@wafertools/wafermap 0.32.0 → 0.33.0

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

@@ -72,7 +72,7 @@ export const USER_GUIDE_HTML=`<div class="wmap-guide">
   .wmap-guide-toc{display:none!important}
 }
 </style>
-<h1 id="wafer-map-user-guide">Wafer Map \u2014 User Guide<span class="wmap-guide-version" title="Built 2026-09-27T14:44:40.685Z">v0.32.0</span></h1>
+<h1 id="wafer-map-user-guide">Wafer Map \u2014 User Guide<span class="wmap-guide-version" title="Built 2026-10-02T10:01:50.772Z">v0.33.0</span></h1>
 <p class="wmap-guide-online-link">This is a quick reference. <a href="https://wafertools.github.io/wafermap/user-guide/" target="_blank" rel="noopener">View the full illustrated guide online \u2197</a></p>
 <p>This guide describes the display and analysis features of the wafer map viewer.
 It is written for users who may be semiconductor test engineers, device engineers, and yield engineers
@@ -97,7 +97,10 @@ display does not change the coordinate labels \u2014 a die at (3, \u22122) alway
 <h3 id="12-wafer-orientation">1.2 Wafer orientation</h3>
 <p>The notch (shown as a V-notch or flat edge) marks the physical reference edge of
 the wafer as configured. Use the <strong>Orientation</strong> toolbar controls to rotate or flip
-the display to match your convention; die coordinates are unaffected.</p>
+the display to match your convention; die coordinates are unaffected. The first rotate
+or flip also switches on the <strong>XY indicator</strong> (the +X/+Y arrows in the Overlays menu), so
+you can see which way the die coordinates now run. It stays on until you switch it off
+there; <strong>Reset orientation</strong> leaves it as it is.</p>
 <div data-wmap-demo="bin-map" class="wmap-demo"></div><p><em>An example wafer bin map above and below the same wafer rotated 90\xB0. The notch has moved, but die coordinates \u2014 shown in tooltips \u2014 remain their original grid/prober values.</em></p>
 <div data-wmap-demo="orientation" class="wmap-demo"></div><h3 id="13-die-appearance">1.3 Die appearance</h3>
 <table>
@@ -281,7 +284,7 @@ shows die tooltips \u2014 a separate thing from the toolbar, which is always pre
 <tr>
 <td><img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9IiMzNzQxNTEiIHN0cm9rZS13aWR0aD0iMS44IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiPjxwYXRoIGQ9Ik0yIDEyczMuNi03IDEwLTcgMTAgNyAxMCA3LTMuNiA3LTEwIDctMTAtNy0xMC03eiIvPjxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjMiLz48L3N2Zz4K" width="20" height="20"></td>
 <td>Overlays</td>
-<td>Check-menu of optional display layers: XY axis indicator, ring boundaries, quadrant lines, die coordinate labels, reticle grid (when geometry is configured), Limit pass/fail (Test Value mode with limits), Test pass/fail (Test Value mode, active test is functional or has recorded verdicts), and <strong>Mark failing dies</strong> (bin modes only). <strong>Clear overlays</strong> at the foot turns off everything in the menu at once, and is greyed when nothing is on \u2014 so the menu also answers &quot;is anything active?&quot; without you auditing every row.</td>
+<td>Check-menu of optional display layers: axis labels, XY axis indicator, ring boundaries, quadrant lines, die coordinate labels, reticle grid (when geometry is configured), Limit pass/fail (Test Value mode with limits), Test pass/fail (Test Value mode, active test is functional or has recorded verdicts), and <strong>Mark failing dies</strong> (bin modes only). <strong>Compact layout</strong> and <strong>Layout diagnostics</strong> sit at the top of the menu (see <a href="#compact-layout" onclick="(function(e){e.preventDefault();var g=e.target.closest('.wmap-guide');var el=g&&g.querySelector('[id=\\'compact-layout\\']');if(el)el.scrollIntoView({behavior:'smooth'});})(event)">Compact layout</a>). <strong>Clear overlays</strong> at the foot turns off everything in the menu at once, and is greyed when nothing is on \u2014 so the menu also answers &quot;is anything active?&quot; without you auditing every row.</td>
 </tr>
 <tr>
 <td><img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9IiMzNzQxNTEiIHN0cm9rZS13aWR0aD0iMS44IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiPjxwYXRoIGQ9Im0xNC42MjIgMTcuODk3LTEwLjY4LTIuOTEzIi8+PHBhdGggZD0iTTE4LjM3NiAyLjYyMmExIDEgMCAxIDEgMy4wMDIgMy4wMDJMMTcuMzYgOS42NDNhLjUuNSAwIDAgMCAwIC43MDdsLjk0NC45NDRhMi40MSAyLjQxIDAgMCAxIDAgMy40MDhsLS45NDQuOTQ0YS41LjUgMCAwIDEtLjcwNyAwTDguMzU0IDcuMzQ4YS41LjUgMCAwIDEgMC0uNzA3bC45NDQtLjk0NGEyLjQxIDIuNDEgMCAwIDEgMy40MDggMGwuOTQ0Ljk0NGEuNS41IDAgMCAwIC43MDcgMHoiLz48cGF0aCBkPSJNOSA4Yy0xLjgwNCAyLjcxLTMuOTcgMy40Ni02LjU4MyAzLjk0OGEuNTA3LjUwNyAwIDAgMC0uMzAyLjgxOWw3LjMyIDguODgzYTEgMSAwIDAgMCAxLjE4NS4yMDRDMTIuNzM1IDIwLjQwNSAxNiAxNi43OTIgMTYgMTUiLz48L3N2Zz4K" width="20" height="20"></td>
@@ -306,7 +309,7 @@ shows die tooltips \u2014 a separate thing from the toolbar, which is always pre
 <tr>
 <td><img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9IiMzNzQxNTEiIHN0cm9rZS13aWR0aD0iMS44IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiPjxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjEwIi8+PHBvbHlnb24gcG9pbnRzPSIxNi4yNCA3Ljc2IDE0LjEyIDE0LjEyIDcuNzYgMTYuMjQgOS44OCA5Ljg4IDE2LjI0IDcuNzYiIGZpbGw9IiMzNzQxNTEiIHN0cm9rZT0ibm9uZSIvPjwvc3ZnPgo=" width="20" height="20"></td>
 <td>Orientation</td>
-<td>Menu of display transforms: <strong>Rotate 90\xB0 clockwise</strong> (applies cumulatively), <strong>Flip horizontal</strong>, <strong>Flip vertical</strong>, and <strong>Reset orientation</strong>. These change only how the wafer is drawn \u2014 die coordinates in tooltips and labels are always the original values, whatever the orientation. Reset is worth knowing about: rotation and mirroring do not combine in the order you applied them, so undoing a few clicks by clicking again does not reliably get you back \u2014 Reset does, and is greyed when you are already there.</td>
+<td>Menu of display transforms: <strong>Rotate 90\xB0 clockwise</strong> (applies cumulatively), <strong>Flip horizontal</strong>, <strong>Flip vertical</strong>, and <strong>Reset orientation</strong>. The first rotate or flip also switches on the XY indicator (see Overlays), which stays on until you switch it off. These change only how the wafer is drawn \u2014 die coordinates in tooltips and labels are always the original values, whatever the orientation. Reset is worth knowing about: rotation and mirroring do not combine in the order you applied them, so undoing a few clicks by clicking again does not reliably get you back \u2014 Reset does, and is greyed when you are already there.</td>
 </tr>
 <tr>
 <td><img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9IiMzNzQxNTEiIHN0cm9rZS13aWR0aD0iMS44IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiPjxwYXRoIGQ9Im0xMyAxMy41IDItMi41LTItMi41Ii8+PHBhdGggZD0ibTIxIDIxLTQuMy00LjMiLz48cGF0aCBkPSJNOSA4LjUgNyAxMWwyIDIuNSIvPjxjaXJjbGUgY3g9IjExIiBjeT0iMTEiIHI9IjgiLz48L3N2Zz4K" width="20" height="20"></td>
@@ -351,7 +354,7 @@ shows die tooltips \u2014 a separate thing from the toolbar, which is always pre
 <tr>
 <td><img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9IiMzNzQxNTEiIHN0cm9rZS13aWR0aD0iMS44IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiPjxwYXRoIGQ9Ik0xNSAzaDZ2NiIvPjxwYXRoIGQ9Ik05IDIxSDN2LTYiLz48cGF0aCBkPSJNMjEgM2wtNyA3Ii8+PHBhdGggZD0iTTMgMjFsNy03Ii8+PC9zdmc+Cg==" width="20" height="20"></td>
 <td>Expand</td>
-<td>Opens the map in an enlarged modal overlay. A maximise button in the modal grows it to fill the window (or press <strong>F</strong>). Press <strong>Esc</strong> or click outside to close. Useful for detailed inspection without changing the main view. Works in the Insights view too, where it opens the whole chart suite in a wide modal \u2014 useful because those charts interact and are best read side by side. Individual charts also have their own expand button.</td>
+<td>Opens the map in an enlarged modal overlay. Opening the Summary panel in it widens the modal by the panel&#39;s width, so the map keeps its size. A maximise button in the modal grows it to fill the window (or press <strong>F</strong>). Press <strong>Esc</strong> or click outside to close. Useful for detailed inspection without changing the main view. Works in the Insights view too, where it opens the whole chart suite in a wide modal \u2014 useful because those charts interact and are best read side by side. Individual charts also have their own expand button.</td>
 </tr>
 <tr>
 <td><img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2IiBmaWxsPSJub25lIiBzdHJva2U9IiMzNzQxNTEiIHN0cm9rZS13aWR0aD0iMS44IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiPjxwYXRoIGQ9Ik0xMy45OTcgNGEyIDIgMCAwIDEgMS43NiAxLjA1bC40ODYuOUEyIDIgMCAwIDAgMTguMDAzIDdIMjBhMiAyIDAgMCAxIDIgMnY5YTIgMiAwIDAgMS0yIDJINGEyIDIgMCAwIDEtMi0yVjlhMiAyIDAgMCAxIDItMmgxLjk5N2EyIDIgMCAwIDAgMS43NTktMS4wNDhsLjQ4OS0uOTA0QTIgMiAwIDAgMSAxMC4wMDQgNHoiLz48Y2lyY2xlIGN4PSIxMiIgY3k9IjEzIiByPSIzIi8+PC9zdmc+Cg==" width="20" height="20"></td>
@@ -396,6 +399,8 @@ highlighting one bin at a time.</p>
 <h3 id="overlays">Overlays</h3>
 <p>Use the <strong>Overlays</strong> menu to toggle optional display layers on and off:</p>
 <ul>
+<li><strong>Axis labels</strong> \u2014 the die coordinates along the bottom and left edges. They appear when you zoom; this row shows
+them all the time, or hides them. <strong>Clear overlays</strong> returns to showing them on zoom</li>
 <li><strong>XY axis indicator</strong> \u2014 shows X and Y axis lines through the wafer centre</li>
 <li><strong>Ring boundaries</strong> \u2014 concentric ring divisions that match the spatial analysis zones</li>
 <li><strong>Quadrant lines</strong> \u2014 divides the wafer into N, S, E, W quadrants</li>
@@ -405,6 +410,33 @@ highlighting one bin at a time.</p>
 <li><strong>Test pass/fail</strong> \u2014 pass/fail colouring for Test Value mode, coloured by the tester&#39;s recorded verdict; always on for a functional (no measured value) active test</li>
 </ul>
 <div data-wmap-demo="overlays" class="wmap-demo"></div><p><em>Ring boundaries, quadrant lines, and XY indicator all active.</em></p>
+<h3 id="compact-layout">Compact layout</h3>
+<p>On a multi-project wafer, each reticle holds only a few of your dies, so the map is mostly empty and the dies you care
+about are small. When the occupied columns and rows repeat at a regular pitch, the Overlays menu offers
+<strong>Compact layout</strong>. Switch it on and the empty rows and columns disappear, so your dies are drawn as one grid at a
+much larger size, with each group of dies outlined so you can still see the reticles they came from.</p>
+<ul>
+<li><strong>Nothing is left out.</strong> Only the arrangement changes. Every die is still drawn and counted, so the legend, yield
+and statistics are the same as in the wafer view. A die that has no bin (for example one that carries metadata only)
+keeps its place, shown in the no-data grey.</li>
+<li><strong>Coordinates stay original.</strong> Hovering a die and the axis labels give its real die coordinates, not its position
+in the compact grid.</li>
+<li><strong>Orientation.</strong> The notch marker shows the wafer orientation and follows rotation and flips. The <strong>XY indicator</strong>
+works as it does on the wafer view, drawn in a margin beside the grid.</li>
+<li><strong>No wafer outline.</strong> The wafer circle, ring boundaries, quadrant lines and reticle grid describe the physical
+wafer, which the compact grid no longer follows, so those rows are greyed out while the layout is on.</li>
+<li><strong>Galleries.</strong> All cards share one layout, built from every wafer shown, so wafers can be compared cell for cell.
+Each card is as tall as its map needs, so more of them fit on screen; a quarter turn swaps a card&#39;s width and height.</li>
+<li><strong>Axis labels.</strong> With the Axis labels row on, the first column of each group of dies is labelled with its real die
+coordinate, which marks the reticle boundaries; zoom in far enough and every die is labelled.</li>
+<li><strong>When it is offered.</strong> The layout is offered when the occupied columns and rows repeat. If you supply
+<code>reticleConfig</code>, it is offered when they repeat at the reticle width and height or a multiple of it (a product on every second reticle repeats at twice the width). Random missing dies do not repeat, so
+a wafer that merely has holes is not offered it. Developers can switch it on regardless with
+<code>viewOptions: { compact: true }</code>.</li>
+</ul>
+<p><strong>Layout diagnostics</strong> (also in the Overlays menu) shows what the detector saw as counts and scores only: it holds no
+die positions, bins, test values or wafer names. If a layout is not recognised the way you expect, copy the text or save
+it as a file and send it to whoever supports this software.</p>
 <h3 id="keyboard-shortcuts">Keyboard shortcuts</h3>
 <table>
 <thead>
@@ -624,7 +656,7 @@ there does what it normally does.</p>
 detected patterns on the wafer. Open it from the toolbar.</p>
 <p>Each finding shows:</p>
 <ul>
-<li><strong>Severity</strong> \u2014 Unusual, Notable, or Info (ordered most to least significant)</li>
+<li><strong>Severity</strong> \u2014 Unusual, Notable, or Minor (ordered most to least significant)</li>
 <li><strong>Description</strong> \u2014 plain-language summary of what was detected and where</li>
 <li><strong>Click to highlight</strong> \u2014 clicking a finding fades the rest of the wafer and outlines the
 affected dies. A finding about a bin also filters the legend to that bin, so the legend
@@ -698,31 +730,56 @@ highlight the affected dies.</em></p>
 panel is computed over. For several wafers the heading names them: <strong>Lot
 LOT123 \xB7 13 wafers</strong> when every wafer comes from that one lot, otherwise
 <strong>26 wafers from 2 lots</strong> (or just <strong>13 wafers</strong> when the data records no lot).
-The panel only says &quot;lot&quot; when it really is one lot. &quot;Mean wafer yield&quot; is an
+The panel only says &quot;lot&quot; when it really is one lot. &quot;Mean per-wafer yield&quot; is an
 <em>unweighted</em> mean of each wafer&#39;s own yield; it is deliberately not the same
 statistic as the bin breakdown&#39;s pass-bin share, which weights every die
 equally. The two agree only when die counts are even across the wafers.</li>
-<li><strong>Findings</strong> \u2014 detected anomalies, most severe first. Severity chips narrow
+<li><strong>What stands out</strong> \u2014 the headline (the yield, and for a lot its spread across
+wafers), then up to three items ranked by how many dies each costs, an &quot;also&quot;
+line for any others over a yield point, and a line saying what was compared. An
+item names a region, a wafer or a test and, for a region, the failing bins that make up
+its shortfall; a test is an item when it is outside its limits (or a functional test
+fails) on a share of the dies that clears the same floor. Its three dots and word (High, Moderate or Low impact) say how
+much of the lot it costs: the higher of its share of all the dies (2% moderate, 4% high)
+and its share of the dies that fail (15% moderate, 40% high), so a small area that is most
+of a good lot&#39;s loss still reads as high. Click a name to highlight that finding on the map.
+A <strong>Watch</strong> line (at most two) follows for things that cost no dies yet: a lot of five or more
+wafers whose yield, or a test&#39;s mean, trends up or down across the wafers <em>in the order given</em>
+(said as &quot;input order&quot;: the order is only a physical one if you know it is), and a test whose
+Ppk against its limits is under 1.0.
+A wafer or lot with nothing over a yield point says so: &quot;Nothing stands out&quot;.
+The reports open with the same section, and <strong>Full report</strong> at the foot of it opens the
+report; in a report opened from the panel, clicking a finding&#39;s row shows it on the map.</li>
+<li><strong>Findings</strong> \u2014 detected anomalies, most severe first, each group marked with
+three dots filled by severity (Unusual, Notable, Minor). Severity chips narrow
 the list; Kind and Region dropdowns appear once there are enough findings to
-be worth narrowing.</li>
+be worth narrowing. <strong>Detail</strong> opens the same sentences above a readable list.</li>
 <li><strong>Bin breakdown</strong> \u2014 bars as a share of dies, pass bins first and then failing
 bins by descending count, so the dominant failure mode is at the top. It
 follows the map&#39;s plot mode: a soft-bin map gets a soft-bin breakdown. When a
 wafer carries both bin types, a <strong>Hard / Soft</strong> selector in the section header
 overrides that.</li>
 <li><strong>Region yield</strong> \u2014 ring yield by default, with a <strong>Ring / Quadrant</strong> selector.
+Each row prints its difference from the wafer&#39;s yield in points and is tinted
+when it is 1, 2 or 4 or more points below it (nothing above is tinted).
 Ring is the default because edge roll-off is the pattern that dominates real
 wafer maps; a genuinely asymmetric quadrant is reported as a finding above,
 with a significance test behind it.</li>
 <li><strong>Wafer yield</strong> (several wafers only) \u2014 one bar per wafer with the median
-marked. Wafers are in slot order by default, since that is what makes a
+marked, each row&#39;s difference from the median in points, and a tint when it is
+1, 2 or 4 or more points below it. Wafers are in slot order by default, since that is what makes a
 slot-correlated pattern visible; a <strong>Slot / Yield</strong> selector re-sorts. Wafers
-far below the rest are labelled &quot;low outlier&quot;.</li>
+well below or above the rest are labelled &quot;low outlier&quot; or &quot;high outlier&quot;
+(3 or more wafers, and at least 3 points from the median \u2014 the same rule as the
+outlier-wafer findings).</li>
 <li><strong>Test values</strong> \u2014 per test: mean, <strong>Ppk</strong>, and limit yield. Ppk (not Cpk)
 because it measures against the <em>overall</em> spread, including wafer-to-wafer
 variation, which is what the dies actually ship against. The full descriptive
 statistics \u2014 min, quartiles, median, max, \u03C3, both test limits, and all four
-capability indices \u2014 are in the summary report and the CSV export.</li>
+capability indices \u2014 are in the CSV export, and the wafer summary report shows
+N, min, quartiles, median, mean, max, \u03C3 and limit yield (a lot&#39;s report has N, min, mean,
+max, \u03C3 and limit yield: quartiles cannot be combined from each wafer&#39;s own). Both reports
+also carry the full Cp, Cpk, Pp and Ppk table.</li>
 <li><strong>Functional tests</strong> \u2014 pass/fail counts and pass rate per functional test.</li>
 </ul>
 <p>Every section header can be collapsed, and stays collapsed as the panel
@@ -730,7 +787,13 @@ re-renders.</p>
 <p>A <strong>Summary report</strong> button (when present) opens a printable full-detail
 report \u2014 yield, bin breakdown, ring and quadrant statistics, the full per-test
 table with Cp/Cpk/Pp/Ppk, and the findings list \u2014 and can be saved as a PDF
-from your browser&#39;s print dialog.</p>
+from your browser&#39;s print dialog. It opens with <strong>What stands out</strong>: the yield,
+up to three regions, fail bins or wafers ranked by how many dies each costs, and a
+line saying what was compared. An item is listed only when it costs at least one
+yield point of the dies analysed; a lot with none says so. Each figure links to its
+row in the Findings table below. Severity is drawn as three dots and a word, so it reads in a
+black-and-white print; yields carry a bar, and a wafer or region is tinted only when it is
+at least a point below the rest.</p>
 <h3 id="why-some-findings-name-two-bins">Why some findings name two bins</h3>
 <p>A finding may read <strong>&quot;hard bin and soft bin 3 (Fail) (same dies)&quot;</strong>. That is one
 group of dies counted in two bin spaces, not two separate groups added together.

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

@@ -1,3 +1,3 @@
-export declare const WMAP_VERSION = "0.32.0";
-export declare const WMAP_BUILD_TIME = "2026-09-27T14:45:45.383Z";
+export declare const WMAP_VERSION = "0.33.0";
+export declare const WMAP_BUILD_TIME = "2026-10-02T10:03:26.613Z";
 //# sourceMappingURL=version.d.ts.map

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

@@ -1 +1 @@
-export const WMAP_VERSION="0.32.0",WMAP_BUILD_TIME="2026-09-27T14:45:45.383Z";
+export const WMAP_VERSION="0.33.0",WMAP_BUILD_TIME="2026-10-02T10:03:26.613Z";

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

@@ -1,4 +1,10 @@
 export type AggregationMethod = 'mean' | 'median' | 'stddev' | 'min' | 'max' | 'count';
+/**
+ * Whether a stack by this method holds measurements of the test, in its units.
+ * A mean, median, minimum or maximum does; a standard deviation is a spread and a
+ * count is a tally, so the test's limits say nothing about them.
+ */
+export declare function stackHoldsMeasurements(method: string): boolean;
 /** Minimal die shape required by aggregation functions — satisfied by both Die and DieResult. */
 export interface DieLike {
     x: number;

package/dist/packages/core/aggregates.js

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

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

@@ -0,0 +1,205 @@
+/**
+ * Detection of a repeating multi-project-wafer (MPW) layout, the gate for the compact view.
+ *
+ * On an MPW only a few parts sit in each reticle, so the occupied columns and rows form a
+ * pattern that repeats at the reticle pitch. Random missing data does not repeat, which is
+ * what separates the two: hiding the empty rows of a wafer that merely has holes could hide
+ * a real problem, so compaction is only offered when a clear period is found.
+ *
+ * "Occupied" means a die EXISTS at that index, whether or not it carries a bin: a die with
+ * only metadata still has a position, and the layout must not change with the colour mode.
+ */
+export interface MpwDetectOptions {
+    /** Fewest whole repeats of the period the axis must span. Default 3. */
+    minRepeats?: number;
+    /**
+     * Lowest lag correlation of the occupancy signal that counts as a period. Default 0.75:
+     * random sparse layouts score under 0.5 at every lag, while a clean MPW with a few
+     * reticle columns missing outright still scores above it.
+     */
+    minScore?: number;
+    /** Occupied fraction above which an axis is dense: nothing worth compacting. Default 0.8. */
+    maxDensity?: number;
+    /**
+     * A unit the host already knows, such as a reticle width or height in dies. Only that unit and
+     * its multiples are tested (devices on every second reticle repeat at twice the reticle, a
+     * cluster that repeats within a reticle at a divisor of it, which the multiples reach too), so
+     * the check still has to pass (the occupied indices must actually repeat) but nothing else is
+     * inferred.
+     */
+    expectedPeriod?: number;
+}
+/** A period found on one axis. */
+export interface MpwPeriod {
+    /** Indices between one repeat and the next. */
+    period: number;
+    /** Lag correlation of the occupancy signal at `period`, 0 to 1. */
+    score: number;
+    /** Whole repeats of the period within the occupied span. */
+    repeats: number;
+    /** Occupied indices as a fraction of the span between the first and last. */
+    occupiedFraction: number;
+}
+/**
+ * Find the smallest period at which the occupied indices of one axis repeat.
+ *
+ * `indices` are the distinct integer indices that hold at least one die, in any order.
+ * Returns `null` when the axis is nearly full (nothing to compact), spans too few repeats,
+ * or does not repeat: random sparse data scores near zero at every period.
+ */
+export declare function detectMpwPeriod(indices: readonly number[], options?: MpwDetectOptions): MpwPeriod | null;
+/** What one axis looks like for the purposes of the compact gate. */
+export type AxisPattern = ({
+    kind: 'periodic';
+} & MpwPeriod) | {
+    kind: 'dense';
+    occupiedFraction: number;
+} | {
+    kind: 'none';
+};
+export interface MpwLayout {
+    x: AxisPattern;
+    y: AxisPattern;
+    /** True when compaction should be offered. */
+    offered: boolean;
+}
+/**
+ * Decide whether the compact view applies to a set of dies.
+ *
+ * Offered when both axes repeat, or one repeats and the other is dense (a layout that is
+ * sparse in one direction only still has empty rows or columns worth removing). Pass the
+ * dies of every wafer in the selection, so the answer, and the layout built from it, is
+ * the same for every card in a gallery. Unpositioned dies are ignored.
+ */
+export declare function detectMpwLayout(dies: readonly {
+    x?: number | null;
+    y?: number | null;
+}[], options?: Omit<MpwDetectOptions, 'expectedPeriod'> & {
+    reticle?: {
+        width: number;
+        height: number;
+    };
+}): MpwLayout;
+/**
+ * The compact layout of a set of dies: which original columns and rows survive, and the
+ * indices they take. Only the layout, never the dies themselves, so one map can be built
+ * from every wafer in a selection and applied to each, giving all gallery cards one grid.
+ */
+export interface CompactMap {
+    /** Original die `x` of each compact column, ascending. All coordinates shown to a user are these. */
+    readonly columns: readonly number[];
+    /** Original die `y` of each compact row, ascending. */
+    readonly rows: readonly number[];
+    /** Compact columns that follow a skipped range of original columns (so a group of columns starts there). */
+    readonly columnBreaks: readonly number[];
+    /** Compact rows that follow a skipped range of original rows. */
+    readonly rowBreaks: readonly number[];
+    /**
+     * The blocks the layout falls into: each is a run of compact columns and a run of compact
+     * rows, `[start, end)`, with no skipped original index inside either, and at least one
+     * die of the layout in it. On an MPW these are the reticle groups the dies sit in, so
+     * drawing each as a box keeps them distinct once the gaps between them are gone.
+     */
+    readonly groups: readonly CompactGroup[];
+    /** Compact column of an original `x`, or `undefined` when no die of the layout sits in it. */
+    columnOf(x: number): number | undefined;
+    /** Compact row of an original `y`, or `undefined` when no die of the layout sits in it. */
+    rowOf(y: number): number | undefined;
+}
+/** A block of compact cells with no skipped original index inside it; see `CompactMap.groups`. */
+export interface CompactGroup {
+    readonly columns: readonly [start: number, end: number];
+    readonly rows: readonly [start: number, end: number];
+}
+/**
+ * Build the compact layout for `dies`: the columns and rows that hold at least one die,
+ * renumbered 0..n-1 in order. A die EXISTS there whether or not it carries a bin (see the
+ * note at the top of this file), so the layout never depends on colour mode, filters or
+ * which wafer has data. Unpositioned dies are ignored.
+ */
+export declare function buildCompactMap(dies: readonly {
+    x?: number | null;
+    y?: number | null;
+}[]): CompactMap;
+/** A die with the compact cell it is drawn in. */
+export interface CompactPlacement<T> {
+    die: T;
+    column: number;
+    row: number;
+}
+/**
+ * Place `dies` on a compact grid. With no `basis` the layout is built from `dies`; pass the
+ * dies of every wafer in a selection as `basis` so each wafer lands on the same grid. Every
+ * positioned die is placed, none dropped: a die whose column or row is missing from the
+ * layout throws, since that is a layout built from the wrong dies, not data to hide.
+ */
+export declare function compactDies<T extends {
+    x?: number | null;
+    y?: number | null;
+}>(dies: readonly T[], basis?: readonly {
+    x?: number | null;
+    y?: number | null;
+}[] | CompactMap): {
+    placements: CompactPlacement<T>[];
+    map: CompactMap;
+};
+/**
+ * Whether the compact layout should be offered for the dies of one map or of every map in a
+ * gallery. The single rule both renderers use: `reticles` holds one entry per map, and a
+ * reticle size fixes the period only when every map supplies the same one; otherwise the
+ * period is inferred from the dies.
+ */
+export declare function compactLayoutOffered(dies: readonly {
+    x?: number | null;
+    y?: number | null;
+}[], reticles: readonly ({
+    width: number;
+    height: number;
+} | undefined)[], options?: Omit<MpwDetectOptions, 'expectedPeriod'>): boolean;
+/** What the detector saw on one axis. Counts and scores only: no index or coordinate. */
+export interface AxisDiagnostics {
+    /** Distinct indices that hold a die. */
+    occupied: number;
+    /** Indices from the first occupied to the last. */
+    span: number;
+    /** Maximal runs of consecutive occupied indices. */
+    runs: number;
+    pattern: AxisPattern;
+    /** The best-scoring candidate periods, whether or not any passed. */
+    bestPeriods: {
+        period: number;
+        score: number;
+    }[];
+}
+export interface MpwDiagnostics {
+    wafers: number;
+    positionedDies: number;
+    unpositionedDies: number;
+    /** Blocks of compact cells that hold dies. */
+    groups: number;
+    reticle: {
+        width: number;
+        height: number;
+    } | undefined;
+    offered: boolean;
+    thresholds: Required<Omit<MpwDetectOptions, 'expectedPeriod'>>;
+    columns: AxisDiagnostics;
+    rows: AxisDiagnostics;
+}
+/**
+ * Everything the compact gate saw, as numbers a host can show a user and ask them to send
+ * back. It exists because the detector's thresholds cannot be tuned on data nobody can
+ * share, so what it needs to report must carry no die position, bin, value or identity:
+ * counts, fractions, scores and periods only. `reticles` holds one entry per map, as for
+ * `compactLayoutOffered`, which this agrees with by construction.
+ */
+export declare function diagnoseMpwLayout(dies: readonly {
+    x?: number | null;
+    y?: number | null;
+}[], reticles: readonly ({
+    width: number;
+    height: number;
+} | undefined)[], options?: Omit<MpwDetectOptions, 'expectedPeriod'>): MpwDiagnostics;
+/** The text a user copies and sends back. Plain lines, so it can be read before it is sent. */
+export declare function formatMpwDiagnostics(d: MpwDiagnostics, library: string): string;
+//# sourceMappingURL=compact.d.ts.map

package/dist/packages/core/compact.js

@@ -0,0 +1,3 @@
+import{hasPosition as a}from"./dies.js";const h={minRepeats:3,minScore:.75,maxDensity:.8};function w(t,e){const s=t.length-e;if(s<2)return 0;let r=0,o=0,n=0,i=0,d=0;for(let u=0;u<s;u++){const p=t[u],l=t[u+e];r+=p,o+=l,n+=p*p,i+=l*l,d+=p*l}const f=n-r*r/s,c=i-o*o/s;return f<=0||c<=0?0:(d-r*o/s)/Math.sqrt(f*c)}function x(t,e,s){const r=Math.floor(t/e),o=[];if(s!==void 0&&s>=1){const n=Math.floor(s);for(let i=n;i<=r;i+=n)i>=2&&o.push(i)}else for(let n=2;n<=r;n++)o.push(n);return o}function g(t){if(t.length===0)return null;let e=1/0,s=-1/0;for(const n of t)n<e&&(e=n),n>s&&(s=n);const r=new Uint8Array(s-e+1);let o=0;for(const n of t)r[n-e]||(r[n-e]=1,o++);return{signal:r,count:o}}export function detectMpwPeriod(t,e={}){const{minRepeats:s,minScore:r,maxDensity:o}={...h,...e},{expectedPeriod:n}=e,i=g(t);if(!i)return null;const d=i.signal.length,f=i.count/d;if(f>o)return null;for(const c of x(d,s,n)){const u=w(i.signal,c);if(u>=r)return{period:c,score:u,repeats:Math.floor(d/c),occupiedFraction:f}}return null}function m(t,e){const{minRepeats:s,maxDensity:r}={...h,...e},o=detectMpwPeriod(t,e);if(o)return{kind:"periodic",...o};const n=g(t);return n&&n.count>=s&&n.count/n.signal.length>r?{kind:"dense",occupiedFraction:n.count/n.signal.length}:{kind:"none"}}export function detectMpwLayout(t,e={}){const{reticle:s,...r}=e,o=new Set,n=new Set;for(const c of t)a(c)&&(o.add(c.x),n.add(c.y));const i=m([...o],{...r,expectedPeriod:s?.width}),d=m([...n],{...r,expectedPeriod:s?.height}),f=i.kind==="periodic"&&(d.kind==="periodic"||d.kind==="dense")||d.kind==="periodic"&&i.kind==="dense";return{x:i,y:d,offered:f}}function y(t,e){const s=[0,...e,t],r=new Int32Array(t);for(let o=0;o+1<s.length;o++)r.fill(o,s[o],s[o+1]);return{ids:r,bounds:s}}function $(t){const e=[...t].sort((o,n)=>o-n),s=[],r=new Map;return e.forEach((o,n)=>{r.set(o,n),n>0&&o-e[n-1]>1&&s.push(n)}),{sorted:e,breaks:s,indexOf:r}}export function buildCompactMap(t){const e=new Set,s=new Set;for(const c of t)a(c)&&(e.add(c.x),s.add(c.y));const r=$(e),o=$(s),n=y(r.sorted.length,r.breaks),i=y(o.sorted.length,o.breaks),d=new Set;for(const c of t)a(c)&&d.add(n.ids[r.indexOf.get(c.x)]*i.bounds.length+i.ids[o.indexOf.get(c.y)]);return{groups:[...d].sort((c,u)=>c-u).map(c=>{const u=Math.floor(c/i.bounds.length),p=c%i.bounds.length;return{columns:[n.bounds[u],n.bounds[u+1]],rows:[i.bounds[p],i.bounds[p+1]]}}),columns:r.sorted,rows:o.sorted,columnBreaks:r.breaks,rowBreaks:o.breaks,columnOf:c=>r.indexOf.get(c),rowOf:c=>o.indexOf.get(c)}}export function compactDies(t,e){const s=e&&"columnOf"in e?e:buildCompactMap(e??t),r=[];for(const o of t){if(!a(o))continue;const n=s.columnOf(o.x),i=s.rowOf(o.y);if(n===void 0||i===void 0)throw new RangeError(`compactDies: die (${o.x}, ${o.y}) is outside the compact layout`);r.push({die:o,column:n,row:i})}return{placements:r,map:s}}export function compactLayoutOffered(t,e,s={}){return detectMpwLayout(t,{...s,reticle:b(e)}).offered}function b(t){const e=t[0];return e&&t.every(s=>s&&s.width===e.width&&s.height===e.height)?{width:e.width,height:e.height}:void 0}function k(t,e){const{minRepeats:s}={...h,...e},r=g(t);if(!r)return{occupied:0,span:0,runs:0,pattern:{kind:"none"},bestPeriods:[]};let o=0;r.signal.forEach((i,d)=>{i&&!r.signal[d-1]&&o++});const n=[];for(const i of x(r.signal.length,s,e.expectedPeriod))n.push({period:i,score:w(r.signal,i)});return n.sort((i,d)=>d.score-i.score||i.period-d.period),{occupied:r.count,span:r.signal.length,runs:o,pattern:m(t,e),bestPeriods:n.slice(0,5)}}export function diagnoseMpwLayout(t,e,s={}){const r=b(e),o=new Set,n=new Set;let i=0;for(const d of t)a(d)&&(i++,o.add(d.x),n.add(d.y));return{wafers:e.length,positionedDies:i,unpositionedDies:t.length-i,groups:buildCompactMap(t).groups.length,reticle:r,offered:detectMpwLayout(t,{...s,reticle:r}).offered,thresholds:{...h,...s},columns:k([...o],{...s,expectedPeriod:r?.width}),rows:k([...n],{...s,expectedPeriod:r?.height})}}function D(t,e){const s=e.span>0?` (${(100*e.occupied/e.span).toFixed(1)}%)`:"",r=e.pattern.kind==="periodic"?`periodic, period ${e.pattern.period}, score ${e.pattern.score.toFixed(3)}, ${e.pattern.repeats} repeats`:e.pattern.kind==="dense"?"dense, nothing to compact":"no repeating pattern found",o=e.bestPeriods.length?`
+  best periods: ${e.bestPeriods.map(n=>`${n.period} (${n.score.toFixed(3)})`).join(", ")}`:"";return`${t}: ${e.occupied} occupied of ${e.span}${s}, ${e.runs} runs; ${r}${o}`}export function formatMpwDiagnostics(t,e){return["wafermap compact-layout diagnostics (format 1)",`library: ${e}`,"Counts and scores only: no die coordinates, bins, test values or wafer identity.",`wafers: ${t.wafers}`,`dies: ${t.positionedDies} positioned, ${t.unpositionedDies} without a position`,`reticle size: ${t.reticle?`${t.reticle.width} x ${t.reticle.height} (supplied by every wafer)`:"not supplied"}`,`compact layout offered: ${t.offered?"yes":"no"}`,`groups of dies: ${t.groups}`,`thresholds: minRepeats ${t.thresholds.minRepeats}, minScore ${t.thresholds.minScore}, maxDensity ${t.thresholds.maxDensity}`,D("columns",t.columns),D("rows",t.rows)].join(`
+`)}

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

@@ -23,6 +23,12 @@ export declare function itemPassBins(item: {
 } | null | undefined, fallback?: readonly number[]): readonly number[];
 /** Same bins, in any order. */
 export declare function sameBins(a: readonly number[], b: readonly number[]): boolean;
+/**
+ * The pass bins every wafer is judged by, or `undefined` when they differ (or there are none to
+ * ask). For a surface that must name one set — a headline, or which bins count as failures — and
+ * so says nothing rather than naming one wafer's set for a population judged several ways.
+ */
+export declare function commonPassBins(sets: Iterable<readonly number[] | undefined>): readonly number[] | undefined;
 /**
  * Names the pass bins in use, for a yield label: "bin 1", "bins 1, 2", or —
  * when the wafers shown disagree — "per wafer: bin 1 · bins 1, 2". A label that

package/dist/packages/core/passBins.js

@@ -1 +1 @@
-export const INPUT_DEFAULT_PASS_BINS=[1];export function itemPassBins(s,e=INPUT_DEFAULT_PASS_BINS){return s?.passBins??e}export function sameBins(s,e){const t=new Set(s),n=new Set(e);return t.size===n.size&&[...t].every(i=>n.has(i))}export function passBinsLabel(s){const e=[];for(const n of s)e.some(i=>sameBins(i,n))||e.push(n);const t=n=>n.length===0?"no bins":n.length===1?`bin ${n[0]}`:`bins ${n.join(", ")}`;return e.length<=1?t(e[0]??INPUT_DEFAULT_PASS_BINS):`per wafer: ${e.map(t).join(" \xB7 ")}`}
+export const INPUT_DEFAULT_PASS_BINS=[1];export function itemPassBins(s,n=INPUT_DEFAULT_PASS_BINS){return s?.passBins??n}export function sameBins(s,n){const t=new Set(s),e=new Set(n);return t.size===e.size&&[...t].every(i=>e.has(i))}export function commonPassBins(s){let n;for(const t of s){if(t===void 0)return;if(n===void 0)n=t;else if(!sameBins(n,t))return}return n}export function passBinsLabel(s){const n=[];for(const e of s)n.some(i=>sameBins(i,e))||n.push(e);const t=e=>e.length===0?"no bins":e.length===1?`bin ${e[0]}`:`bins ${e.join(", ")}`;return n.length<=1?t(n[0]??INPUT_DEFAULT_PASS_BINS):`per wafer: ${n.map(t).join(" \xB7 ")}`}

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

@@ -1,3 +1,17 @@
+/**
+ * Which columns (or rows) of a compact layout get an axis label.
+ *
+ * Group starts when the cells are too narrow to label every one: each is the first column of
+ * a reticle group, so the labels name the boundaries, there are few of them, and they are
+ * spread out. Every cell once there is room for that, so a zoomed-in map labels each die.
+ * A layout with a single group has no boundaries to name, so it is thinned evenly instead.
+ *
+ * @param count     cells on the axis
+ * @param breaks    compact indices that start a group after the first (see `CompactMap`)
+ * @param cellPx    on-screen size of one cell along the axis
+ * @param minGapPx  least distance between two labels
+ */
+export declare function compactTickIndices(count: number, breaks: readonly number[], cellPx: number, minGapPx: number): number[];
 /**
  * Round a raw spacing to the nearest 1, 2 or 5 × 10ⁿ — THE rounding rule for
  * every tick grid in the library, the wafer map's own mm axes included.

package/dist/packages/renderer/axisTicks.js

@@ -1 +1 @@
-export function niceStep(i){if(!(i>0)||!Number.isFinite(i))return 0;const n=Math.pow(10,Math.floor(Math.log10(i))),t=i/n;return(t<1.5?1:t<3.5?2:t<7.5?5:10)*n}export function stepDecimals(i){if(!(i>0)||!Number.isFinite(i))return 0;for(let n=0;n<=9;n++){const t=i*10**n;if(Math.abs(t-Math.round(t))<1e-6*Math.max(1,t))return n}return 9}function M(i,n,t){const c=Math.ceil(i/t-1e-9)*t,e=[];for(let r=c;r<=n+t*1e-9;r+=t)e.push(Number((Math.round(r/t)*t).toFixed(stepDecimals(t)+2)));return e}export function fitTicks(i,n,t,c){const e=n-i;if(!(e>0)||!Number.isFinite(e)||!(t>0))return{ticks:Number.isFinite(i)?[i]:[],step:0};const r=[1,2,5];let f=Math.floor(Math.log10(e/Math.max(1,t/4))),u=0;for(let a=0;a<60;a++){const o=Number((r[u]*10**f).toPrecision(12)),s=M(i,n,o);if(s.length<=1||o/e*t>=c(o,s))return{ticks:s,step:o};++u===r.length&&(u=0,f++)}return{ticks:[i,n],step:e}}
+export function compactTickIndices(e,n,t,s){if(e<=0)return[];const r=Math.max(1,Math.ceil(s/Math.max(t,1e-9)));if(r===1)return Array.from({length:e},(i,c)=>c);if(n.length===0){const i=[];for(let c=0;c<e;c+=r)i.push(c);return i}const o=[];let u=-1/0;for(const i of[0,...n])((i-u)*t>=s||o.length===0)&&(o.push(i),u=i);return o}export function niceStep(e){if(!(e>0)||!Number.isFinite(e))return 0;const n=Math.pow(10,Math.floor(Math.log10(e))),t=e/n;return(t<1.5?1:t<3.5?2:t<7.5?5:10)*n}export function stepDecimals(e){if(!(e>0)||!Number.isFinite(e))return 0;for(let n=0;n<=9;n++){const t=e*10**n;if(Math.abs(t-Math.round(t))<1e-6*Math.max(1,t))return n}return 9}function h(e,n,t){const s=Math.ceil(e/t-1e-9)*t,r=[];for(let o=s;o<=n+t*1e-9;o+=t)r.push(Number((Math.round(o/t)*t).toFixed(stepDecimals(t)+2)));return r}export function fitTicks(e,n,t,s){const r=n-e;if(!(r>0)||!Number.isFinite(r)||!(t>0))return{ticks:Number.isFinite(e)?[e]:[],step:0};const o=[1,2,5];let u=Math.floor(Math.log10(r/Math.max(1,t/4))),i=0;for(let c=0;c<60;c++){const f=Number((o[i]*10**u).toPrecision(12)),a=h(e,n,f);if(a.length<=1||f/r*t>=s(f,a))return{ticks:a,step:f};++i===o.length&&(i=0,u++)}return{ticks:[e,n],step:r}}

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

@@ -4,6 +4,7 @@ import type { Reticle } from '../core/reticle.js';
 import type { DieMetadata, WaferMetadata } from '../core/metadata.js';
 import { type Affine } from '../core/transforms.js';
 import { type BinColors } from './binColors.js';
+import type { CompactMap } from '../core/compact.js';
 import type { TestDef, BinDef, MetadataFieldDef, ReticleConfig } from './buildWaferMap.js';
 import { classifySpec, type SpecCategory } from './spec.js';
 export { classifySpec };
@@ -89,7 +90,7 @@ export interface ViewHoverPoint {
     y: number;
 }
 export interface ViewOverlay {
-    kind: 'wafer-boundary' | 'reticle' | 'probe-path' | 'ring-boundary' | 'quadrant-boundary' | 'xy-indicator';
+    kind: 'wafer-boundary' | 'reticle' | 'probe-path' | 'ring-boundary' | 'quadrant-boundary' | 'xy-indicator' | 'compact-group';
     points: Point[][];
     closed: boolean;
     lineColor: string;
@@ -267,6 +268,21 @@ export interface View {
         pass: number;
         fail: number;
     };
+    /**
+     * Present only on a compact view (see `ViewOptions.compact`): the original die coordinate of
+     * each compact column and row, and the compact index that sits at the display origin.
+     * Axis labels read this instead of inverting `gridToScreen`, so they stay original die
+     * coordinates, never compact indices.
+     */
+    compact?: {
+        columns: readonly number[];
+        rows: readonly number[];
+        /** Compact indices that start a group after the first, per axis: where the axis labels go. */
+        columnBreaks: readonly number[];
+        rowBreaks: readonly number[];
+        centreColumn: number;
+        centreRow: number;
+    };
     /** Bounding box of all die centres in scene coordinates (mm). */
     dieBounds: {
         minX: number;
@@ -316,6 +332,15 @@ export interface ViewOptions {
         flipX?: boolean;
         flipY?: boolean;
     };
+    /**
+     * Draw the dies on this compact layout (see `buildCompactMap`) instead of at their physical
+     * positions: the empty columns and rows are gone, each group of dies is outlined, and the
+     * wafer outline, rings, quadrants, reticle grid and XY indicator are not drawn, because the
+     * dies no longer sit where they are. Every die is still drawn and still counts: only the
+     * layout changes. Rotation, flips and the notch marker follow the same transform as the
+     * physical view.
+     */
+    compact?: CompactMap;
     /**
      * Explicit value colour normalization range.
      *