feat(ci): build styled macOS DMG headlessly via dmgbuild (#189)

- Add scripts/build-dmg.py using dmgbuild to generate DMGs with custom background art and icon locations without Finder AppleScript.
- Update .gitea/workflows/build-macos.yml and .github/workflows/build-macos.yml to package the .app bundle using dmgbuild in a headless virtual environment.
- Resolves missing DMG background in CI while preventing AppleScript GUI automation timeouts.

.gitea/workflows/build-linux.yml

@@ -64,6 +64,9 @@ jobs:
       - name: Install Node dependencies
         run: npm ci
 
+      - name: Run frontend tests
+        run: npm test
+
       - name: Set Release Environment
         id: set_env
         shell: bash

.gitea/workflows/build-macos.yml

@@ -9,33 +9,45 @@ jobs:
   build-macos:
     name: Build macOS (${{ matrix.platform.name }})
     runs-on: ${{ matrix.platform.os }}
+    env:
+      XDG_CONFIG_HOME: ${{ runner.temp }}/.config
     strategy:
       matrix:
         platform:
           - name: Intel
-            os: macos-15-intel
+            os: macos
             target: x86_64-apple-darwin
             binary_dir: macos-x86_64
             arch: x86_64
           - name: Apple Silicon
-            os: macos-15
+            os: macos
             target: aarch64-apple-darwin
             binary_dir: macos-aarch64
             arch: arm64
-          - name: Universal (Intel + Apple Silicon)
+#          - name: Universal (Intel + Apple Silicon)
-            os: macos-15
+#            os: macos
-            target: universal-apple-darwin
+#            target: universal-apple-darwin
-            binary_dir: macos-universal
+#            binary_dir: macos-universal
-            arch: universal
+#            arch: universal
     
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Ensure workspace and git permissions
+        run: |
+          mkdir -p "${{ runner.temp }}/.config/git"
+          touch "${{ runner.temp }}/.config/git/ignore"
+          mkdir -p .git/info
+          touch .git/info/exclude
+          chmod -R u+rwX .git || true
+          chmod 644 .git/info/exclude || true
+          git config --local core.excludesFile "${{ runner.temp }}/.config/git/ignore" || true
+
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: 20
+          node-version: 24
           cache: 'npm'
 
       - name: Install Rust stable
@@ -44,12 +56,12 @@ jobs:
           toolchain: stable
           targets: ${{ matrix.platform.target == 'universal-apple-darwin' && 'x86_64-apple-darwin, aarch64-apple-darwin' || matrix.platform.target }}
 
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2
-
       - name: Install Node dependencies
         run: npm ci
 
+      - name: Run frontend tests
+        run: npm test
+
       - name: Fetch ArgyllCMS binaries
         env:
           ARGYLL_SERVER_URL: ${{ github.server_url }}
@@ -62,15 +74,6 @@ jobs:
           test -x "src-tauri/argyll/${{ matrix.platform.binary_dir }}/instlist"
           test -x "src-tauri/argyll/${{ matrix.platform.binary_dir }}/targen"
 
-      - name: Run Rust tests
-        shell: bash
-        env:
-          CARGO_INCREMENTAL: "0"
-          CARGO_TARGET_DIR: "${{ runner.temp }}/cargo-target"
-        run: |
-          cd src-tauri
-          cargo test --target ${{ matrix.platform.target }}
-
       - name: Set Release Environment
         id: set_env
         shell: bash
@@ -82,6 +85,8 @@ jobs:
           echo "PREFIX=ICCery_${TAG}-${SHORT_SHA}-macos-${{ matrix.platform.arch }}" >> $GITHUB_ENV
 
       - name: Build Tauri App
+        env:
+          CI: "true"
         run: npm run tauri build -- --target ${{ matrix.platform.target }}
 
       - name: Prepare Release Assets
@@ -89,19 +94,23 @@ jobs:
         run: |
           mkdir -p release-assets
           
-          # Stage DMG package
+          APP_PATH=$(find src-tauri/target -type d -path "*/release/bundle/macos/*.app" | head -n 1)
-          DMG_FILE=$(find src-tauri/target -type f -name "*.dmg" | head -n 1)
+          if [ -z "$APP_PATH" ] || [ ! -d "$APP_PATH" ]; then
-          if [ -n "$DMG_FILE" ] && [ -f "$DMG_FILE" ]; then
+            echo "Error: Could not locate built .app bundle in src-tauri/target"
-            cp "$DMG_FILE" "release-assets/${PREFIX}.dmg"
+            exit 1
           fi
+          echo "Found .app bundle: ${APP_PATH}"
+
+          # Setup isolated Python virtual environment for dmgbuild
+          python3 -m venv "${{ runner.temp }}/dmgbuild-venv"
+          "${{ runner.temp }}/dmgbuild-venv/bin/pip" install --quiet dmgbuild
+
+          # Build styled DMG with background art and custom icon locations
+          "${{ runner.temp }}/dmgbuild-venv/bin/python" scripts/build-dmg.py \
+            --app "${APP_PATH}" \
+            --output "release-assets/${PREFIX}.dmg" \
+            --volname "ICCery"
 
-          # Stage ZIP archive of .app bundle
-          APP_DIR=$(find src-tauri/target -type d -name "*.app" | head -n 1)
-          if [ -n "$APP_DIR" ] && [ -d "$APP_DIR" ]; then
-            APP_PARENT=$(dirname "$APP_DIR")
-            APP_NAME=$(basename "$APP_DIR")
-            (cd "$APP_PARENT" && zip -r "${GITHUB_WORKSPACE}/release-assets/${PREFIX}.zip" "$APP_NAME")
-          fi
 
       - name: Upload Artifacts
         uses: actions/upload-artifact@v3

.gitea/workflows/build-windows.yml

@@ -41,6 +41,9 @@ jobs:
       - name: Install Node dependencies
         run: npm ci
 
+      - name: Run frontend tests
+        run: npm test
+
       - name: Fetch ArgyllCMS binaries
         shell: powershell
         env:

.github/workflows/build-macos.yml

@@ -35,6 +35,16 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Ensure workspace and git permissions
+        run: |
+          mkdir -p "${{ runner.temp }}/.config/git"
+          touch "${{ runner.temp }}/.config/git/ignore"
+          mkdir -p .git/info
+          touch .git/info/exclude
+          chmod -R u+rwX .git || true
+          chmod 644 .git/info/exclude || true
+          git config --local core.excludesFile "${{ runner.temp }}/.config/git/ignore" || true
+
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
@@ -74,22 +84,9 @@ jobs:
           echo "SHORT_SHA=${SHORT_SHA}" >> $GITHUB_ENV
           echo "PREFIX=ICCery_${TAG}-${SHORT_SHA}-macos-${{ matrix.platform.arch }}" >> $GITHUB_ENV
 
-      - name: Warm up macOS GUI for DMG layout
-        if: runner.os == 'macOS'
-        run: |
-          # Tauri's DMG bundler runs an AppleScript that asks Finder to set the
-          # background picture and icon positions. On CI runners, Finder or the
-          # Aqua session may be idle, which can cause AppleEvent timeouts. Try to
-          # start/awaken Finder and System Events before the real build.
-          open -g -a Finder || true
-          open -g -a "System Events" || true
-          # Send a harmless probe to force Finder to initialise a scripting session.
-          osascript -e 'tell application "Finder" to get name' || true
-          sleep 10
-
       - name: Build Tauri App
         env:
-          TAURI_BUNDLER_DMG_IGNORE_CI: "true"
+          CI: "true"
         run: npm run tauri build -- --target ${{ matrix.platform.target }}
 
       - name: Prepare Release Assets
@@ -97,19 +94,23 @@ jobs:
         run: |
           mkdir -p release-assets
           
-          # Stage DMG package
+          APP_PATH=$(find src-tauri/target -type d -path "*/release/bundle/macos/*.app" | head -n 1)
-          DMG_FILE=$(find src-tauri/target -type f -path "*/release/bundle/dmg/*.dmg" | head -n 1)
+          if [ -z "$APP_PATH" ] || [ ! -d "$APP_PATH" ]; then
-          if [ -n "$DMG_FILE" ] && [ -f "$DMG_FILE" ]; then
+            echo "Error: Could not locate built .app bundle in src-tauri/target"
-            cp "$DMG_FILE" "release-assets/${PREFIX}.dmg"
+            exit 1
           fi
+          echo "Found .app bundle: ${APP_PATH}"
+
+          # Setup isolated Python virtual environment for dmgbuild
+          python3 -m venv "${{ runner.temp }}/dmgbuild-venv"
+          "${{ runner.temp }}/dmgbuild-venv/bin/pip" install --quiet dmgbuild
+
+          # Build styled DMG with background art and custom icon locations
+          "${{ runner.temp }}/dmgbuild-venv/bin/python" scripts/build-dmg.py \
+            --app "${APP_PATH}" \
+            --output "release-assets/${PREFIX}.dmg" \
+            --volname "ICCery"
 
-          # Stage ZIP archive of .app bundle
-          APP_DIR=$(find src-tauri/target -type d -path "*/release/bundle/macos/*.app" | head -n 1)
-          if [ -n "$APP_DIR" ] && [ -d "$APP_DIR" ]; then
-            APP_PARENT=$(dirname "$APP_DIR")
-            APP_NAME=$(basename "$APP_DIR")
-            (cd "$APP_PARENT" && zip -r "${GITHUB_WORKSPACE}/release-assets/${PREFIX}.zip" "$APP_NAME")
-          fi
 
       - name: Upload Artifacts
         uses: actions/upload-artifact@v4

AGENTS.md

@@ -53,11 +53,17 @@ The frontend uses a tiered button sizing system defined in `src/styles/main.css`
 - Valid threshold values must be non-negative and `delta_e_good_max < delta_e_warning_max`; both the frontend and backend enforce this.
 - Saving settings dispatches a `settings-saved` custom event so live components (e.g. the swatch grid) can re-classify on the fly.
 
-## Build Commands
+## Build & Test Commands
 
-- **Rust backend**: `cd src-tauri && CARGO_INCREMENTAL=0 cargo check` (the project lives on a network filesystem that doesn't support file locking, so `CARGO_INCREMENTAL=0` is required)
+- **Rust backend check**: `cd src-tauri && CARGO_INCREMENTAL=0 cargo check` (the project lives on a network filesystem that doesn't support file locking, so `CARGO_INCREMENTAL=0` is required)
-- **Rust tests**: `cd src-tauri && CARGO_INCREMENTAL=0 cargo test`
+- **Rust unit tests**: `cd src-tauri && CARGO_INCREMENTAL=0 cargo test`
-- **Frontend**: `cd src-tauri && npm run build` (or `npm run dev` for development)
+- **Frontend test suites**:
+  - Verification & drift tests: `node src/js/profcheck.test.js` (21 tests)
+  - Chartread classifier & XY table tests: `node src/js/chartread.test.js` (39 tests)
+  - Gamut viewer tests: `node src/js/gamut_viewer.test.js`
+  - Browser devtools console: `import('./profcheck.test.js').then(m => m.runAll())`
+- **Frontend development server**: `npm run tauri dev`
+- **Production package build**: `npm run tauri build`
 
 ## Architecture Overview
 
@@ -102,3 +108,64 @@ The "Preferences" button opens the native macOS `NSPrintPanel` (not CUPS web UI
 - Epson color bypass: `EPIJ_CMat=3` (Off / No Color Adjustment)
 - Canon color bypass: `CNIJIntent2=4` or `CNIJIntent=4`
 - Gutenprint: `StpColorCorrection=Uncorrected`
+
+## Verification History & Printer Drift Tracking (#95)
+
+- Historical verification runs are stored in `verification_history.json` in the app data directory.
+- Record schema (`VerificationRecord` in `src-tauri/src/quality_store.rs`):
+  - `id`: unique record identifier in the format `vr-<epoch_millis>-<seq>`.
+  - `profile_name`: target profile filename.
+  - `printer_name`: device name captured at print spooling (`wizardState.printerName`), or "Unknown".
+  - `avg_de`, `max_de`, `rms_de`: CIEDE2000 metrics from `profcheck` (using `-u` JSON summary).
+  - `patch_count`: number of test patches evaluated.
+  - `status`: classified status using **ICCery verification bands (issue #95)**:
+    - `< 1.0`: "Excellent" (`badge-excellent`)
+    - `< 2.0`: "Good" (`badge-good`)
+    - `< 3.5`: "Acceptable" (`badge-acceptable`)
+    - `>= 3.5`: "Warning" (`badge-poor`)
+  - `timestamp`: ISO-8601 UTC string.
+- Max capacity is 1,000 records; oldest records evicted on overflow.
+- Atomic file writes (`.tmp` write followed by `rename`) prevent data corruption.
+- Tauri IPC command casing:
+  - Nested struct fields (`VerificationRecord`) serialize with `snake_case`.
+  - Top-level Tauri command arguments use `camelCase` (e.g. `savePath`, `record`, `profileName`).
+- Drift history UI in Stage 5 features an interactive SVG trend chart with ICCery verification reference bands, consecutive-breach alert card (requires $\ge 2$ consecutive runs $\ge 3.5$ on distinct calendar days or $\ge 1$ hour apart), and RFC-4180 compliant CSV export.
+
+## Stage 3 XY Automated Scanning Tables (#93)
+
+- Supports automated XY scanning tables (GretagMacbeth SpectroScan, X-Rite i1iO) in Stage 3 `chartread`.
+- Hardware detection in `instlist` flags devices matching `/spectro\s?scan|i1io/i` with `data-xy="1"` and `· XY Table` label suffix.
+- Runtime auto-detection activates when any XY-specific prompt is classified from `chartread` stdout (supporting i1iO units reporting as i1Pro).
+- XY State Machine additions:
+  - `STATE.TABLE_PLACE_SHEET`: Prompts user to place sheet on table; button displays "✓ Sheet Placed — Continue".
+  - `STATE.TABLE_ALIGN`: Prompts user to align measurement head with target fiducial patches (`locate patch <ID> with sight`); button displays "✓ Aligned — Continue".
+- Two-line prompt handling & sticky state:
+  - Argyll `chartread.c` splits XY prompts across two lines (prompt line followed by `hit return to continue...`).
+  - While in `TABLE_PLACE_SHEET` or `TABLE_ALIGN`, subsequent continuation lines remain sticky in that table state, preserving the custom button label and preventing regression to generic `PROMPT_CONTINUE`.
+- Button behaviors:
+  - `btnAccept`: in `TABLE_*` states, sends `\n` without forcing `STATE.READING`; the state machine advances naturally when Argyll emits the next prompt.
+  - `btnCancel`: in `TABLE_*` states or when an XY table is active, sends `q\n` first to allow the hardware to park its measurement head gracefully before terminating the process.
+- Multi-sheet and final sheet notice:
+  - Multi-sheet targets are measured within a single `chartread` process lifecycle; sheet changes transition through `TABLE_PLACE_SHEET` without opening the Stage 3 multi-pass averaging panel.
+  - `Please remove last sheet from table` is emitted by Argyll right before writing `.ti3` and exiting; it is classified as an info-only notice (`isRemoveSheetNotice: true`) and does not prompt for user input.
+- Testing:
+  - Pure line classification unit tests live in `src/js/chartread.test.js` (executable directly in Node or browser console).
+  - Unix/macOS mock script `src-tauri/argyll/mocks/chartread.mock` supports `--xy` flag (or `MOCK_XY_TABLE=1`) with blocking `read` calls simulating calibration, sheet placement, fiducial alignment, and scanning.
+
+## Stage 3 i1Pro 2 LED Status Feedback (#204)
+
+- Supports the `-Y l` switch introduced in the ICCery ArgyllCMS fork to drive the dual RGB ring LEDs of the X-Rite i1Pro 2 (Rev E) for real-time visual status feedback during strip measurement:
+  - **Flashing White**: Awaiting baseline calibration on white tile.
+  - **Flashing Blue**: Ready for row swipe / awaiting strip read.
+  - **Flashing Red**: Strip scan error / misread.
+  - **Flashing Green**: Strip scan successfully captured.
+- Controlled via `enable_i1pro2_leds: bool` in `AppSettings` (persisted in `settings.json`), exposed under Settings → Instrument & Measurement Preferences.
+- Defaults to `false` ensuring 100% out-of-the-box compatibility with stock upstream ArgyllCMS binaries.
+- Subprocess error diagnostics in `chartread.js` capture `lastStderrLine` from `process:stderr`, auto-expanding the Process Output `<details>` panel with the stderr explanation if an unpatched binary rejects `-Y l`.
+
+## CI & Cross-Compilation
+
+- Release packaging workflows live under `.gitea/workflows/` (`build-macos.yml`, `build-linux.yml`, `build-windows.yml`).
+- Tag release builds focus exclusively on packaging via `npm run tauri build` without redundant debug-profile test compilations.
+- Local/CI cross-compilation test execution for Apple Silicon (`aarch64-apple-darwin`) on Intel hosts must use `cargo test --no-run --target aarch64-apple-darwin` to avoid executing ARM64 binaries on an x86_64 CPU (`Bad CPU type in executable (os error 86)`).
+

README.md

@@ -2,8 +2,8 @@
 
 > Modern, cross-platform native desktop application for printer profiling, powered by ArgyllCMS.
 
-[![Release](https://img.shields.io/badge/version-v0.7.2-blue.svg)](https://git.i3omb.com/gronod/ICCery)
+[![Release](https://img.shields.io/badge/version-v0.8.4-blue.svg)](https://git.i3omb.com/gronod/ICCery)
-[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux-lightgrey.svg)](https://git.i3omb.com/gronod/ICCery)
+[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey.svg)](https://git.i3omb.com/gronod/ICCery)
 [![Framework](https://img.shields.io/badge/framework-Tauri%20v2%20%2B%20Rust-orange.svg)](https://tauri.app)
 [![License](https://img.shields.io/badge/license-Proprietary%20%2F%20EULA-blue.svg)](LICENCE.md)
 
@@ -14,16 +14,29 @@
 ## Key Features
 
 - 🪄 **Linear 5-Stage Wizard Workflow**:
-  1. **Stage 1 — Patch Generation (`targen`)**: Configure RGB (driver-managed) or CMYK (RIP-managed) patch sets with custom counts, profiling presets, and neutral/grey axis boosting.
+  1. **Stage 1 — Patch Generation (`targen`)**: Configure RGB (driver-managed) or CMYK (RIP-managed) patch sets with custom counts, profiling presets, neutral/grey axis boosting, and 11 advanced generation parameters with contextual guidance tooltips. Supports direct-resume from existing `.ti2` target files to jump straight to measurement.
-  2. **Stage 2 — Target Creation & Raw Printing (`printtarg`)**: Format patch targets for spectrophotometers (i1Pro, i1Pro2, ColorMunki, SpyderPrint). View high-resolution downscaled TIFF previews and print directly using native OS raw unmanaged pathways (Windows GDI uncorrected / Linux CUPS `raw`).
+  2. **Stage 2 — Target Creation & Raw Printing (`printtarg`)**: Format patch targets for handheld spectrophotometers (i1Pro, i1Pro2, ColorMunki, SpyderPrint) and automated XY tables (i1iO, SpectroScan). View high-resolution downscaled TIFF previews and print directly using native OS unmanaged pathways:
-  3. **Stage 3 — Interactive Measurement (`chartread`) & Averaging (`average`)**: Instrument auto-detection (`instlist`), real-time calibration prompts, interactive strip reading state machine, live swatch grid with CIEDE2000 ($\Delta E_{00}$) quality indicators and user-configurable traffic-light thresholds, diagonally split intended-vs-measured colour swatches, white reference patch preservation, and multi-pass sheet averaging for measurement noise reduction.
+     - **macOS**: Native `NSPrintPanel` driver preferences with automatic ColorSync suppression (`AP_ColorMatchingMode=AP_ApplicationColorMatching`), CUPS media type selection, and driver-specific color adjustment bypass detection (Canon `CNIJIntent2`, Epson `ColorCorrection`, Gutenprint).
-  4. **Stage 4 — Profile Calculation (`colprof`)**: Generate high-precision cLUT mathematical ICC/ICM profiles with configurable algorithm quality, OBA/FWA compensation, illuminant/observer selection, viewing-condition transforms, custom ambient spectrum support, descriptions, and copyright tagging.
+     - **Windows**: GDI uncorrected raw printing and DEVMODE preferences.
-  5. **Stage 5 — Verification & 3D Gamut (`profcheck` + `iccgamut`)**: Comprehensive mathematical validation report (Peak, Average, RMS $\Delta E$) paired with an interactive 3D CIELAB convex hull color volume viewer, per-vertex true-colour rendering, layer opacity controls, camera reset, keyboard shortcut, touch controls, bundled sRGB reference wireframe comparison, and robust parsing of both JSON and legacy profcheck output formats.
+     - **Linux**: CUPS `raw` queue and PPD media option spooling.
+  3. **Stage 3 — Interactive Measurement (`chartread`) & Averaging (`average`)**:
+     - **Automated XY Scanning Tables (#93)**: Full automated sequence for GretagMacbeth SpectroScan and X-Rite i1iO tables with multi-line prompt classification, fiducial sight alignment prompts, 4-step sequence checklist UI, and graceful head parking (`q\n`).
+     - **Instrument Status Feedback (#204)**: Optional `-Y l` switch support driving the dual RGB ring LEDs of the X-Rite i1Pro 2 (flashing white for calibration, flashing blue for ready/swipe, flashing red for error, flashing green for capture).
+     - **Interactive Controls**: Dedicated `Done & Save .ti3` (`d\n`), `Undo Strip` (`u\n`), and `Skip Strip` (`s\n`) actions.
+     - **Live Swatch Grid**: 135° diagonally split intended-vs-measured colour patches with live CIEDE2000 ($\Delta E_{00}$) quality indicators, white reference patch preservation, and user-configurable good/warning traffic-light thresholds persisted across sessions.
+     - **Noise Reduction**: Multi-pass sheet averaging (`average`) to eliminate spectrophotometer noise.
+  4. **Stage 4 — Profile Calculation (`colprof`)**: Generate high-precision cLUT mathematical ICC/ICM profiles with configurable algorithm quality, OBA/FWA compensation (`-f`), illuminant (`-i`) and observer (`-o`) overrides, viewing-condition transforms (`-c`, `-d`), custom ambient spectrum support, descriptions, and copyright tagging.
+  5. **Stage 5 — Verification, Drift Analytics & 3D Gamut (`profcheck` + `iccgamut`)**:
+     - **Longitudinal Printer Drift Analytics (#95)**: Historical verification logging persisted to `verification_history.json` (up to 1,000 records), an interactive dual-series SVG trend chart with shaded ICCery verification reference bands, consecutive-breach alert recommendation card (detecting drift across distinct dates or $\ge 1$ hour apart), and RFC-4180 compliant CSV export.
+     - **Mathematical Accuracy Report**: Peak, Average, and RMS CIEDE2000 metrics with robust parsing of both Argyll JSON summaries (`-u`) and legacy plain-text reports.
+     - **Interactive 3D Gamut Viewer**: CIELAB coordinate scaffold with crisp CSS2D labels, per-vertex true-colour profile gamut shading, layer visibility toggles and opacity sliders, camera reset (press **R**), touch controls, and bundled sRGB reference wireframe comparison.
+- 📊 **CGATS Dataset Interoperability (#94)**: Native parser for external CGATS and Argyll `.ti3` datasets with canonical normalization (0–255 scaling, field aliasing, metadata synthesis) and direct-jump workflows to Stage 4 (Profile Calculation) and Stage 5 (Verification).
 - 📋 **Profiling Presets**: One-click configuration presets (Standard RGB Photo, High-Gamut CMYK Proofing, Fast RGB Draft) with custom preset export/import and security validation.
-- 🐧 **glibc Compatibility**: Pre-built Linux packages compiled with Ubuntu 22.04 LTS compatibility for Debian/Ubuntu environments.
+- 🍎 **macOS Universal Binary**: Native Apple Silicon (`arm64`) and Intel (`x86_64`) support with universal binary bundling and fallback resolution.
-- 🛡️ **Disk Artefact Gating**: Stepper navigation strictly verifies generated artefacts on disk (`.ti1`, `.ti2`, `.ti3`, `.icc`/`.icm`), preventing out-of-order execution while preserving backward navigation.
+- 🐧 **Linux glibc Compatibility**: Pre-built Linux packages compiled with Ubuntu 22.04 LTS compatibility for Debian/Ubuntu environments.
-- 🌐 **Platform-Aware**: Automatic handling of platform profile conventions (`.icm` on Windows, `.icc` on Linux/macOS) and native OS printer subsystems.
+- 🛡️ **Disk Artefact Gating**: Stepper navigation strictly verifies generated artefacts on disk (`.ti1` → `.ti2` → `.ti3` → `.icc`/`.icm`), preventing out-of-order execution while preserving backward navigation.
-- 🎛️ **Consistent UI Controls**: Tiered button sizing (`btn-sm`/`btn-md`/`btn-lg`/`btn-icon-sq`) and standardised action row classes provide a uniform, polished interface across all wizard stages and dialogs.
+- 🌐 **Platform-Aware**: Automatic handling of platform profile conventions (`.icm` on Windows, `.icc` on macOS/Linux) and native OS printer subsystems.
+- 🎛️ **Standardised UI Design**: Tiered button sizing (`.btn-sm`, `.btn-md`, `.btn-lg`, `.btn-icon-sq`) and consistent action row layouts provide a uniform, responsive interface across all stages.
 - ⚖️ **Clean AGPL Boundary**: Complete isolation of AGPLv3 binaries via asynchronous tokio IPC process pipelines.
 
 ---
@@ -38,13 +51,16 @@ flowchart TD
         UI[Wizard UI & Swatch Grid]
         ThreeJS[3D CIELAB Gamut Viewer]
         State[Wizard State & Artefact Verifier]
-        PrintEngine["Raw Print Subsystem (GDI / CUPS)"]
+        QualityStore[Verification History & Drift Analytics]
+        PrintEngine["Raw Print Subsystem (GDI / CUPS / NSPrintPanel)"]
         ProcMgr[Async Subprocess IPC Manager]
 
         UI <--> State
         State <--> ProcMgr
+        State <--> QualityStore
         ProcMgr --> ThreeJS
         UI --> PrintEngine
+        QualityStore --> UI
     end
 
     subgraph Argyll ["ArgyllCMS Subprocesses (AGPLv3)"]
@@ -72,6 +88,7 @@ flowchart TD
 - [Node.js](https://nodejs.org/) (v18 or newer)
 - [Rust](https://www.rust-lang.org/) (1.78+ stable)
 - Operating system dependencies:
+  - **macOS**: macOS 11.0 (Big Sur) or newer, Xcode Command Line Tools (`xcode-select --install`).
   - **Windows**: Microsoft Visual Studio C++ Build Tools & WebView2 runtime.
   - **Linux (Debian/Ubuntu)**: `libwebkit2gtk-4.1-dev`, `build-essential`, `curl`, `wget`, `file`, `libxdo-dev`, `libssl-dev`, `libayatana-appindicator3-dev`, `librsvg2-dev`, `libcups2-dev`.
 
@@ -91,7 +108,7 @@ npm run fetch-argyll
 npm run tauri dev
 ```
 
-> **Note:**
+> **Notes:**
 > - Sidecars are not stored in git; `tauri build` / `tauri dev` will fail until `npm run fetch-argyll` has been run at least once.
 > - You can override the downloaded ArgyllCMS release version using `ARGYLL_RELEASE_TAG=vX.Y.Z npm run fetch-argyll`.
 > - On Windows, the NSIS installer package bundles the ArgyllCMS USB instrument driver suite and offers an optional driver setup step when run with administrative privileges.
@@ -101,7 +118,10 @@ npm run tauri dev
 # Download sidecars (if not already fetched)
 npm run fetch-argyll
 
-# Build desktop packages (MSI/NSIS on Windows, DEB/AppImage on Linux)
+# Build desktop packages
+# - macOS: .dmg / .app bundle (Intel, Apple Silicon, or Universal with --target universal-apple-darwin)
+# - Windows: .exe (NSIS) / .msi installer
+# - Linux: .AppImage / .deb package
 npm run tauri build
 ```
 

ROADMAP.md

@@ -10,10 +10,11 @@ This document outlines the architectural roadmap, completed milestones, and upco
 ## 1. Architecture Summary
 
 ICCery is a native, cross-platform desktop application built with:
-- **Backend**: Rust + Tauri v2, managing asynchronous process pipes, native printer devmode configurations (Windows GDI & Linux CUPS), and filesystem operations.
+- **Backend**: Rust + Tauri v2, managing asynchronous process pipes, native printer configurations (macOS Core Printing / `NSPrintPanel`, Windows GDI & DEVMODE, Linux CUPS), and filesystem operations.
 - **Frontend**: Vanilla JS (ES Modules) + HTML5/CSS3 with a modern dark theme and responsive layout.
 - **Visualization**: Three.js WebGL engine for 3D CIELAB color gamut volumes and sRGB reference comparisons.
 - **Engine**: ArgyllCMS command-line utilities orchestrated over isolated standard stream IPC (`stdin`, `stdout`, `stderr`).
+- **Current Version**: `v0.8.4` (Production release).
 
 ---
 
@@ -90,17 +91,7 @@ ICCery is a native, cross-platform desktop application built with:
 - [x] **Windows Authenticode Code Signing in Gitea CI** (`v0.6.4` – `v0.6.6`): Integrated Tauri bundle signing hooks via `sign.cmd` batch wrapper with PATH resolution, Gitea Actions secret-based PFX materialization, and ephemeral signing pipeline.
 - [x] **Stage 3 Chartread Completion & Snapshot IPC Fix (#175)** (`v0.6.7` – `v0.6.8`): Added dedicated `Done & Save .ti3` action (`d\n`), `Undo Strip` action (`u\n`), automated completion state detection, and corrected Tauri IPC deserialization parameter (`passIndex`) in `snapshot_ti3`.
 
----
+### Milestone 13 — UI/UX & Workflow Polish (`v0.7.0` – `v0.7.4`, `v0.8.0`)
-
-## 3. Future Roadmap
-
-### Milestone 9 — macOS Native Support & Enhanced Print Spooling (`v0.4.0`)
-- [ ] **macOS Platform Bundle**: Build and sign universal macOS `.dmg` bundles with notarization.
-- [ ] **macOS Raw Spooling**: Native CoreGraphics/CUPS raw print dialog bypass.
-- [ ] **SpectroScan & Automated Table Support (#93)**: Support XY automated scanning tables (i1iO / SpectroScan) in `chartread` (deferred).
-
-### Milestone 13 — UI/UX & Workflow Polish
-
 - [x] **Global Button Standardization (#177)**: Enforce `.btn-sm`/`.btn-md`/`.btn-lg`/`.btn-icon-sq` tiers across all stages, remove inline button styles, and add CSS custom properties for button metrics.
 - [x] **Swatch Grid White Patch & Orientation Polish (#178)**: Finalise `is_pad` guard documentation, diagonally split swatch tooltips, and validate `printtarg` row/column ordering.
 - [x] **Configurable CIEDE2000 Thresholds (#184)**: User-configurable good/warning ΔE₀₀ upper bounds in Settings, persisted across sessions and applied to the Stage 3 swatch grid.
@@ -108,6 +99,33 @@ ICCery is a native, cross-platform desktop application built with:
 - [x] **3D Gamut Viewer Controls (#185)**: Camera reset, opacity sliders, keyboard shortcut, and full public-API JSDoc.
 - [x] **Gamut / Profcheck Hardening (#179)**: Validate `.gam` vertex/face parsing, improved `profcheck` regex fallbacks for legacy text output, and user-visible parser warnings.
 
-### Milestone 12 — Future Workflow & Advanced Analytics (Deferred)
+### Hardware Status Feedback Release (`v0.8.1`)
-- [ ] **Batch Verification & Drift Tracking (#95)**: Track printer drift over time by comparing periodic verification measurements against a baseline profile.
+- [x] **i1Pro 2 LED Status Feedback (#204)**: Added optional `-Y l` switch support to `chartread` driving the dual RGB ring LEDs of the X-Rite i1Pro 2 for visual status feedback (calibration, swipe ready, misread, capture success).
-- [ ] **Multi-Language Localization (#96)**: Full UI internationalization (English, German, French, Japanese).
+- [x] **macOS CI Cross-Compilation Testing**: Hardened `.gitea/workflows/build-macos.yml` by compiling Apple Silicon tests with `--no-run` on Intel runner hosts to avoid architecture execution mismatch.
+
+### Milestone 12 — Future Workflow & Advanced Analytics (`v0.8.2`)
+- [x] **Printer Drift Tracking & Verification Analytics (#95)**: Track longitudinal printer drift in Stage 5 over time with historical run logging in `verification_history.json` (1,000 records), interactive dual-series SVG trend chart with ICCery verification reference bands, consecutive-breach alert recommendation card, and RFC-4180 CSV export.
+- [x] **XY Automated Scanning Tables (#93)**: Full Stage 3 support for automated XY scanning tables (GretagMacbeth SpectroScan, X-Rite i1iO) with pure multi-line prompt classification, fiducial alignment prompts, 4-step sequence checklist, and graceful head parking on cancel.
+- [ ] ~~**Multi-Language Localization (#96)**~~: *Closed — Won't Fix* (English UI retained as standard color-management terminology).
+
+### Maintenance & Reliability Release (`v0.8.3`)
+- [x] **Gamut Viewer Node Test Runner Support (#212)**: Guarded `window` and `window.__TAURI__` globals in `gamut_viewer.js` and added polyfill mock harness to `gamut_viewer.test.js` to enable automated headless test execution via `node src/js/gamut_viewer.test.js`.
+- [x] **Custom Spectrum File Picker Dialog (#210)**: Implemented native `select_spectrum_file` command wrapping Tauri file dialog with `.sp` filter for custom FWA/OBA spectrum selection in Stage 4 profile generation.
+- [x] **CGATS Dataset Import File Picker & State Synchronization (#211)**: Implemented native `select_dataset_file` command with `.ti3`, `.txt`, `.cgats`, and `.csv` filter, synchronized wizard target directory and basename upon import, and guarded against empty target states.
+
+### Maintenance & Reliability Release (`v0.8.4`)
+- [x] **Atomic Verification History Persistence (#213)**: Hardened `quality_store.rs` with atomic temporary file writes (`.tmp`), explicit flush/sync, and atomic rename to prevent historical drift data loss or corruption upon unexpected system crashes.
+- [x] **Frontend Unit Testing & CI Integration (#215)**: Added standard `npm test` script executing the 3 frontend test suites (`profcheck`, `chartread`, and `gamut_viewer`) and integrated automated frontend test validation into macOS, Linux, and Windows CI workflows.
+
+---
+
+## 3. Future Roadmap
+
+### Milestone 9 — macOS Native Support & Enhanced Print Spooling (`v0.4.0` / Post-v0.8)
+- [ ] **macOS Platform Bundle**: Build and sign universal macOS `.dmg` bundles with Apple Developer ID notarization and stapling.
+- [ ] **macOS Raw Spooling**: Native CoreGraphics/CUPS raw print dialog bypass.
+
+### Future Architecture Strategy (Post-v0.8.2)
+- **Multi-Device Drift Overlays**: Overlay drift curves from multiple printers/media types on a shared timeline in Stage 5.
+- **Direct Remote Target Dispatch**: Send `.ti2` target jobs to network print spoolers or remote print labs with automated token callbacks.
+- **Embedded ICC Profile Inspector**: Direct inspection of cLUT tags, chromatic adaptation matrices, tone reproduction curves (TRC), and profile metadata from saved `.icc`/`.icm` files.

THIRDPARTY-LICENSES.md

@@ -23,20 +23,26 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
-## Delaunator
+## quickhull3d
-Copyright (c) 2017, Mapbox
+MIT License
 
-Permission to use, copy, modify, and/or distribute this software for any purpose
+Permission is hereby granted, free of charge, to any person obtaining a copy
-with or without fee is hereby granted, provided that the above copyright notice
+of this software and associated documentation files (the "Software"), to deal
-and this permission notice appear in all copies.
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+The above copyright notice and this permission notice shall be included in
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+all copies or substantial portions of the Software.
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
 
 ## Tauri Framework & Rust Dependencies
 Copyright (c) 2019-present, Tauri Programme within The Commons Conservancy.

package.json

@@ -1,11 +1,12 @@
 {
   "name": "iccery",
   "private": true,
-  "version": "0.7.4",
+  "version": "0.8.4",
   "type": "module",
   "scripts": {
     "fetch-argyll": "node scripts/fetch-argyll.mjs",
-    "tauri": "tauri"
+    "tauri": "tauri",
+    "test": "node src/js/profcheck.test.js && node src/js/chartread.test.js && node src/js/gamut_viewer.test.js"
   },
   "devDependencies": {
     "@tauri-apps/cli": "^2"

scripts/build-dmg.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""
+Headless macOS DMG Builder for ICCery.
+
+Uses `dmgbuild` to package the .app bundle into a styled DMG with custom
+background art, window bounds, and icon locations without requiring Finder
+AppleScript automation or an interactive display session.
+"""
+
+import argparse
+import os
+import sys
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Build styled macOS DMG installer")
+    parser.add_argument(
+        "--app",
+        required=True,
+        help="Path to the .app application bundle",
+    )
+    parser.add_argument(
+        "--output",
+        required=True,
+        help="Path to the output .dmg file",
+    )
+    parser.add_argument(
+        "--volname",
+        default="ICCery",
+        help="Volume name for the mounted disk image (default: ICCery)",
+    )
+    parser.add_argument(
+        "--background",
+        default="src-tauri/icons/dmg-background.png",
+        help="Path to background image (default: src-tauri/icons/dmg-background.png)",
+    )
+    parser.add_argument(
+        "--icon",
+        default="src-tauri/icons/icon.icns",
+        help="Path to volume icon .icns (default: src-tauri/icons/icon.icns)",
+    )
+    parser.add_argument(
+        "--window-size",
+        nargs=2,
+        type=int,
+        default=[660, 400],
+        metavar=("WIDTH", "HEIGHT"),
+        help="Window width and height in points (default: 660 400)",
+    )
+    parser.add_argument(
+        "--icon-size",
+        type=int,
+        default=100,
+        help="Icon size in points (default: 100)",
+    )
+    parser.add_argument(
+        "--app-pos",
+        nargs=2,
+        type=int,
+        default=[180, 220],
+        metavar=("X", "Y"),
+        help="App icon location (default: 180 220)",
+    )
+    parser.add_argument(
+        "--apps-link-pos",
+        nargs=2,
+        type=int,
+        default=[480, 220],
+        metavar=("X", "Y"),
+        help="Applications symlink location (default: 480 220)",
+    )
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    app_path = os.path.abspath(args.app)
+    output_path = os.path.abspath(args.output)
+    bg_path = os.path.abspath(args.background) if args.background else None
+    icon_path = os.path.abspath(args.icon) if args.icon else None
+
+    if not os.path.isdir(app_path):
+        print(f"Error: Application bundle does not exist at '{app_path}'", file=sys.stderr)
+        sys.exit(1)
+
+    if bg_path and not os.path.isfile(bg_path):
+        print(f"Error: Background image not found at '{bg_path}'", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        import dmgbuild
+    except ImportError:
+        print("Error: 'dmgbuild' is required. Install via: pip install dmgbuild", file=sys.stderr)
+        sys.exit(1)
+
+    app_name = os.path.basename(app_path)
+    output_dir = os.path.dirname(output_path)
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+
+    if os.path.exists(output_path):
+        os.remove(output_path)
+
+    win_w, win_h = args.window_size
+    app_x, app_y = args.app_pos
+    apps_x, apps_y = args.apps_link_pos
+
+    settings = {
+        "files": [app_path],
+        "symlinks": {"Applications": "/Applications"},
+        "background": bg_path,
+        "icon": icon_path if icon_path and os.path.isfile(icon_path) else None,
+        "icon_size": args.icon_size,
+        "window_rect": ((100, 100), (win_w, win_h)),
+        "icon_locations": {
+            app_name: (app_x, app_y),
+            "Applications": (apps_x, apps_y),
+        },
+        "format": "UDZO",
+    }
+
+    print(f"Building DMG for {app_name}...")
+    print(f"  Volume Name:   {args.volname}")
+    print(f"  App Bundle:    {app_path}")
+    print(f"  Background:    {bg_path}")
+    print(f"  Window Size:   {win_w}x{win_h}")
+    print(f"  App Position:  ({app_x}, {app_y})")
+    print(f"  Apps Position: ({apps_x}, {apps_y})")
+    print(f"  Output Path:   {output_path}")
+
+    try:
+        dmgbuild.build_dmg(output_path, args.volname, settings=settings)
+    except Exception as e:
+        print(f"Error: dmgbuild failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if not os.path.isfile(output_path):
+        print(f"Error: Expected output DMG file '{output_path}' was not created", file=sys.stderr)
+        sys.exit(1)
+
+    size_mb = os.path.getsize(output_path) / (1024 * 1024)
+    print(f"Successfully generated DMG ({size_mb:.2f} MB): {output_path}")
+
+
+if __name__ == "__main__":
+    main()

src-tauri/Cargo.lock

@@ -1423,7 +1423,7 @@ dependencies = [
 
 [[package]]
 name = "iccery"
-version = "0.8.0"
+version = "0.8.4"
 dependencies = [
  "base64 0.22.1",
  "image",

src-tauri/Cargo.toml

@@ -1,9 +1,20 @@
 [package]
 name = "iccery"
-version = "0.8.0"
+version = "0.8.4"
 description = "Modern Printer Profiling UI frontend for ArgyllCMS"
 authors = ["Gordon"]
 edition = "2021"
+include = [
+  "src/**/*",
+  "build.rs",
+  "Cargo.toml",
+  "Cargo.lock",
+  "tauri.conf.json",
+  "capabilities/**/*",
+  "gen/**/*",
+  "icons/**/*",
+  "windows/**/*",
+]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

src-tauri/argyll/mocks/chartread.mock

@@ -2,6 +2,51 @@
 # Mock script for chartread -u
 # This script simulates the behaviour of chartread for testing purposes.
 
+# Check for --xy argument or MOCK_XY_TABLE environment variable
+IS_XY=0
+for arg in "$@"; do
+    if [ "$arg" = "--xy" ]; then
+        IS_XY=1
+        break
+    fi
+done
+
+if [ "$IS_XY" = "1" ] || [ "${MOCK_XY_TABLE}" = "1" ]; then
+    echo "Place instrument on calibration tile and hit [Space] to calibrate."
+    read -r _calib
+    echo "Calibration successful."
+
+    echo "Please place sheet 1 of 1 on the table"
+    echo "hit return to continue, Esc or 'q' to give up"
+    read -r _sheet1
+
+    echo "locate patch A1 with the sight,"
+    echo "then hit return to continue"
+    read -r _fid1
+
+    echo "locate patch B24 with the sight,"
+    echo "then hit return to continue"
+    read -r _fid2
+
+    echo "Reading sheet 1..."
+    sleep 0.5
+
+    # Emit mock JSON for strip A
+    cat << 'EOF'
+ROW_COLORS_JSON: {"event": "row_complete", "row_id": "A", "row_index": 0, "total_rows": 2, "patch_count": 3, "patches": [{"id": "1", "loc": "A1", "is_pad": false, "device": [0.0, 50.0, 100.0], "expected": {"XYZ": [18.4210, 20.1234, 15.6789], "Lab": [51.98, -8.45, 12.32]}, "measured": {"XYZ": [18.5120, 20.0451, 15.7100], "Lab": [51.89, -8.31, 12.15]}}, {"id": "2", "loc": "A2", "is_pad": false, "device": [10.0, 60.0, 90.0], "expected": {"Lab": [60.0, 10.0, -20.0]}, "measured": {"Lab": [60.1, 10.5, -19.5]}}, {"id": "3", "loc": "A3", "is_pad": true, "device": [100.0, 100.0, 100.0]}]}
+EOF
+
+    # Emit mock JSON for strip B
+    cat << 'EOF'
+ROW_COLORS_JSON: {"event": "row_complete", "row_id": "B", "row_index": 1, "total_rows": 2, "patch_count": 2, "patches": [{"id": "4", "loc": "B1", "is_pad": false, "device": [100.0, 0.0, 0.0], "expected": {"Lab": [40.0, 40.0, 40.0]}, "measured": {"Lab": [38.0, 41.0, 39.0]}}, {"id": "5", "loc": "B2", "is_pad": false, "device": [0.0, 100.0, 0.0], "expected": {"Lab": [80.0, -50.0, 50.0]}, "measured": {"Lab": [79.0, -49.0, 51.0]}}]}
+EOF
+
+    echo "Sheet 1 of 1 read OK"
+    echo "Please remove last sheet from table"
+    exit 0
+fi
+
+# Handheld / strip reader simulation
 echo "Place instrument on calibration tile and hit [Space] to calibrate."
 
 # We don't really wait for input, just wait 1 second

src-tauri/argyll/mocks/profcheck.mock

@@ -1,14 +1,12 @@
 #!/bin/bash
 # Mock script for profcheck
-# Simulates profcheck verification output
+# Simulates real ArgyllCMS profcheck -v -k -s -u output
 
 echo "profcheck: Checking profile accuracy..."
+echo "No of test patches = 52"
 sleep 1
 cat << 'EOF'
-{"event": "profcheck_complete", "avg_de": 0.85, "max_de": 2.41, "rms_de": 1.02}
+{"event": "report", "peak_de2000": 2.41, "avg_de2000": 0.85, "rms": 1.02}
 EOF
-echo "Summary:"
+echo "Profile check complete, errors(CIEDE2000): max. = 2.41, avg. = 0.85, RMS = 1.02"
-echo "  avg. dE = 0.85"
-echo "  max. dE = 2.41"
-echo "  rms. dE = 1.02"
 exit 0

src-tauri/build.rs

@@ -10,6 +10,12 @@ fn main() {
 
     println!("cargo:rustc-env=BUILD_DATE={}", build_date);
 
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=src");
+    println!("cargo:rerun-if-changed=tauri.conf.json");
+    println!("cargo:rerun-if-changed=Cargo.toml");
+    println!("cargo:rerun-if-changed=argyll");
+
     // Validate that ArgyllCMS sidecar binaries are staged before building
     let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
     let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();

src-tauri/src/commands.rs

@@ -391,6 +391,61 @@ pub async fn select_profile_file(
     rx.await.map_err(|e| format!("Dialog channel error: {}", e))
 }
 
+#[tauri::command]
+pub async fn select_spectrum_file(
+    app: AppHandle,
+    default_dir: Option<String>,
+) -> Result<Option<String>, String> {
+    use tauri_plugin_dialog::DialogExt;
+
+    let mut builder = app
+        .dialog()
+        .file()
+        .add_filter("Argyll Spectrum File (*.sp)", &["sp"]);
+    if let Some(ref dir) = default_dir {
+        if !dir.trim().is_empty() {
+            builder = builder.set_directory(std::path::PathBuf::from(dir));
+        }
+    }
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    builder.pick_file(move |file_path| {
+        let res = file_path.map(|p| p.to_string());
+        let _ = tx.send(res);
+    });
+
+    rx.await.map_err(|e| format!("Dialog channel error: {}", e))
+}
+
+#[tauri::command]
+pub async fn select_dataset_file(
+    app: AppHandle,
+    default_dir: Option<String>,
+) -> Result<Option<String>, String> {
+    use tauri_plugin_dialog::DialogExt;
+
+    let mut builder = app
+        .dialog()
+        .file()
+        .add_filter(
+            "Measurement Dataset (*.ti3, *.txt, *.cgats, *.csv)",
+            &["ti3", "txt", "cgats", "csv"],
+        );
+    if let Some(ref dir) = default_dir {
+        if !dir.trim().is_empty() {
+            builder = builder.set_directory(std::path::PathBuf::from(dir));
+        }
+    }
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    builder.pick_file(move |file_path| {
+        let res = file_path.map(|p| p.to_string());
+        let _ = tx.send(res);
+    });
+
+    rx.await.map_err(|e| format!("Dialog channel error: {}", e))
+}
+
 #[tauri::command]
 pub async fn select_target_file(
     app: AppHandle,
@@ -425,6 +480,34 @@ pub async fn select_target_file(
     rx.await.map_err(|e| format!("Dialog channel error: {}", e))
 }
 
+#[tauri::command]
+pub async fn select_csv_save_path(
+    app: AppHandle,
+    default_name: Option<String>,
+) -> Result<Option<String>, String> {
+    use tauri_plugin_dialog::DialogExt;
+
+    let mut builder = app.dialog().file().add_filter("CSV", &["csv"]);
+    if let Some(ref name) = default_name {
+        if !name.trim().is_empty() {
+            let filename = if name.to_lowercase().ends_with(".csv") {
+                name.to_string()
+            } else {
+                format!("{}.csv", name)
+            };
+            builder = builder.set_file_name(filename);
+        }
+    }
+
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    builder.save_file(move |file_path| {
+        let res = file_path.map(|p| p.to_string());
+        let _ = tx.send(res);
+    });
+
+    rx.await.map_err(|e| format!("Dialog channel error: {}", e))
+}
+
 #[tauri::command]
 pub async fn select_directory(
     app: AppHandle,
@@ -829,11 +912,13 @@ pub async fn read_tiff_preview_png(path: String) -> Result<String, String> {
     Ok(base64::engine::general_purpose::STANDARD.encode(png_bytes.into_inner()))
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct ChartreadConfig {
     pub basename: String,
     pub cwd: String,
     pub port: Option<String>,
+    #[serde(default)]
+    pub enable_i1pro2_leds: Option<bool>,
 }
 
 pub fn build_chartread_args(config: &ChartreadConfig) -> Vec<String> {
@@ -849,6 +934,11 @@ pub fn build_chartread_args(config: &ChartreadConfig) -> Vec<String> {
         }
     }
 
+    if config.enable_i1pro2_leds.unwrap_or(false) {
+        args.push("-Y".to_string());
+        args.push("l".to_string());
+    }
+
     args.push(config.basename.clone());
     args
 }
@@ -857,8 +947,12 @@ pub fn build_chartread_args(config: &ChartreadConfig) -> Vec<String> {
 pub async fn run_chartread(
     app: AppHandle,
     state: State<'_, ProcessManager>,
-    config: ChartreadConfig,
+    mut config: ChartreadConfig,
 ) -> Result<(), String> {
+    if config.enable_i1pro2_leds.is_none() {
+        let settings = crate::settings::load_settings(app.clone()).unwrap_or_default();
+        config.enable_i1pro2_leds = Some(settings.enable_i1pro2_leds);
+    }
     let binary = resolve_binary(app.clone(), "chartread".to_string()).await?;
     let args = build_chartread_args(&config);
     let id = format!("chartread_{}", config.basename);
@@ -1073,6 +1167,7 @@ pub fn build_profcheck_args(config: &ProfcheckConfig) -> Vec<String> {
         "-v".to_string(),
         "-k".to_string(),
         "-s".to_string(),
+        "-u".to_string(),
         config.ti3_path.clone(),
         config.icc_path.clone(),
     ]
@@ -1558,6 +1653,7 @@ mod tests {
             basename: "my_profile".to_string(),
             cwd: "/home/user".to_string(),
             port: None,
+            enable_i1pro2_leds: None,
         };
         let args = build_chartread_args(&config);
         assert_eq!(args, vec!["-v", "-u", "my_profile"]);
@@ -1569,6 +1665,7 @@ mod tests {
             basename: "my_profile".to_string(),
             cwd: "/home/user".to_string(),
             port: Some("".to_string()),
+            enable_i1pro2_leds: None,
         };
         let args = build_chartread_args(&config);
         assert_eq!(args, vec!["-v", "-u", "my_profile"]);
@@ -1580,11 +1677,48 @@ mod tests {
             basename: "my_profile".to_string(),
             cwd: "/home/user".to_string(),
             port: Some("1".to_string()),
+            enable_i1pro2_leds: None,
         };
         let args = build_chartread_args(&config);
         assert_eq!(args, vec!["-v", "-u", "-c", "1", "my_profile"]);
     }
 
+    #[test]
+    fn test_build_chartread_args_leds_enabled() {
+        let config = ChartreadConfig {
+            basename: "my_profile".to_string(),
+            cwd: "/home/user".to_string(),
+            port: None,
+            enable_i1pro2_leds: Some(true),
+        };
+        let args = build_chartread_args(&config);
+        assert_eq!(args, vec!["-v", "-u", "-Y", "l", "my_profile"]);
+    }
+
+    #[test]
+    fn test_build_chartread_args_with_port_and_leds() {
+        let config = ChartreadConfig {
+            basename: "my_profile".to_string(),
+            cwd: "/home/user".to_string(),
+            port: Some("1".to_string()),
+            enable_i1pro2_leds: Some(true),
+        };
+        let args = build_chartread_args(&config);
+        assert_eq!(args, vec!["-v", "-u", "-c", "1", "-Y", "l", "my_profile"]);
+    }
+
+    #[test]
+    fn test_build_chartread_args_leds_disabled() {
+        let config = ChartreadConfig {
+            basename: "my_profile".to_string(),
+            cwd: "/home/user".to_string(),
+            port: None,
+            enable_i1pro2_leds: Some(false),
+        };
+        let args = build_chartread_args(&config);
+        assert_eq!(args, vec!["-v", "-u", "my_profile"]);
+    }
+
     #[test]
     fn test_build_average_args() {
         let config = AverageConfig {
@@ -1818,7 +1952,7 @@ mod tests {
             cwd: "/home/user".to_string(),
         };
         let args = build_profcheck_args(&config);
-        assert_eq!(args, vec!["-v", "-k", "-s", "my_profile.ti3", "my_profile.icc"]);
+        assert_eq!(args, vec!["-v", "-k", "-s", "-u", "my_profile.ti3", "my_profile.icc"]);
     }
 
     #[test]

src-tauri/src/lib.rs

@@ -5,6 +5,7 @@ mod commands;
 mod events;
 mod print;
 mod process_manager;
+mod quality_store;
 mod settings;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
@@ -50,6 +51,8 @@ pub fn run() {
             commands::inspect_dataset_preview,
             commands::select_existing_target,
             commands::select_profile_file,
+            commands::select_spectrum_file,
+            commands::select_dataset_file,
             commands::select_target_file,
             commands::select_directory,
             commands::send_stdin,
@@ -74,6 +77,11 @@ pub fn run() {
             commands::get_printer_capabilities,
             commands::show_printer_properties,
             commands::print_target_native,
+            commands::select_csv_save_path,
+            quality_store::save_verification_record,
+            quality_store::get_verification_history,
+            quality_store::clear_verification_history,
+            quality_store::export_verification_history_csv,
             settings::load_settings,
             settings::save_settings,
             settings::get_all_presets,

src-tauri/src/process_manager.rs

@@ -276,7 +276,7 @@ mod tests {
         let pm = ProcessManager::new();
         // Test helper using dummy/mock or direct map operations
         {
-            let mut stdins = pm.stdins.lock().await;
+            let stdins = pm.stdins.lock().await;
             assert!(!stdins.contains_key("test_proc"));
         }
     }

src-tauri/src/quality_store.rs

@@ -0,0 +1,487 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::time::{SystemTime, UNIX_EPOCH};
+use tauri::{AppHandle, Manager};
+
+static SEQ_COUNTER: AtomicU64 = AtomicU64::new(1);
+
+const HISTORY_CAP: usize = 1000;
+const STORE_VERSION: u32 = 1;
+const MAX_STRING_LEN: usize = 200;
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct VerificationRecord {
+    pub id: String,             // backend-generated only: "vr-<epoch_millis>-<seq>"
+    pub timestamp: String,      // ISO 8601 string
+    pub printer_name: String,
+    pub profile_name: String,
+    pub avg_de: f64,
+    pub max_de: f64,
+    pub rms_de: f64,
+    pub patch_count: u32,
+    pub status: String,         // backend ALWAYS fills via classify_status
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct VerificationHistoryStore {
+    pub version: u32,
+    pub records: Vec<VerificationRecord>,
+}
+
+impl Default for VerificationHistoryStore {
+    fn default() -> Self {
+        Self {
+            version: STORE_VERSION,
+            records: Vec::new(),
+        }
+    }
+}
+
+/// Generates a unique record identifier: "vr-<epoch_millis>-<seq>"
+pub fn generate_record_id() -> String {
+    let millis = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map(|d| d.as_millis())
+        .unwrap_or(0);
+    let seq = SEQ_COUNTER.fetch_add(1, Ordering::SeqCst);
+    format!("vr-{}-{}", millis, seq)
+}
+
+/// Classifies status into ICCery verification bands (issue #95):
+/// - < 1.0: "excellent"
+/// - < 2.0: "good"
+/// - < 3.5: "acceptable"
+/// - >= 3.5: "warning"
+pub fn classify_status(avg_de: f64) -> &'static str {
+    if avg_de < 1.0 {
+        "excellent"
+    } else if avg_de < 2.0 {
+        "good"
+    } else if avg_de < 3.5 {
+        "acceptable"
+    } else {
+        "warning"
+    }
+}
+
+/// Validates record data constraints.
+pub fn validate_record(record: &VerificationRecord) -> Result<(), String> {
+    if record.profile_name.trim().is_empty() {
+        return Err("Profile name cannot be empty.".to_string());
+    }
+    if record.profile_name.len() > MAX_STRING_LEN {
+        return Err(format!("Profile name exceeds maximum length of {} characters.", MAX_STRING_LEN));
+    }
+    if record.printer_name.len() > MAX_STRING_LEN {
+        return Err(format!("Printer name exceeds maximum length of {} characters.", MAX_STRING_LEN));
+    }
+    if record.timestamp.trim().is_empty() {
+        return Err("Timestamp cannot be empty.".to_string());
+    }
+    if !record.avg_de.is_finite() || record.avg_de < 0.0 {
+        return Err("Average ΔE must be a finite non-negative number.".to_string());
+    }
+    if !record.max_de.is_finite() || record.max_de < 0.0 {
+        return Err("Peak ΔE must be a finite non-negative number.".to_string());
+    }
+    if !record.rms_de.is_finite() || record.rms_de < 0.0 {
+        return Err("RMS ΔE must be a finite non-negative number.".to_string());
+    }
+    Ok(())
+}
+
+/// Loads verification history from a JSON file.
+/// Missing, unreadable, or corrupted files safely return an empty vector.
+pub fn load_history_file(path: &Path) -> Vec<VerificationRecord> {
+    if !path.exists() {
+        return Vec::new();
+    }
+    let content = match fs::read_to_string(path) {
+        Ok(c) => c,
+        Err(e) => {
+            log::warn!("Failed to read verification history at {}: {}", path.display(), e);
+            return Vec::new();
+        }
+    };
+    match serde_json::from_str::<VerificationHistoryStore>(&content) {
+        Ok(store) => store.records,
+        Err(e) => {
+            log::error!("Failed to parse verification history at {}: {}", path.display(), e);
+            Vec::new()
+        }
+    }
+}
+
+/// Writes verification records to the specified JSON path atomically.
+/// Automatically creates parent directories if needed.
+/// Evicts oldest records by timestamp if count exceeds HISTORY_CAP (1,000).
+pub fn write_history_file(path: &Path, records: &[VerificationRecord]) -> Result<(), String> {
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("Failed to create directory: {}", e))?;
+    }
+
+    let mut bounded_records: Vec<VerificationRecord> = records.to_vec();
+    // Sort by timestamp ascending
+    bounded_records.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
+
+    if bounded_records.len() > HISTORY_CAP {
+        let excess = bounded_records.len() - HISTORY_CAP;
+        bounded_records.drain(0..excess);
+    }
+
+    let store = VerificationHistoryStore {
+        version: STORE_VERSION,
+        records: bounded_records,
+    };
+
+    let json = serde_json::to_string_pretty(&store)
+        .map_err(|e| format!("Failed to serialize verification history: {}", e))?;
+
+    let mut tmp_path = path.as_os_str().to_os_string();
+    tmp_path.push(".tmp");
+    let tmp_path = PathBuf::from(tmp_path);
+
+    // Write to temporary file with explicit flush and sync
+    {
+        use std::io::Write;
+        let mut file = fs::File::create(&tmp_path)
+            .map_err(|e| format!("Failed to create temp history file: {}", e))?;
+        file.write_all(json.as_bytes())
+            .map_err(|e| {
+                let _ = fs::remove_file(&tmp_path);
+                format!("Failed to write temp history file: {}", e)
+            })?;
+        file.sync_all()
+            .map_err(|e| {
+                let _ = fs::remove_file(&tmp_path);
+                format!("Failed to sync temp history file: {}", e)
+            })?;
+    }
+
+    // Atomically replace destination file
+    if let Err(e) = fs::rename(&tmp_path, path) {
+        let _ = fs::remove_file(&tmp_path);
+        return Err(format!("Failed to atomically replace verification history file: {}", e));
+    }
+
+    Ok(())
+}
+
+/// Helper to escape CSV text fields according to RFC-4180.
+fn escape_csv_field(val: &str) -> String {
+    if val.contains('"') || val.contains(',') || val.contains('\n') || val.contains('\r') {
+        format!("\"{}\"", val.replace('"', "\"\""))
+    } else {
+        val.to_string()
+    }
+}
+
+/// Formats records into standard RFC-4180 CSV string.
+pub fn to_csv(records: &[VerificationRecord]) -> String {
+    let mut csv = String::from("id,timestamp,printer_name,profile_name,avg_de,max_de,rms_de,patch_count,status\r\n");
+    for r in records {
+        csv.push_str(&format!(
+            "{},{},{},{},{:.4},{:.4},{:.4},{},{}\r\n",
+            escape_csv_field(&r.id),
+            escape_csv_field(&r.timestamp),
+            escape_csv_field(&r.printer_name),
+            escape_csv_field(&r.profile_name),
+            r.avg_de,
+            r.max_de,
+            r.rms_de,
+            r.patch_count,
+            escape_csv_field(&r.status),
+        ));
+    }
+    csv
+}
+
+/// Validates CSV destination file path.
+pub fn validate_csv_dest(dest: &str) -> Result<PathBuf, String> {
+    let trimmed = dest.trim();
+    if trimmed.is_empty() {
+        return Err("Destination path cannot be empty.".to_string());
+    }
+    let mut path = PathBuf::from(trimmed);
+    if path.extension().is_none() || path.extension().unwrap_or_default() != "csv" {
+        path.set_extension("csv");
+    }
+    Ok(path)
+}
+
+fn get_store_path(app: &AppHandle) -> Result<PathBuf, String> {
+    let app_data = app.path().app_data_dir().map_err(|e| e.to_string())?;
+    Ok(app_data.join("verification_history.json"))
+}
+
+// ---------------------------------------------------------------------------
+// Tauri Commands
+// ---------------------------------------------------------------------------
+
+#[tauri::command]
+pub fn save_verification_record(
+    app: AppHandle,
+    mut record: VerificationRecord,
+) -> Result<VerificationRecord, String> {
+    record.id = generate_record_id();
+    record.status = classify_status(record.avg_de).to_string();
+    validate_record(&record)?;
+
+    let path = get_store_path(&app)?;
+    let mut records = load_history_file(&path);
+    records.push(record.clone());
+    write_history_file(&path, &records)?;
+
+    Ok(record)
+}
+
+#[tauri::command]
+pub fn get_verification_history(
+    app: AppHandle,
+    profile_name: Option<String>,
+    printer_name: Option<String>,
+) -> Result<Vec<VerificationRecord>, String> {
+    let path = get_store_path(&app)?;
+    let mut records = load_history_file(&path);
+
+    if let Some(ref prof) = profile_name {
+        let prof_clean = prof.trim();
+        if !prof_clean.is_empty() {
+            records.retain(|r| r.profile_name == prof_clean);
+        }
+    }
+
+    if let Some(ref prn) = printer_name {
+        let prn_clean = prn.trim();
+        if !prn_clean.is_empty() {
+            records.retain(|r| r.printer_name == prn_clean);
+        }
+    }
+
+    // Return chronological order (ascending timestamp)
+    records.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
+    Ok(records)
+}
+
+#[tauri::command]
+pub fn clear_verification_history(app: AppHandle) -> Result<(), String> {
+    let path = get_store_path(&app)?;
+    write_history_file(&path, &[])
+}
+
+#[tauri::command]
+pub fn export_verification_history_csv(
+    app: AppHandle,
+    dest_path: String,
+    profile_name: Option<String>,
+    printer_name: Option<String>,
+) -> Result<usize, String> {
+    let validated_path = validate_csv_dest(&dest_path)?;
+    let records = get_verification_history(app, profile_name, printer_name)?;
+    let count = records.len();
+    let csv_content = to_csv(&records);
+
+    if let Some(parent) = validated_path.parent() {
+        fs::create_dir_all(parent).map_err(|e| format!("Failed to create CSV parent directory: {}", e))?;
+    }
+    fs::write(&validated_path, csv_content)
+        .map_err(|e| format!("Failed to write CSV file: {}", e))?;
+
+    Ok(count)
+}
+
+// ---------------------------------------------------------------------------
+// Unit Tests (Path-based, no AppHandle required)
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    fn sample_record(id: &str, ts: &str, avg: f64) -> VerificationRecord {
+        VerificationRecord {
+            id: id.to_string(),
+            timestamp: ts.to_string(),
+            printer_name: "Canon PRO-1000".to_string(),
+            profile_name: "ProLustre_Photo".to_string(),
+            avg_de: avg,
+            max_de: avg * 2.0,
+            rms_de: avg * 1.2,
+            patch_count: 50,
+            status: classify_status(avg).to_string(),
+        }
+    }
+
+    #[test]
+    fn test_classify_status_bands() {
+        // Boundaries: <1.0 excellent, <2.0 good, <3.5 acceptable, >=3.5 warning
+        assert_eq!(classify_status(0.0), "excellent");
+        assert_eq!(classify_status(0.999), "excellent");
+        assert_eq!(classify_status(1.0), "good");
+        assert_eq!(classify_status(1.999), "good");
+        assert_eq!(classify_status(2.0), "acceptable");
+        assert_eq!(classify_status(3.499), "acceptable");
+        assert_eq!(classify_status(3.5), "warning");
+        assert_eq!(classify_status(5.2), "warning");
+    }
+
+    #[test]
+    fn test_validate_record_valid_and_invalid() {
+        let valid = sample_record("vr-1", "2026-09-05T12:00:00Z", 0.85);
+        assert!(validate_record(&valid).is_ok());
+
+        let mut empty_prof = valid.clone();
+        empty_prof.profile_name = "   ".to_string();
+        assert!(validate_record(&empty_prof).is_err());
+
+        let mut empty_ts = valid.clone();
+        empty_ts.timestamp = "".to_string();
+        assert!(validate_record(&empty_ts).is_err());
+
+        let mut negative_de = valid.clone();
+        negative_de.avg_de = -0.1;
+        assert!(validate_record(&negative_de).is_err());
+
+        let mut nan_de = valid.clone();
+        nan_de.max_de = f64::NAN;
+        assert!(validate_record(&nan_de).is_err());
+
+        let mut inf_de = valid.clone();
+        inf_de.rms_de = f64::INFINITY;
+        assert!(validate_record(&inf_de).is_err());
+
+        let mut long_name = valid.clone();
+        long_name.profile_name = "a".repeat(201);
+        assert!(validate_record(&long_name).is_err());
+    }
+
+    #[test]
+    fn test_store_load_missing_and_corrupt() {
+        let temp_dir = std::env::temp_dir().join("iccery_test_quality_store_corrupt");
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&temp_dir).unwrap();
+
+        let missing_path = temp_dir.join("nonexistent.json");
+        let records = load_history_file(&missing_path);
+        assert!(records.is_empty());
+
+        let corrupt_path = temp_dir.join("corrupt.json");
+        fs::write(&corrupt_path, "{ broken json ... ").unwrap();
+        let records_corrupt = load_history_file(&corrupt_path);
+        assert!(records_corrupt.is_empty());
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_store_write_and_roundtrip() {
+        let temp_dir = std::env::temp_dir().join("iccery_test_quality_store_roundtrip");
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&temp_dir).unwrap();
+
+        let file_path = temp_dir.join("verification_history.json");
+        let rec1 = sample_record("vr-1", "2026-09-01T10:00:00Z", 0.75);
+        let rec2 = sample_record("vr-2", "2026-09-02T10:00:00Z", 1.85);
+
+        write_history_file(&file_path, &[rec1.clone(), rec2.clone()]).unwrap();
+        let loaded = load_history_file(&file_path);
+        assert_eq!(loaded.len(), 2);
+        assert_eq!(loaded[0], rec1);
+        assert_eq!(loaded[1], rec2);
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_cap_eviction_drops_oldest_by_timestamp() {
+        let temp_dir = std::env::temp_dir().join("iccery_test_quality_store_eviction");
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&temp_dir).unwrap();
+
+        let file_path = temp_dir.join("capped_history.json");
+
+        // Generate 1005 records with disordered timestamps
+        let mut records = Vec::new();
+        for i in 0..1005 {
+            // ts ranges from 1000 to 2004
+            let ts = format!("2026-01-01T{:04}Z", i);
+            records.push(sample_record(&format!("vr-{}", i), &ts, 1.0));
+        }
+
+        // Shuffle slightly so input is out of order
+        records.swap(0, 500);
+
+        write_history_file(&file_path, &records).unwrap();
+        let loaded = load_history_file(&file_path);
+
+        assert_eq!(loaded.len(), HISTORY_CAP); // 1000 records
+        // Oldest 5 records (ts 0000..0004) should have been evicted
+        assert_eq!(loaded[0].timestamp, "2026-01-01T0005Z");
+        assert_eq!(loaded[loaded.len() - 1].timestamp, "2026-01-01T1004Z");
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_to_csv_escaping_and_formatting() {
+        let mut rec1 = sample_record("vr-1", "2026-09-05T12:00:00Z", 0.85);
+        rec1.printer_name = "Canon \"Pro\" 1000, Tray 1".to_string(); // quotes + comma
+        rec1.profile_name = "FineArt, Velvet".to_string();
+
+        let csv = to_csv(&[rec1]);
+        let lines: Vec<&str> = csv.split("\r\n").filter(|l| !l.is_empty()).collect();
+        assert_eq!(lines.len(), 2);
+        assert_eq!(lines[0], "id,timestamp,printer_name,profile_name,avg_de,max_de,rms_de,patch_count,status");
+        assert!(lines[1].contains("\"Canon \"\"Pro\"\" 1000, Tray 1\""));
+        assert!(lines[1].contains("\"FineArt, Velvet\""));
+    }
+
+    #[test]
+    fn test_validate_csv_dest() {
+        assert!(validate_csv_dest("   ").is_err());
+
+        let p1 = validate_csv_dest("/tmp/history.csv").unwrap();
+        assert_eq!(p1.extension().unwrap(), "csv");
+
+        let p2 = validate_csv_dest("/tmp/history").unwrap();
+        assert_eq!(p2.extension().unwrap(), "csv");
+        assert_eq!(p2.to_string_lossy(), "/tmp/history.csv");
+    }
+
+    #[test]
+    fn test_atomic_write_preserves_data_and_cleans_tmp() {
+        let temp_dir = std::env::temp_dir().join("iccery_test_atomic_write");
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&temp_dir).unwrap();
+
+        let file_path = temp_dir.join("verification_history.json");
+        let mut tmp_file_path = file_path.as_os_str().to_os_string();
+        tmp_file_path.push(".tmp");
+        let tmp_file_path = std::path::PathBuf::from(tmp_file_path);
+
+        let rec = sample_record("vr-atom-1", "2026-09-06T12:00:00Z", 0.5);
+        write_history_file(&file_path, &[rec.clone()]).unwrap();
+
+        assert!(file_path.exists(), "Target file must exist");
+        assert!(!tmp_file_path.exists(), "Temporary file must not remain after successful atomic write");
+
+        let loaded = load_history_file(&file_path);
+        assert_eq!(loaded.len(), 1);
+        assert_eq!(loaded[0], rec);
+
+        // Overwrite with updated records to verify atomic replacement
+        let rec2 = sample_record("vr-atom-2", "2026-09-06T12:05:00Z", 1.2);
+        write_history_file(&file_path, &[rec.clone(), rec2.clone()]).unwrap();
+
+        assert!(!tmp_file_path.exists(), "Temporary file must not remain after overwrite");
+        let loaded2 = load_history_file(&file_path);
+        assert_eq!(loaded2.len(), 2);
+        assert_eq!(loaded2[0], rec);
+        assert_eq!(loaded2[1], rec2);
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+}

src-tauri/src/settings.rs

@@ -74,6 +74,8 @@ pub struct AppSettings {
     pub delta_e_warning_max: f64,
     #[serde(default)]
     pub custom_presets: Vec<ProfilingPreset>,
+    #[serde(default)]
+    pub enable_i1pro2_leds: bool,
 }
 
 impl Default for AppSettings {
@@ -85,6 +87,7 @@ impl Default for AppSettings {
             delta_e_good_max: default_delta_e_good_max(),
             delta_e_warning_max: default_delta_e_warning_max(),
             custom_presets: Vec::new(),
+            enable_i1pro2_leds: false,
         }
     }
 }
@@ -466,4 +469,28 @@ mod tests {
             assert_eq!(parse_log_level_filter(Some("unknown")), log::LevelFilter::Info);
         }
     }
+
+    #[test]
+    fn test_default_enable_i1pro2_leds() {
+        let settings = AppSettings::default();
+        assert_eq!(settings.enable_i1pro2_leds, false);
+    }
+
+    #[test]
+    fn test_enable_i1pro2_leds_serialization() {
+        // Missing field defaults to false
+        let json_empty = "{}";
+        let settings_empty: AppSettings = serde_json::from_str(json_empty).unwrap();
+        assert_eq!(settings_empty.enable_i1pro2_leds, false);
+
+        // Explicit true
+        let json_true = r#"{"enable_i1pro2_leds": true}"#;
+        let settings_true: AppSettings = serde_json::from_str(json_true).unwrap();
+        assert_eq!(settings_true.enable_i1pro2_leds, true);
+
+        // Explicit false
+        let json_false = r#"{"enable_i1pro2_leds": false}"#;
+        let settings_false: AppSettings = serde_json::from_str(json_false).unwrap();
+        assert_eq!(settings_false.enable_i1pro2_leds, false);
+    }
 }

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "ICCery",
-  "version": "0.8.0",
+  "version": "0.8.4",
   "identifier": "com.gronod.iccery",
   "build": {
     "frontendDist": "../src"

src/index.html

@@ -559,6 +559,25 @@
             </div>
           </div>
 
+          <!-- XY Scanning Table Panel -->
+          <div id="xyTableHint" class="notification-banner info hidden">
+            <span>ℹ️</span>
+            <span>SpectroScan → use the SS layout in Stage 2; i1iO → use i1/i1Pro2 layout — the table is auto-detected when chartread starts.</span>
+          </div>
+
+          <div id="xyTablePanel" class="xy-table-panel hidden">
+            <div class="xy-table-header">
+              <h4>XY Automated Scanning Table Sequence</h4>
+              <span id="xyTableActiveStepBadge" class="status-badge badge-idle">Standby</span>
+            </div>
+            <ol class="xy-steps-list">
+              <li id="xyStepPlace" class="xy-step">Place sheet on table</li>
+              <li id="xyStepAlign" class="xy-step">Align reference patches with sight</li>
+              <li id="xyStepScan" class="xy-step">Automated scan in progress</li>
+              <li id="xyStepRemove" class="xy-step">Remove sheet from table</li>
+            </ol>
+          </div>
+
           <!-- State & Prompt Area -->
           <div class="chartread-status">
             <div class="status-label">State: <span id="chartreadState">IDLE</span></div>
@@ -804,6 +823,44 @@
             </div>
           </div>
 
+          <!-- Verification History & Drift Tracking -->
+          <details class="log-container drift-history" id="driftHistorySection">
+            <summary>Verification History &amp; Drift Tracking</summary>
+            <div class="notification-banner warning hidden" id="driftAlertCard">
+              <span id="driftAlertIcon">⚠️</span><span id="driftAlertText"></span>
+            </div>
+            <div class="drift-filter-row hidden" id="driftFilterRow">
+              <label for="driftPrinterFilter">Filter by Printer:</label>
+              <select id="driftPrinterFilter">
+                <option value="">All Printers</option>
+              </select>
+            </div>
+            <div id="driftChartWrap" class="drift-chart-wrap">
+              <svg id="driftTrendChart" role="img" aria-label="Printer Drift Verification History"></svg>
+            </div>
+            <p id="driftEmptyState" class="help-hint">No verification history yet for this profile.</p>
+            <div class="drift-table-wrap">
+              <table id="verificationHistoryTable" class="drift-table">
+                <thead>
+                  <tr>
+                    <th>Date</th>
+                    <th>Printer</th>
+                    <th>Avg ΔE₀₀</th>
+                    <th>Peak ΔE₀₀</th>
+                    <th>RMS ΔE₀₀</th>
+                    <th>Patches</th>
+                    <th>Status</th>
+                  </tr>
+                </thead>
+                <tbody id="verificationHistoryTbody"></tbody>
+              </table>
+            </div>
+            <div class="btn-row">
+              <button type="button" class="secondary" id="btnExportHistoryCsv" disabled>Export CSV…</button>
+              <button type="button" class="danger" id="btnClearHistory" disabled>Clear History</button>
+            </div>
+          </details>
+
           <!-- 3D Gamut Viewer -->
           <div class="gamut-viewer-section">
             <div class="gamut-viewer-header">
@@ -883,9 +940,19 @@
           <label for="argyll_binary_dir">ArgyllCMS Binary Directory Override</label>
           <input type="text" id="argyll_binary_dir" placeholder="Leave empty for bundled sidecars (e.g. /usr/bin)">
         </div>
-        <div class="form-group">
+        <div class="form-group" style="margin-top: 16px; padding-top: 14px; border-top: 1px solid var(--border-color, #333);">
-          <label for="default_instrument">Default Instrument Override</label>
+          <label style="font-weight: 600;">Instrument &amp; Measurement Preferences</label>
-          <input type="text" id="default_instrument" placeholder="e.g. i1">
+          <div style="margin-top: 8px;">
+            <label for="default_instrument" class="sub-label">Default Instrument Override</label>
+            <input type="text" id="default_instrument" placeholder="e.g. i1">
+          </div>
+          <div style="margin-top: 12px;">
+            <label class="checkbox-label" for="enable_i1pro2_leds" style="display: flex; align-items: center; gap: 8px; cursor: pointer;">
+              <input type="checkbox" id="enable_i1pro2_leds">
+              <span>Enable i1Pro 2 status LEDs (<code>-Y l</code>)</span>
+            </label>
+            <small class="help-hint" style="display:block; font-size:0.75rem; color:var(--text-muted, #888); margin-top:3px;">Provides visual status feedback via the instrument ring LEDs during patch reading. Requires patched ArgyllCMS build.</small>
+          </div>
         </div>
         <div class="form-group" style="margin-top: 16px; padding-top: 14px; border-top: 1px solid var(--border-color, #333);">
           <label style="font-weight: 600;">Stage 3 ΔE₀₀ Traffic-Light Thresholds</label>
@@ -940,7 +1007,7 @@
           <img src="./assets/ICCery-logo.svg" alt="ICCery Logo" class="about-logo" />
         </div>
         <h2>About ICCery</h2>
-        <p><strong>Version:</strong> <span id="aboutVersion">v0.7.2</span> &bull; <strong>Build Date:</strong> <span id="aboutBuildDate">September 2026</span></p>
+        <p><strong>Version:</strong> <span id="aboutVersion">v0.8.2</span> &bull; <strong>Build Date:</strong> <span id="aboutBuildDate">September 2026</span></p>
         <p><strong>Copyright &copy; 2026 Gordon Bolton. All rights reserved.</strong></p>
         <h3>Licences & EULA</h3>
         <div class="license-text-container">
@@ -992,9 +1059,9 @@
           <p>Copyright (c) 2010-2023 three.js authors</p>
           <p class="license-legal-block">Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:<br/><br/>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.<br/><br/>THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.</p>
 
-          <h5>Delaunator</h5>
+          <h5>quickhull3d</h5>
-          <p>Copyright (c) 2017, Mapbox</p>
+          <p>MIT License</p>
-          <p class="license-legal-block">Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.<br/><br/>THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.</p>
+          <p class="license-legal-block">Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:<br/><br/>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.<br/><br/>THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.</p>
 
           <h5>Tauri Framework &amp; Rust Dependencies</h5>
           <p>Copyright (c) 2019-present, Tauri Programme within The Commons Conservancy.</p>

src/js/cgats_interop.js

@@ -1,4 +1,6 @@
-const { invoke } = window.__TAURI__.core;
+const invoke = typeof window !== 'undefined' && window.__TAURI__?.core?.invoke
+  ? window.__TAURI__.core.invoke
+  : async () => {};
 
 export class CgatsInterop {
   constructor(appState) {
@@ -22,26 +24,53 @@ export class CgatsInterop {
 
   async handleImport() {
     try {
-      const filePath = await invoke('select_target_file');
+      const filePath = await invoke('select_dataset_file', {
+        defaultDir: this.appState?.cwd || null,
+      });
       if (!filePath) return; // User cancelled
 
-      // Inspect first to show modal (optional, skipping for now, directly import)
+      const isWindows = filePath.includes('\\');
-      // Since we are mocking the UI a bit for this branch, we will just import directly
+      const sep = isWindows ? '\\' : '/';
+      const parts = filePath.split(sep);
+      const fileName = parts.pop();
+      const fileDir = parts.join(sep);
+      const fileStem = fileName.replace(/\.[^/.]+$/, '');
+
+      const targetCwd = this.appState?.cwd || fileDir;
+      const targetBasename = this.appState?.basename || fileStem;
+
+      const targetBasenameInput = document.getElementById('targetBasename');
+      if (targetBasenameInput && !targetBasenameInput.value.trim()) {
+        targetBasenameInput.value = targetBasename;
+      }
+      const selectedPathDisplay = document.getElementById('selectedPathDisplay');
+      if (selectedPathDisplay && (!selectedPathDisplay.textContent || selectedPathDisplay.textContent.includes('No directory') || !this.appState?.cwd)) {
+        selectedPathDisplay.textContent = `Directory: ${targetCwd}`;
+      }
+
+      if (this.appState?.setTarget) {
+        await this.appState.setTarget(targetBasename, targetCwd);
+      }
+
       const summary = await invoke('import_measurement_dataset', {
         filePath,
-        targetCwd: this.appState.cwd,
+        targetCwd,
-        targetBasename: this.appState.basename,
+        targetBasename,
       });
 
-      this.appState.showNotice(`Successfully imported dataset (${summary.patch_count} patches)`, 'success');
+      this.appState?.showNotice?.(`Successfully imported dataset (${summary.patch_count} patches)`, 'success');
       
       // Update state to jump to stage 4
-      await this.appState.updateGating();
+      if (this.appState?.updateGating) {
-      this.appState.currentStage = 4;
+        await this.appState.updateGating();
-      this.appState.applyStageDOM(4);
+      }
+      if (this.appState) {
+        this.appState.currentStage = 4;
+        this.appState.applyStageDOM?.(4);
+      }
       
     } catch (e) {
-      this.appState.showNotice(`Failed to import dataset: ${e}`, 'error');
+      this.appState?.showNotice?.(`Failed to import dataset: ${e}`, 'error');
     }
   }
 

src/js/chartread.js

@@ -45,7 +45,7 @@ export function populateStage3TargetContext(metadata) {
 }
 
 // State machine states
-const STATE = {
+export const STATE = {
   IDLE: "IDLE",
   CALIBRATING: "CALIBRATING",
   AWAITING_STRIP: "AWAITING_STRIP",
@@ -53,13 +53,242 @@ const STATE = {
   ALL_STRIPS_READ: "ALL_STRIPS_READ",
   WARNING: "WARNING",
   PROMPT_CONTINUE: "PROMPT_CONTINUE",
+  TABLE_PLACE_SHEET: "TABLE_PLACE_SHEET",
+  TABLE_ALIGN: "TABLE_ALIGN",
   ERROR: "ERROR",
   FINISHED: "FINISHED",
 };
 
+/**
+ * Classifies a line of stdout from chartread into a state transition, prompt, and metadata.
+ * Pure function with no side-effects or DOM interaction.
+ *
+ * @param {string} line - Raw stdout line
+ * @param {string} currentState - The current STATE value
+ * @returns {{ state: string, prompt: string, matched: boolean, meta?: object }}
+ */
+export function classifyChartreadLine(line, currentState = STATE.IDLE) {
+  if (typeof line !== "string") {
+    return { state: currentState, prompt: "", matched: false };
+  }
+
+  const lineTrim = line.trim();
+  const lineLower = lineTrim.toLowerCase();
+
+  if (!lineTrim) {
+    return { state: currentState, prompt: "", matched: false };
+  }
+
+  // 1. Info-only: Remove last sheet notice (emitted by Argyll before writing .ti3 and exiting)
+  if (lineLower.includes("remove last sheet from table") || lineLower.includes("remove last sheet")) {
+    return {
+      state: currentState,
+      prompt: lineTrim,
+      matched: true,
+      meta: { isRemoveSheetNotice: true },
+    };
+  }
+
+  // 2. Info-only: Sheet read OK
+  const sheetOkMatch = lineTrim.match(/sheet\s+(\d+)\s+of\s+(\d+)\s+read\s+ok/i);
+  if (sheetOkMatch) {
+    return {
+      state: currentState,
+      prompt: lineTrim,
+      matched: true,
+      meta: {
+        sheetOk: true,
+        sheet: parseInt(sheetOkMatch[1], 10),
+        totalSheets: parseInt(sheetOkMatch[2], 10),
+      },
+    };
+  }
+
+  // 3. Fiducial alignment prompt (XY table)
+  // e.g. "locate patch A1 with the sight," or "locate patch 1 with the sight"
+  const alignMatch = lineTrim.match(/locate\s+patch\s+([A-Za-z0-9_]+)\s+with\s+(?:the\s+)?sight/i);
+  if (alignMatch) {
+    return {
+      state: STATE.TABLE_ALIGN,
+      prompt: lineTrim,
+      matched: true,
+      meta: { patch: alignMatch[1] },
+    };
+  }
+  if (lineLower.includes("locate patch") && lineLower.includes("sight")) {
+    const fallbackMatch = lineTrim.match(/locate\s+patch\s+([^\s,]+)/i);
+    return {
+      state: STATE.TABLE_ALIGN,
+      prompt: lineTrim,
+      matched: true,
+      meta: { patch: fallbackMatch ? fallbackMatch[1] : "" },
+    };
+  }
+
+  // 4. Sheet placement prompt (XY table)
+  // e.g. "Please place sheet 1 of 1 on the table" or "Please remove previous sheet and place sheet 2 of 2 on the table"
+  const placeMatch = lineTrim.match(/place\s+sheet\s+(\d+)\s+of\s+(\d+)/i);
+  if (placeMatch) {
+    return {
+      state: STATE.TABLE_PLACE_SHEET,
+      prompt: lineTrim,
+      matched: true,
+      meta: {
+        sheet: parseInt(placeMatch[1], 10),
+        totalSheets: parseInt(placeMatch[2], 10),
+      },
+    };
+  }
+  if (lineLower.includes("place sheet") || lineLower.includes("remove previous sheet")) {
+    return {
+      state: STATE.TABLE_PLACE_SHEET,
+      prompt: lineTrim,
+      matched: true,
+      meta: {},
+    };
+  }
+
+  // 5. Continuation lines ("hit return to continue...", etc.)
+  // Real Argyll XY prompts are two lines:
+  // Line 1: "locate patch A1 with the sight,"
+  // Line 2: "then hit return to continue"
+  // When line 2 arrives, if we are in TABLE_PLACE_SHEET or TABLE_ALIGN, we MUST remain sticky in that table state!
+  const isContinuePrompt =
+    (lineLower.includes("hit return to continue") ||
+     lineLower.includes("then hit return to continue") ||
+     lineLower.includes("hit return to continue, esc or 'q' to give up")) &&
+    !lineLower.includes("use it anyway");
+
+  if (isContinuePrompt) {
+    if (currentState === STATE.TABLE_PLACE_SHEET) {
+      return {
+        state: STATE.TABLE_PLACE_SHEET,
+        prompt: lineTrim,
+        matched: true,
+        meta: { isContinuation: true },
+      };
+    }
+    if (currentState === STATE.TABLE_ALIGN) {
+      return {
+        state: STATE.TABLE_ALIGN,
+        prompt: lineTrim,
+        matched: true,
+        meta: { isContinuation: true },
+      };
+    }
+    return {
+      state: STATE.PROMPT_CONTINUE,
+      prompt: lineTrim,
+      matched: true,
+    };
+  }
+
+  // 6. Strip / measurement completed signals
+  if (
+    lineLower.includes("'d' if done") ||
+    lineLower.includes("'d' when done") ||
+    lineLower.includes("d if done") ||
+    lineLower.includes("d when done") ||
+    lineLower.includes("d to finish") ||
+    lineLower.includes("d to save") ||
+    lineLower.includes("all strips read") ||
+    lineLower.includes("all patches read") ||
+    lineLower.includes("done reading")
+  ) {
+    return {
+      state: STATE.ALL_STRIPS_READ,
+      prompt: lineTrim,
+      matched: true,
+    };
+  }
+
+  // 7. Warning prompts (e.g. unexpected response, use it anyway)
+  if (
+    lineLower.includes("(warning)") ||
+    lineLower.includes("use it anyway") ||
+    lineLower.includes("seem to have read strip pass") ||
+    lineLower.includes("unexpected response")
+  ) {
+    return {
+      state: STATE.WARNING,
+      prompt: lineTrim,
+      matched: true,
+    };
+  }
+
+  // 8. Calibration prompts
+  if (
+    ((lineLower.includes("place") &&
+      (lineLower.includes("reference") ||
+       lineLower.includes("white") ||
+       lineLower.includes("calibrat") ||
+       lineLower.includes("standard"))) ||
+     lineLower.includes("hit any key to continue") ||
+     lineLower.includes("calibration")) &&
+    !lineLower.includes("place sheet") &&
+    !lineLower.includes("locate patch")
+  ) {
+    return {
+      state: STATE.CALIBRATING,
+      prompt: lineTrim,
+      matched: true,
+    };
+  }
+
+  // 9. Ready to read / Strip trigger (handheld / strip readers)
+  if (
+    ((lineLower.includes("hit") && lineLower.includes("read") && lineLower.includes("strip")) ||
+     lineLower.includes("ready to read") ||
+     (lineLower.includes("read") && lineLower.includes("strip") && lineLower.includes("key"))) &&
+    !lineLower.includes("all strips read")
+  ) {
+    return {
+      state: STATE.AWAITING_STRIP,
+      prompt: lineTrim,
+      matched: true,
+    };
+  }
+
+  // 10. Reading / Scanning
+  if (
+    lineLower.includes("reading strip") ||
+    lineLower.includes("processing") ||
+    lineLower.includes("scanning") ||
+    lineLower.includes("reading sheet")
+  ) {
+    return {
+      state: STATE.READING,
+      prompt: lineTrim,
+      matched: true,
+    };
+  }
+
+  // 11. Errors
+  if (
+    lineLower.includes("error") ||
+    lineLower.includes("too fast") ||
+    lineLower.includes("too slow") ||
+    lineLower.includes("misread") ||
+    lineLower.includes("failed to read")
+  ) {
+    return {
+      state: STATE.ERROR,
+      prompt: lineTrim,
+      matched: true,
+    };
+  }
+
+  return {
+    state: currentState,
+    prompt: lineTrim,
+    matched: false,
+  };
+}
+
 let currentState = STATE.IDLE;
 let currentProcessId = "";
 let measurementInProgress = false;
+let xyTableDetected = false;
 let currentPassIndex = 0;
 const recordedPasses = [];
 
@@ -83,6 +312,82 @@ export function initChartread() {
   const passCounterBadge = document.getElementById("passCounterBadge");
   const btnMeasureAnotherSheet = document.getElementById("btnMeasureAnotherSheet");
   const btnFinishAndAverage = document.getElementById("btnFinishAndAverage");
+  const xyTableHint = document.getElementById("xyTableHint");
+  const xyTablePanel = document.getElementById("xyTablePanel");
+  const xyTableActiveStepBadge = document.getElementById("xyTableActiveStepBadge");
+  const xyStepPlace = document.getElementById("xyStepPlace");
+  const xyStepAlign = document.getElementById("xyStepAlign");
+  const xyStepScan = document.getElementById("xyStepScan");
+  const xyStepRemove = document.getElementById("xyStepRemove");
+
+  function setXyTableVisible(visible) {
+    if (xyTableHint) {
+      if (visible) xyTableHint.classList.remove("hidden");
+      else xyTableHint.classList.add("hidden");
+    }
+    if (xyTablePanel) {
+      if (visible) xyTablePanel.classList.remove("hidden");
+      else xyTablePanel.classList.add("hidden");
+    }
+  }
+
+  function updateXyTableSequence(phase) {
+    if (!xyTablePanel) return;
+
+    const steps = [
+      { el: xyStepPlace, name: "place" },
+      { el: xyStepAlign, name: "align" },
+      { el: xyStepScan, name: "scan" },
+      { el: xyStepRemove, name: "remove" },
+    ];
+
+    const phaseOrder = ["place", "align", "scan", "remove", "done"];
+    const targetIndex = phaseOrder.indexOf(phase);
+
+    steps.forEach((step, idx) => {
+      if (!step.el) return;
+      step.el.classList.remove("active", "completed");
+      if (targetIndex >= 0) {
+        if (idx < targetIndex) {
+          step.el.classList.add("completed");
+        } else if (idx === targetIndex && phase !== "done") {
+          step.el.classList.add("active");
+        } else if (phase === "done") {
+          step.el.classList.add("completed");
+        }
+      }
+    });
+
+    if (xyTableActiveStepBadge) {
+      xyTableActiveStepBadge.className = "status-badge";
+      switch (phase) {
+        case "place":
+          xyTableActiveStepBadge.textContent = "Step 1: Place Sheet";
+          xyTableActiveStepBadge.classList.add("badge-primary");
+          break;
+        case "align":
+          xyTableActiveStepBadge.textContent = "Step 2: Align Patches";
+          xyTableActiveStepBadge.classList.add("badge-primary");
+          break;
+        case "scan":
+          xyTableActiveStepBadge.textContent = "Step 3: Scanning";
+          xyTableActiveStepBadge.classList.add("badge-primary");
+          break;
+        case "remove":
+          xyTableActiveStepBadge.textContent = "Step 4: Remove Sheet";
+          xyTableActiveStepBadge.classList.add("badge-primary");
+          break;
+        case "done":
+          xyTableActiveStepBadge.textContent = "Complete";
+          xyTableActiveStepBadge.classList.add("badge-good");
+          break;
+        default:
+          xyTableActiveStepBadge.textContent = "Standby";
+          xyTableActiveStepBadge.classList.add("badge-idle");
+          break;
+      }
+    }
+  }
 
   function setMeasurementBusy(busy) {
     measurementInProgress = busy;
@@ -182,7 +487,13 @@ export function initChartread() {
               const opt = document.createElement("option");
               // Port value for -c switch. If port is 1 or auto, empty string leaves -c omitted for default port
               opt.value = inst.port && inst.port !== "1" ? inst.port : "";
-              opt.textContent = `${inst.type || inst.name}${inst.port ? ` (Port ${inst.port})` : ""}`;
+              const isXy = /spectro\s?scan|i1io/i.test(inst.name) || /spectro\s?scan|i1io/i.test(inst.type);
+              if (isXy) {
+                opt.dataset.xy = "1";
+                opt.textContent = `${inst.type || inst.name}${inst.port ? ` (Port ${inst.port})` : ""} · XY Table`;
+              } else {
+                opt.textContent = `${inst.type || inst.name}${inst.port ? ` (Port ${inst.port})` : ""}`;
+              }
               instrumentSelect.appendChild(opt);
             });
             instrumentSelect.value = "";
@@ -202,6 +513,21 @@ export function initChartread() {
     });
   }
 
+  if (instrumentSelect) {
+    instrumentSelect.addEventListener("change", () => {
+      const selectedOpt = instrumentSelect.selectedOptions && instrumentSelect.selectedOptions[0];
+      const isXy = Boolean(selectedOpt && selectedOpt.dataset && selectedOpt.dataset.xy === "1");
+      if (isXy) {
+        xyTableDetected = true;
+        setXyTableVisible(true);
+        updateXyTableSequence("standby");
+      } else if (!measurementInProgress) {
+        xyTableDetected = false;
+        setXyTableVisible(false);
+      }
+    });
+  }
+
   function setState(newState) {
     currentState = newState;
     if (stateLabel) stateLabel.textContent = newState;
@@ -287,6 +613,22 @@ export function initChartread() {
         }
         if (btnCancel) btnCancel.classList.remove("hidden");
         break;
+      case STATE.TABLE_PLACE_SHEET:
+        if (btnAccept) {
+          btnAccept.disabled = false;
+          btnAccept.textContent = "✓ Sheet Placed — Continue";
+          btnAccept.classList.remove("hidden");
+        }
+        if (btnCancel) btnCancel.classList.remove("hidden");
+        break;
+      case STATE.TABLE_ALIGN:
+        if (btnAccept) {
+          btnAccept.disabled = false;
+          btnAccept.textContent = "✓ Aligned — Continue";
+          btnAccept.classList.remove("hidden");
+        }
+        if (btnCancel) btnCancel.classList.remove("hidden");
+        break;
       case STATE.ERROR:
         if (btnRetry) {
           btnRetry.disabled = false;
@@ -339,6 +681,15 @@ export function initChartread() {
       setState(STATE.CALIBRATING);
       setPrompt("Starting chartread... waiting for instrument calibration prompt.");
 
+      const selectedOpt = instrumentSelect && instrumentSelect.selectedOptions && instrumentSelect.selectedOptions[0];
+      if (selectedOpt && selectedOpt.dataset && selectedOpt.dataset.xy === "1") {
+        xyTableDetected = true;
+        setXyTableVisible(true);
+        updateXyTableSequence("standby");
+      } else {
+        xyTableDetected = false;
+      }
+
       const selectedPort = instrumentSelect && instrumentSelect.value ? instrumentSelect.value : null;
 
       const config = {
@@ -365,69 +716,74 @@ export function initChartread() {
           logPre.textContent += line + "\n";
           logPre.scrollTop = logPre.scrollHeight;
 
-          // Parse prompts for state transitions
+          const classified = classifyChartreadLine(line, currentState);
-          const lineLower = line.toLowerCase();
 
-          if (
+          if (classified.matched) {
-            lineLower.includes("'d' if done") ||
+            if (
-            lineLower.includes("'d' when done") ||
+              classified.state === STATE.TABLE_PLACE_SHEET ||
-            lineLower.includes("d if done") ||
+              classified.state === STATE.TABLE_ALIGN ||
-            lineLower.includes("d when done") ||
+              (classified.meta && (classified.meta.isRemoveSheetNotice || classified.meta.sheetOk))
-            lineLower.includes("d to finish") ||
+            ) {
-            lineLower.includes("d to save") ||
+              if (!xyTableDetected) {
-            lineLower.includes("all strips read") ||
+                xyTableDetected = true;
-            lineLower.includes("all patches read") ||
+                setXyTableVisible(true);
-            lineLower.includes("done reading")
+              }
-          ) {
+            }
-            setState(STATE.ALL_STRIPS_READ);
+
-            setPrompt(`🎉 ${line.trim()} — Click 'Done & Save .ti3' to save.`);
+            if (xyTableDetected) {
-          } else if (
+              if (classified.state === STATE.TABLE_PLACE_SHEET) {
-            lineLower.includes("(warning)") ||
+                updateXyTableSequence("place");
-            lineLower.includes("use it anyway") ||
+              } else if (classified.state === STATE.TABLE_ALIGN) {
-            lineLower.includes("seem to have read strip pass") ||
+                updateXyTableSequence("align");
-            lineLower.includes("unexpected response") ||
+              } else if (classified.state === STATE.READING) {
-            lineLower.includes("hit return to use it anyway")
+                updateXyTableSequence("scan");
-          ) {
+              } else if (classified.meta && classified.meta.isRemoveSheetNotice) {
-            const previousPrompt = promptText ? promptText.textContent.trim() : "";
+                updateXyTableSequence("remove");
-            const isContinuationPrompt = lineLower.includes("hit return to use it anyway") || lineLower.includes("use it anyway");
+              }
-            setState(STATE.WARNING);
+            }
-            if (currentState === STATE.WARNING && isContinuationPrompt && previousPrompt && !previousPrompt.includes(line.trim())) {
+
-              setPrompt(`${previousPrompt}\n${line.trim()}`);
+            if (classified.state !== currentState) {
-            } else {
+              setState(classified.state);
-              setPrompt(line.trim());
+            }
+
+            if (classified.state === STATE.TABLE_PLACE_SHEET) {
+              const sheetInfo = (classified.meta && classified.meta.sheet && classified.meta.totalSheets)
+                ? ` (Sheet ${classified.meta.sheet} of ${classified.meta.totalSheets})`
+                : "";
+              setPrompt(`📋 ${classified.prompt}${sheetInfo}`);
+            } else if (classified.state === STATE.TABLE_ALIGN) {
+              const patchInfo = (classified.meta && classified.meta.patch)
+                ? ` [Patch ${classified.meta.patch}]`
+                : "";
+              setPrompt(`🎯 ${classified.prompt}${patchInfo}`);
+            } else if (classified.meta && classified.meta.isRemoveSheetNotice) {
+              setPrompt(`ℹ️ ${classified.prompt}`);
+            } else if (classified.meta && classified.meta.sheetOk) {
+              setPrompt(`✅ ${classified.prompt}`);
+            } else if (classified.state === STATE.ALL_STRIPS_READ) {
+              setPrompt(`🎉 ${classified.prompt} — Click 'Done & Save .ti3' to save.`);
+            } else if (classified.state === STATE.WARNING) {
+              const previousPrompt = promptText ? promptText.textContent.trim() : "";
+              const lineLower = line.toLowerCase();
+              const isContinuationPrompt = lineLower.includes("hit return to use it anyway") || lineLower.includes("use it anyway");
+              if (currentState === STATE.WARNING && isContinuationPrompt && previousPrompt && !previousPrompt.includes(line.trim())) {
+                setPrompt(`${previousPrompt}\n${line.trim()}`);
+              } else {
+                setPrompt(classified.prompt);
+              }
+            } else if (classified.state === STATE.ERROR) {
+              setPrompt("⚠️ " + classified.prompt);
+            } else {
+              setPrompt(classified.prompt);
             }
-          } else if (
-            lineLower.includes("place sheet") ||
-            lineLower.includes("remove previous sheet") ||
-            (lineLower.includes("hit return to continue") && !lineLower.includes("use it anyway"))
-          ) {
-            setState(STATE.PROMPT_CONTINUE);
-            setPrompt(line.trim());
-          } else if (
-            (lineLower.includes("place") && (lineLower.includes("reference") || lineLower.includes("white") || lineLower.includes("calibrat") || lineLower.includes("standard"))) ||
-            lineLower.includes("hit any key to continue") ||
-            lineLower.includes("calibration")
-          ) {
-            setState(STATE.CALIBRATING);
-            setPrompt(line.trim());
-          } else if (
-            (lineLower.includes("hit") && lineLower.includes("read") && lineLower.includes("strip")) ||
-            lineLower.includes("ready to read") ||
-            (lineLower.includes("read") && lineLower.includes("strip") && lineLower.includes("key"))
-          ) {
-            setState(STATE.AWAITING_STRIP);
-            setPrompt(line.trim());
-          } else if (lineLower.includes("reading strip") || lineLower.includes("processing")) {
-            setState(STATE.READING);
-            setPrompt(line.trim());
-          } else if (lineLower.includes("error") || lineLower.includes("too fast") || lineLower.includes("too slow") || lineLower.includes("misread") || lineLower.includes("failed to read")) {
-            setState(STATE.ERROR);
-            setPrompt("⚠️ " + line.trim());
           }
         });
 
+        let lastStderrLine = "";
+
         const unlistenStderr = await listen("process:stderr", (event) => {
           if (event.payload.id === currentProcessId && event.payload.line) {
+            lastStderrLine = event.payload.line;
             logPre.textContent += "ERR: " + event.payload.line + "\n";
             logPre.scrollTop = logPre.scrollHeight;
           }
@@ -441,6 +797,9 @@ export function initChartread() {
           stopSwatchListener();
 
           if (event.payload.code === 0) {
+            if (xyTableDetected) {
+              updateXyTableSequence("done");
+            }
             try {
               const passIndex = currentPassIndex + 1;
               const filename = await invoke("snapshot_ti3", {
@@ -471,8 +830,10 @@ export function initChartread() {
             }
           } else {
             setState(STATE.FINISHED);
-            setPrompt(`❌ chartread exited with code ${event.payload.code}.`);
+            if (logContainer) logContainer.open = true;
-            logPre.textContent += `\n[ERROR] chartread exited with code ${event.payload.code}.\n`;
+            const errDetail = lastStderrLine ? ` (${lastStderrLine})` : "";
+            setPrompt(`❌ chartread exited with code ${event.payload.code}.${errDetail}`);
+            logPre.textContent += `\n[ERROR] chartread exited with code ${event.payload.code}.${errDetail}\n`;
           }
 
           setMeasurementBusy(false);
@@ -610,8 +971,12 @@ export function initChartread() {
       try {
         btnAccept.disabled = true;
         await invoke("send_stdin", { id: currentProcessId, input: "\n" });
-        setState(STATE.READING);
+        if (currentState === STATE.TABLE_PLACE_SHEET || currentState === STATE.TABLE_ALIGN) {
-        setPrompt("Accepted. Processing...");
+          setPrompt("Continuing XY table sequence...");
+        } else {
+          setState(STATE.READING);
+          setPrompt("Accepted. Processing...");
+        }
       } catch (e) {
         console.error("send_stdin error:", e);
         btnAccept.disabled = false;
@@ -677,14 +1042,27 @@ export function initChartread() {
   if (btnCancel) {
     btnCancel.addEventListener("click", async () => {
       try {
+        btnCancel.disabled = true;
+        if (currentState === STATE.TABLE_PLACE_SHEET || currentState === STATE.TABLE_ALIGN || xyTableDetected) {
+          // For XY table states, send 'q\n' first to allow the table to park its measurement head gracefully
+          try {
+            await invoke("send_stdin", { id: currentProcessId, input: "q\n" });
+          } catch (_) {}
+          // Brief pause before kill to allow graceful parking
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
         await invoke("kill_process", { id: currentProcessId });
         stopSwatchListener();
         setState(recordedPasses.length > 0 ? STATE.FINISHED : STATE.IDLE);
         setPrompt("Measurement cancelled.");
+        if (xyTableDetected) {
+          updateXyTableSequence("standby");
+        }
       } catch (e) {
         console.error("kill_process error:", e);
         setPrompt(`Cancel failed: ${e}`);
       } finally {
+        btnCancel.disabled = false;
         setMeasurementBusy(false);
         stopSwatchListener();
       }

src/js/chartread.test.js

@@ -0,0 +1,153 @@
+// Unit & console tests for chartread.js stdout classifier and state machine transitions.
+// Can be run in browser devtools console:
+//   import('./chartread.test.js').then(m => m.runAll())
+// Or in Node:
+//   node src/js/chartread.test.js
+
+// Node environment polyfill for browser globals
+if (typeof window === 'undefined') {
+  globalThis.window = {
+    __TAURI__: {
+      core: { invoke: () => Promise.resolve() },
+      event: {
+        listen: () => Promise.resolve(() => {}),
+        emit: () => Promise.resolve(),
+      },
+    },
+    addEventListener: () => {},
+    dispatchEvent: () => {},
+  };
+  globalThis.document = {
+    getElementById: () => null,
+    querySelectorAll: () => [],
+    createElement: () => ({
+      classList: { add: () => {}, remove: () => {} },
+      style: {},
+      appendChild: () => {},
+    }),
+  };
+}
+
+const { STATE, classifyChartreadLine } = await import('./chartread.js');
+
+export function runAll() {
+  console.group('Chartread Classifier & XY Table Tests');
+  let passed = 0;
+  let total = 0;
+
+  function assert(actual, expected, message) {
+    total++;
+    const ok = JSON.stringify(actual) === JSON.stringify(expected);
+    if (ok) {
+      console.log('PASS:', message);
+      passed++;
+    } else {
+      console.error('FAIL:', message, '\nExpected:', expected, '\nGot:', actual);
+    }
+    return ok;
+  }
+
+  // 1. XY Sheet Placement prompts
+  const place1 = classifyChartreadLine("Please place sheet 1 of 1 on the table", STATE.CALIBRATING);
+  assert(place1.state, STATE.TABLE_PLACE_SHEET, 'sheet 1 of 1 state TABLE_PLACE_SHEET');
+  assert(place1.matched, true, 'sheet 1 of 1 matched');
+  assert(place1.meta?.sheet, 1, 'sheet 1 of 1 sheet number 1');
+  assert(place1.meta?.totalSheets, 1, 'sheet 1 of 1 total sheets 1');
+
+  const place2 = classifyChartreadLine("Please remove previous sheet and place sheet 2 of 2 on the table", STATE.READING);
+  assert(place2.state, STATE.TABLE_PLACE_SHEET, 'sheet 2 of 2 state TABLE_PLACE_SHEET');
+  assert(place2.meta?.sheet, 2, 'sheet 2 of 2 sheet number 2');
+  assert(place2.meta?.totalSheets, 2, 'sheet 2 of 2 total sheets 2');
+
+  const placeGeneric = classifyChartreadLine("place sheet on table", STATE.IDLE);
+  assert(placeGeneric.state, STATE.TABLE_PLACE_SHEET, 'generic place sheet state TABLE_PLACE_SHEET');
+
+  // 2. XY Fiducial patch alignment prompts
+  const fid1 = classifyChartreadLine("locate patch A1 with the sight,", STATE.TABLE_PLACE_SHEET);
+  assert(fid1.state, STATE.TABLE_ALIGN, 'locate patch A1 state TABLE_ALIGN');
+  assert(fid1.matched, true, 'locate patch A1 matched');
+  assert(fid1.meta?.patch, "A1", 'locate patch A1 meta patch');
+
+  const fid2 = classifyChartreadLine("locate patch B24 with the sight", STATE.TABLE_ALIGN);
+  assert(fid2.state, STATE.TABLE_ALIGN, 'locate patch B24 state TABLE_ALIGN');
+  assert(fid2.meta?.patch, "B24", 'locate patch B24 meta patch');
+
+  const fid3 = classifyChartreadLine("locate patch 1 with sight", STATE.TABLE_ALIGN);
+  assert(fid3.state, STATE.TABLE_ALIGN, 'locate patch 1 state TABLE_ALIGN');
+  assert(fid3.meta?.patch, "1", 'locate patch 1 meta patch');
+
+  // 3. Two-line prompt sticky transitions
+  // A continuation line arriving while in TABLE_PLACE_SHEET must remain in TABLE_PLACE_SHEET
+  const contSheet1 = classifyChartreadLine("hit return to continue, Esc or 'q' to give up", STATE.TABLE_PLACE_SHEET);
+  assert(contSheet1.state, STATE.TABLE_PLACE_SHEET, 'sheet continuation remains in TABLE_PLACE_SHEET');
+  assert(contSheet1.meta?.isContinuation, true, 'sheet continuation flag set');
+
+  const contSheet2 = classifyChartreadLine("then hit return to continue", STATE.TABLE_PLACE_SHEET);
+  assert(contSheet2.state, STATE.TABLE_PLACE_SHEET, 'then hit return remains in TABLE_PLACE_SHEET');
+
+  // A continuation line arriving while in TABLE_ALIGN must remain in TABLE_ALIGN
+  const contAlign1 = classifyChartreadLine("then hit return to continue", STATE.TABLE_ALIGN);
+  assert(contAlign1.state, STATE.TABLE_ALIGN, 'align continuation remains in TABLE_ALIGN');
+  assert(contAlign1.meta?.isContinuation, true, 'align continuation flag set');
+
+  const contAlign2 = classifyChartreadLine("hit return to continue, Esc or 'q' to give up", STATE.TABLE_ALIGN);
+  assert(contAlign2.state, STATE.TABLE_ALIGN, 'align esc/q continuation remains in TABLE_ALIGN');
+
+  // Continuation prompt in strip mode becomes generic PROMPT_CONTINUE
+  const contStrip = classifyChartreadLine("hit return to continue", STATE.READING);
+  assert(contStrip.state, STATE.PROMPT_CONTINUE, 'strip continue transitions to PROMPT_CONTINUE');
+
+  // 4. Final sheet removal notice (Info-only, does not change state or trigger stdin prompt)
+  const removeSheet = classifyChartreadLine("Please remove last sheet from table", STATE.READING);
+  assert(removeSheet.state, STATE.READING, 'remove last sheet notice preserves currentState');
+  assert(removeSheet.matched, true, 'remove last sheet notice is matched');
+  assert(removeSheet.meta?.isRemoveSheetNotice, true, 'remove last sheet notice flag set');
+
+  // 5. Sheet read OK notices
+  const sheetOk = classifyChartreadLine("Sheet 1 of 1 read OK", STATE.READING);
+  assert(sheetOk.matched, true, 'sheet read OK matched');
+  assert(sheetOk.meta?.sheetOk, true, 'sheet read OK flag');
+  assert(sheetOk.meta?.sheet, 1, 'sheet read OK sheet 1');
+  assert(sheetOk.meta?.totalSheets, 1, 'sheet read OK totalSheets 1');
+
+  // 6. Strip mode regressions
+  const calib = classifyChartreadLine("Place instrument on calibration tile and hit [Space] to calibrate.", STATE.IDLE);
+  assert(calib.state, STATE.CALIBRATING, 'strip calibration prompt transitions to CALIBRATING');
+
+  const awaitStrip = classifyChartreadLine("Hit [Space] to read strip A (or 's' to skip).", STATE.CALIBRATING);
+  assert(awaitStrip.state, STATE.AWAITING_STRIP, 'strip prompt transitions to AWAITING_STRIP');
+
+  const readingStrip = classifyChartreadLine("Reading strip A...", STATE.AWAITING_STRIP);
+  assert(readingStrip.state, STATE.READING, 'reading strip transitions to READING');
+
+  const readingSheet = classifyChartreadLine("Reading sheet 1...", STATE.TABLE_ALIGN);
+  assert(readingSheet.state, STATE.READING, 'reading sheet transitions to READING');
+
+  const warning = classifyChartreadLine("Warning: unexpected response from instrument", STATE.READING);
+  assert(warning.state, STATE.WARNING, 'unexpected response transitions to WARNING');
+
+  const warnAnyway = classifyChartreadLine("Hit return to use it anyway", STATE.WARNING);
+  assert(warnAnyway.state, STATE.WARNING, 'use it anyway stays in WARNING');
+
+  const allStripsDone = classifyChartreadLine("All strips read. Hit 'd' when done", STATE.READING);
+  assert(allStripsDone.state, STATE.ALL_STRIPS_READ, 'all strips read transitions to ALL_STRIPS_READ');
+
+  const err = classifyChartreadLine("Fatal error: instrument communication failed", STATE.READING);
+  assert(err.state, STATE.ERROR, 'instrument communication failed transitions to ERROR');
+
+  const unrecognized = classifyChartreadLine("some debug log output [1234]", STATE.READING);
+  assert(unrecognized.state, STATE.READING, 'unrecognized line preserves currentState');
+  assert(unrecognized.matched, false, 'unrecognized line matched is false');
+
+  console.log(`\nResults: ${passed} / ${total} tests passed.`);
+  console.groupEnd();
+
+  if (passed !== total) {
+    throw new Error(`Chartread tests failed: ${total - passed} failure(s)`);
+  }
+}
+
+// Auto-run if executed in Node.js
+if (typeof process !== 'undefined' && process.argv && process.argv[1]?.endsWith('chartread.test.js')) {
+  runAll();
+}

src/js/colprof.js

@@ -54,8 +54,8 @@ export function initColprof() {
   if (btnBrowseCustomSp && colprofCustomSpPath) {
     btnBrowseCustomSp.addEventListener("click", async () => {
       try {
-        const selected = await window.__TAURI__.dialog.open({
+        const selected = await invoke("select_spectrum_file", {
-          filters: [{ name: 'Spectrum', extensions: ['sp'] }]
+          defaultDir: chartreadCwd || wizardState.cwd || null,
         });
         if (selected) {
           colprofCustomSpPath.value = selected;

src/js/gamut_viewer.js

@@ -1,8 +1,7 @@
-import { computeQuickHull } from "./vendor/quickhull.js";
+import { computeQuickHull } from "./vendor/quickhull.js";
 import { labToSrgb } from "./color_convert.js";
 
-const { invoke } = window.__TAURI__.core;
+const invoke = typeof window !== 'undefined' && window.__TAURI__?.core?.invoke ? window.__TAURI__.core.invoke : null;
-const { listen } = window.__TAURI__.event;
 
 let scene, camera, renderer, labelRenderer, controls;
 let currentProfileMesh = null;

src/js/gamut_viewer.test.js

@@ -1,20 +1,50 @@
-// Manual / browser-console tests for gamut_viewer.js and profcheck.js parsing.
+// Unit & console tests for gamut_viewer.js parsing.
-// Run in a browser/devtools console after the app has loaded:
+// Can be run in browser devtools console:
 //   import('./gamut_viewer.test.js').then(m => m.runAll())
+// Or in Node:
+//   node src/js/gamut_viewer.test.js
 
-import { parseGamutFile } from './gamut_viewer.js';
+// Node environment polyfill for browser globals
+if (typeof window === 'undefined') {
+  globalThis.window = {
+    __TAURI__: {
+      core: { invoke: () => Promise.resolve() },
+      event: { listen: () => Promise.resolve(() => {}) }
+    },
+    addEventListener: () => {},
+    dispatchEvent: () => {}
+  };
+  globalThis.document = {
+    getElementById: () => null,
+    querySelectorAll: () => []
+  };
+}
+
+const { parseGamutFile } = await import('./gamut_viewer.js');
+
+let passed = 0;
+let total = 0;
 
 export function runAll() {
-  console.group('gamut/profcheck parser tests');
+  console.group('Gamut Viewer Parser Tests');
+  passed = 0;
+  total = 0;
   testParseGamutBasic();
   testParseGamutDualTable();
   testParseGamutWithComments();
+  console.log(`\nResults: ${passed} / ${total} tests passed.`);
   console.groupEnd();
+
+  if (passed !== total) {
+    throw new Error(`Gamut viewer parser tests failed: ${total - passed} failure(s)`);
+  }
 }
 
 function assertEqual(actual, expected, message) {
+  total++;
   const ok = JSON.stringify(actual) === JSON.stringify(expected);
   if (ok) {
+    passed++;
     console.log('PASS:', message);
   } else {
     console.error('FAIL:', message, 'expected', expected, 'got', actual);
@@ -78,3 +108,8 @@ END_DATA`;
   assertEqual(vertices.length, 4, 'commented gamut vertex count');
   assertEqual(faces.length, 2, 'commented gamut face count');
 }
+
+// Auto-run if executed in Node.js
+if (typeof process !== 'undefined' && process.argv && process.argv[1]?.endsWith('gamut_viewer.test.js')) {
+  runAll();
+}

src/js/printtarg.js

@@ -574,6 +574,7 @@ export function initPrinttarg() {
       showNotification("error", "Please select a destination printer first.");
       return;
     }
+    wizardState.printerName = printerName;
 
     const options = getSelectedPrintOptions();
     const origBtnContent = triggeringButton ? triggeringButton.innerHTML : "";
@@ -619,6 +620,7 @@ export function initPrinttarg() {
         showNotification("error", "Please select a destination printer first.");
         return;
       }
+      wizardState.printerName = printerName;
 
       const options = getSelectedPrintOptions();
       const cwd = stage1Cwd;

src/js/profcheck.js

@@ -14,6 +14,423 @@ export function setStage4Result(basename, cwd) {
   profileBasename = basename || wizardState.basename;
   profileCwd = cwd || wizardState.cwd;
   wizardState.setTarget(profileBasename, profileCwd);
+  loadVerificationHistory();
+}
+
+/**
+ * Parse profcheck output for Average, Peak, and RMS delta-E values and patch count.
+ * Supports Argyll's -u JSON summary object, text summary line, and legacy plain-text output.
+ * @param {string} stdout - Full profcheck stdout.
+ * @returns {{ avgDe: number, maxDe: number, rmsDe: number, patchCount: number, warnings: string[] }}
+ */
+export function parseProfcheckReport(stdout) {
+  let avgDe = 0.0;
+  let maxDe = 0.0;
+  let rmsDe = 0.0;
+  let patchCount = 0;
+  const warnings = [];
+
+  if (!stdout || typeof stdout !== 'string') {
+    return { avgDe, maxDe, rmsDe, patchCount, warnings: ['No stdout received from profcheck.'] };
+  }
+
+  // Parse patch count from "No of test patches = (\d+)"
+  const patchMatch = stdout.match(/No\s+of\s+test\s+patches\s*=\s*(\d+)/i);
+  if (patchMatch) {
+    patchCount = parseInt(patchMatch[1], 10);
+  }
+
+  // Argyll's JSON output can appear either as a compact object on a single
+  // line or embedded inside larger text. Accept objects with event === "report"
+  // or containing any of avg_de, avg_de2000, peak_de, peak_de2000, rms, rms_de.
+  const jsonObjects = [];
+  const re = /\{[\s\S]*?\}/g;
+  let m;
+  while ((m = re.exec(stdout)) !== null) {
+    try {
+      const parsed = JSON.parse(m[0]);
+      if (typeof parsed === 'object' && parsed !== null) {
+        if (
+          parsed.event === 'report' ||
+          'avg_de' in parsed ||
+          'avg_de2000' in parsed ||
+          'peak_de' in parsed ||
+          'peak_de2000' in parsed ||
+          'rms' in parsed ||
+          'rms_de' in parsed
+        ) {
+          jsonObjects.push(parsed);
+        }
+      }
+    } catch (e) {
+      // Not a valid JSON object, ignore.
+    }
+  }
+
+  if (jsonObjects.length > 0) {
+    // When several report objects exist (de2000, de94, de), prefer *de2000 object matching -k
+    const de2000Obj = jsonObjects.find(o => 'avg_de2000' in o || 'peak_de2000' in o);
+    const targetJson = de2000Obj || jsonObjects[jsonObjects.length - 1];
+
+    avgDe = typeof targetJson.avg_de2000 === 'number' ? targetJson.avg_de2000 :
+            (typeof targetJson.avg_de === 'number' ? targetJson.avg_de : 0);
+    maxDe = typeof targetJson.peak_de2000 === 'number' ? targetJson.peak_de2000 :
+            (typeof targetJson.max_de === 'number' ? targetJson.max_de :
+            (typeof targetJson.peak_de === 'number' ? targetJson.peak_de : 0));
+    rmsDe = typeof targetJson.rms === 'number' ? targetJson.rms :
+            (typeof targetJson.rms_de === 'number' ? targetJson.rms_de : 0);
+  } else {
+    // Check for standard Argyll text summary line:
+    // Profile check complete, errors...: max. = %f, avg. = %f, RMS = %f
+    const summaryMatch = stdout.match(/Profile check complete,\s*errors[^\:]*:\s*max\.\s*=\s*([\d\.]+),\s*avg\.\s*=\s*([\d\.]+),\s*RMS\s*=\s*([\d\.]+)/i);
+    if (summaryMatch) {
+      maxDe = parseFloat(summaryMatch[1]);
+      avgDe = parseFloat(summaryMatch[2]);
+      rmsDe = parseFloat(summaryMatch[3]);
+    } else {
+      // Regex fallbacks for standard profcheck text output
+      const avgPatterns = [
+        /avg(?:\.?|erage)\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
+        /average\s+(?:dE\s*)?([\d\.]+)/i,
+        /mean\s+(?:dE\s*)?([\d\.]+)/i,
+        /dE\s+average[^\d]*([\d\.]+)/i,
+      ];
+      const maxPatterns = [
+        /max(?:\.?|imum)\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
+        /peak\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
+        /worst\s*(?:dE\s*)?([\d\.]+)/i,
+        /dE\s+max[^\d]*([\d\.]+)/i,
+      ];
+      const rmsPatterns = [
+        /RMS(?:\.?)\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
+        /rms(?:\.?)\s*(?:dE\s*)?([\d\.]+)/i,
+        /root\s+mean\s+sq(?:uare)?\s*(?:dE\s*)?([\d\.]+)/i,
+      ];
+
+      const find = (patterns) => {
+        for (const p of patterns) {
+          const match = stdout.match(p);
+          if (match) return match;
+        }
+        return null;
+      };
+
+      const avgMatch = find(avgPatterns);
+      const maxMatch = find(maxPatterns);
+      const rmsMatch = find(rmsPatterns);
+
+      if (avgMatch) avgDe = parseFloat(avgMatch[1]);
+      else warnings.push('Could not detect Average ΔE in profcheck output.');
+
+      if (maxMatch) maxDe = parseFloat(maxMatch[1]);
+      else warnings.push('Could not detect Peak ΔE in profcheck output.');
+
+      if (rmsMatch) rmsDe = parseFloat(rmsMatch[1]);
+      else warnings.push('Could not detect RMS ΔE in profcheck output.');
+
+      if (!avgMatch && !maxMatch && !rmsMatch) {
+        warnings.push('No delta-E values were found in profcheck output.');
+      }
+    }
+  }
+
+  return { avgDe, maxDe, rmsDe, patchCount, warnings };
+}
+
+/**
+ * Checks for a printer drift breach condition:
+ * Returns an alert string if the last >=2 consecutive records have avg_de >= 3.5
+ * and span distinct calendar dates (or are >= 1 hour apart).
+ * @param {Array<object>} records - Array of verification records sorted ascending by timestamp.
+ * @returns {string|null} Alert text or null if no breach.
+ */
+export function checkBreachAlert(records) {
+  if (!records || records.length < 2) return null;
+
+  let count = 0;
+  let firstBreach = null;
+  let latestBreach = null;
+
+  for (let i = records.length - 1; i >= 0; i--) {
+    if (records[i].avg_de >= 3.5) {
+      count++;
+      if (!latestBreach) latestBreach = records[i];
+      firstBreach = records[i];
+    } else {
+      break;
+    }
+  }
+
+  if (count >= 2 && firstBreach && latestBreach) {
+    const tFirst = new Date(firstBreach.timestamp).getTime();
+    const tLatest = new Date(latestBreach.timestamp).getTime();
+    const diffHours = (tLatest - tFirst) / (1000 * 60 * 60);
+    const dFirst = firstBreach.timestamp.slice(0, 10);
+    const dLatest = latestBreach.timestamp.slice(0, 10);
+
+    if (dFirst !== dLatest || diffHours >= 1.0) {
+      const fmt = (ts) => {
+        try {
+          return new Date(ts).toLocaleDateString(undefined, { month: 'short', day: 'numeric', year: 'numeric' });
+        } catch (_) {
+          return ts;
+        }
+      };
+      return `⚠️ Re-profiling Recommended — ${count} consecutive verifications out of tolerance (first: ${fmt(firstBreach.timestamp)}, latest: ${fmt(latestBreach.timestamp)})`;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Loads verification history records and updates the Stage 5 drift analytics UI.
+ */
+export async function loadVerificationHistory(selectedPrinter = "") {
+  const profileName = profileBasename || wizardState.basename || "";
+  const driftSection = document.getElementById("driftHistorySection");
+  if (!driftSection) return;
+
+  const alertCard = document.getElementById("driftAlertCard");
+  const alertText = document.getElementById("driftAlertText");
+  const emptyState = document.getElementById("driftEmptyState");
+  const chartWrap = document.getElementById("driftChartWrap");
+  const chartSvg = document.getElementById("driftTrendChart");
+  const tbody = document.getElementById("verificationHistoryTbody");
+  const btnExport = document.getElementById("btnExportHistoryCsv");
+  const btnClear = document.getElementById("btnClearHistory");
+  const printerFilterSelect = document.getElementById("driftPrinterFilter");
+  const filterRow = document.getElementById("driftFilterRow");
+
+  try {
+    // 1. Fetch all records for current profile to populate printer options
+    const allProfileRecords = await invoke("get_verification_history", {
+      profileName: profileName || null,
+      printerName: null,
+    });
+
+    if (printerFilterSelect) {
+      const distinctPrinters = Array.from(new Set(allProfileRecords.map(r => r.printer_name).filter(Boolean)));
+      printerFilterSelect.innerHTML = `<option value="">All Printers</option>`;
+      distinctPrinters.forEach(p => {
+        const opt = document.createElement("option");
+        opt.value = p;
+        opt.textContent = p;
+        if (p === selectedPrinter) opt.selected = true;
+        printerFilterSelect.appendChild(opt);
+      });
+      if (filterRow) {
+        filterRow.classList.toggle("hidden", distinctPrinters.length <= 1);
+      }
+    }
+
+    // 2. Fetch filtered records
+    const records = await invoke("get_verification_history", {
+      profileName: profileName || null,
+      printerName: selectedPrinter || null,
+    });
+
+    // 3. Breach Alert check (evaluated against profile records chronologically)
+    const breachMessage = checkBreachAlert(records);
+    if (alertCard && alertText) {
+      if (breachMessage) {
+        alertText.textContent = breachMessage;
+        alertCard.classList.remove("hidden");
+      } else {
+        alertCard.classList.add("hidden");
+      }
+    }
+
+    const hasRecords = records.length > 0;
+    if (btnExport) btnExport.disabled = !hasRecords;
+    if (btnClear) btnClear.disabled = allProfileRecords.length === 0;
+
+    if (!hasRecords) {
+      if (emptyState) emptyState.classList.remove("hidden");
+      if (chartWrap) chartWrap.classList.add("hidden");
+      if (tbody) tbody.innerHTML = "";
+      return;
+    }
+
+    if (emptyState) emptyState.classList.add("hidden");
+    if (chartWrap) chartWrap.classList.remove("hidden");
+
+    // 4. Render Hand-rolled SVG Trend Chart
+    if (chartSvg) {
+      renderDriftTrendChart(chartSvg, records);
+    }
+
+    // 5. Render Run-Log Table (newest first)
+    if (tbody) {
+      tbody.innerHTML = "";
+      const reversed = [...records].reverse();
+      reversed.forEach(r => {
+        const tr = document.createElement("tr");
+
+        const tdDate = document.createElement("td");
+        try {
+          tdDate.textContent = new Date(r.timestamp).toLocaleString();
+        } catch (_) {
+          tdDate.textContent = r.timestamp;
+        }
+
+        const tdPrinter = document.createElement("td");
+        tdPrinter.textContent = r.printer_name || "Unknown";
+
+        const tdAvg = document.createElement("td");
+        tdAvg.textContent = r.avg_de.toFixed(2);
+
+        const tdMax = document.createElement("td");
+        tdMax.textContent = r.max_de.toFixed(2);
+
+        const tdRms = document.createElement("td");
+        tdRms.textContent = r.rms_de.toFixed(2);
+
+        const tdPatches = document.createElement("td");
+        tdPatches.textContent = r.patch_count || "-";
+
+        const tdStatus = document.createElement("td");
+        const badge = document.createElement("span");
+        const statusClass = r.status === 'excellent' ? 'badge-excellent' :
+                            r.status === 'good' ? 'badge-good' :
+                            r.status === 'acceptable' ? 'badge-acceptable' : 'badge-poor';
+        badge.className = `status-badge ${statusClass}`;
+        badge.textContent = r.status ? r.status.toUpperCase() : "UNKNOWN";
+        tdStatus.appendChild(badge);
+
+        tr.appendChild(tdDate);
+        tr.appendChild(tdPrinter);
+        tr.appendChild(tdAvg);
+        tr.appendChild(tdMax);
+        tr.appendChild(tdRms);
+        tr.appendChild(tdPatches);
+        tr.appendChild(tdStatus);
+
+        tbody.appendChild(tr);
+      });
+    }
+  } catch (e) {
+    logger.warn(`Failed to load verification history: ${e}`, 'Stage5-Profcheck');
+  }
+}
+
+/**
+ * Hand-rolled SVG line chart rendering verification drift trends with ICCery threshold bands.
+ */
+function renderDriftTrendChart(svg, records) {
+  // Downsample to the last 50 points if necessary
+  const data = records.length > 50 ? records.slice(records.length - 50) : records;
+
+  const width = 640;
+  const height = 220;
+  const padLeft = 45;
+  const padRight = 30;
+  const padTop = 20;
+  const padBottom = 28;
+
+  const plotW = width - padLeft - padRight;
+  const plotH = height - padTop - padBottom;
+
+  // Compute max Y (minimum 4.0 for all threshold bands)
+  let maxY = 4.0;
+  data.forEach(d => {
+    if (d.max_de > maxY) maxY = d.max_de;
+    if (d.avg_de > maxY) maxY = d.avg_de;
+  });
+  maxY = Math.ceil(maxY * 1.1);
+
+  const getY = (val) => padTop + plotH - (val / maxY) * plotH;
+  const getX = (idx) => {
+    if (data.length <= 1) return padLeft + plotW / 2;
+    return padLeft + (idx / (data.length - 1)) * plotW;
+  };
+
+  let elements = [];
+
+  // Threshold background bands
+  // Bands at: 0-1.0 (Excellent), 1.0-2.0 (Good), 2.0-3.5 (Acceptable), 3.5-maxY (Warning)
+  const bands = [
+    { from: 0.0, to: 1.0, color: "rgba(34, 197, 94, 0.08)", label: "Excellent (< 1.0)" },
+    { from: 1.0, to: 2.0, color: "rgba(59, 130, 246, 0.08)", label: "Good (< 2.0)" },
+    { from: 2.0, to: 3.5, color: "rgba(245, 158, 11, 0.08)", label: "Acceptable (< 3.5)" },
+    { from: 3.5, to: maxY, color: "rgba(239, 68, 68, 0.08)", label: "Warning (≥ 3.5)" },
+  ];
+
+  bands.forEach(b => {
+    const yTop = getY(Math.min(b.to, maxY));
+    const yBot = getY(b.from);
+    const bandH = Math.max(0, yBot - yTop);
+    elements.push(`<rect x="${padLeft}" y="${yTop}" width="${plotW}" height="${bandH}" fill="${b.color}" />`);
+  });
+
+  // Threshold lines
+  [1.0, 2.0, 3.5].forEach(thresh => {
+    if (thresh <= maxY) {
+      const y = getY(thresh);
+      elements.push(`<line x1="${padLeft}" y1="${y}" x2="${padLeft + plotW}" y2="${y}" stroke="rgba(255,255,255,0.15)" stroke-dasharray="3,3" />`);
+      elements.push(`<text x="${padLeft + plotW - 4}" y="${y - 3}" class="drift-band-label">${thresh.toFixed(1)} ΔE</text>`);
+    }
+  });
+
+  // Verification bands caption
+  elements.push(`<text x="${padLeft + 6}" y="${padTop + 12}" fill="rgba(255,255,255,0.35)" font-size="9px" font-family="sans-serif">ICCery verification bands</text>`);
+
+  // Y Axis ticks
+  const ySteps = [0, 1, 2, 3.5];
+  if (maxY > 5) ySteps.push(Math.floor(maxY));
+  ySteps.forEach(val => {
+    const y = getY(val);
+    elements.push(`<line x1="${padLeft - 4}" y1="${y}" x2="${padLeft}" y2="${y}" stroke="rgba(255,255,255,0.3)" />`);
+    elements.push(`<text x="${padLeft - 8}" y="${y + 3}" text-anchor="end" class="drift-chart-text">${val.toFixed(1)}</text>`);
+  });
+
+  // X Axis baseline
+  elements.push(`<line x1="${padLeft}" y1="${padTop + plotH}" x2="${padLeft + plotW}" y2="${padTop + plotH}" stroke="rgba(255,255,255,0.3)" />`);
+
+  // Series points & paths
+  if (data.length === 1) {
+    const x = getX(0);
+    const yAvg = getY(data[0].avg_de);
+    const yMax = getY(data[0].max_de);
+
+    // Dashed horizontal line across plot for single point
+    elements.push(`<line x1="${padLeft}" y1="${yAvg}" x2="${padLeft + plotW}" y2="${yAvg}" stroke="#3b82f6" stroke-dasharray="4,4" stroke-opacity="0.5" />`);
+    elements.push(`<circle cx="${x}" cy="${yAvg}" r="5" class="drift-dot-avg"><title>Avg ΔE: ${data[0].avg_de.toFixed(2)} (${data[0].timestamp})</title></circle>`);
+    elements.push(`<circle cx="${x}" cy="${yMax}" r="4" class="drift-dot-max"><title>Peak ΔE: ${data[0].max_de.toFixed(2)}</title></circle>`);
+  } else {
+    // Polylines
+    let ptsAvg = [];
+    let ptsMax = [];
+    data.forEach((d, idx) => {
+      const x = getX(idx);
+      const yA = getY(d.avg_de);
+      const yM = getY(d.max_de);
+      ptsAvg.push(`${x.toFixed(1)},${yA.toFixed(1)}`);
+      ptsMax.push(`${x.toFixed(1)},${yM.toFixed(1)}`);
+    });
+
+    elements.push(`<polyline points="${ptsMax.join(' ')}" class="drift-line-max" />`);
+    elements.push(`<polyline points="${ptsAvg.join(' ')}" class="drift-line-avg" />`);
+
+    // Draw dots
+    data.forEach((d, idx) => {
+      const x = getX(idx);
+      const yA = getY(d.avg_de);
+      const yM = getY(d.max_de);
+      const dateStr = d.timestamp.slice(0, 10);
+      elements.push(`<circle cx="${x.toFixed(1)}" cy="${yA.toFixed(1)}" r="4" class="drift-dot-avg"><title>Avg: ${d.avg_de.toFixed(2)} (${dateStr})</title></circle>`);
+      elements.push(`<circle cx="${x.toFixed(1)}" cy="${yM.toFixed(1)}" r="3" class="drift-dot-max"><title>Peak: ${d.max_de.toFixed(2)} (${dateStr})</title></circle>`);
+    });
+
+    // Start and End date labels on X axis
+    const startStr = data[0].timestamp.slice(5, 10);
+    const endStr = data[data.length - 1].timestamp.slice(5, 10);
+    elements.push(`<text x="${padLeft}" y="${height - 8}" text-anchor="start" class="drift-chart-text">${startStr}</text>`);
+    elements.push(`<text x="${padLeft + plotW}" y="${height - 8}" text-anchor="end" class="drift-chart-text">${endStr}</text>`);
+  }
+
+  svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg.innerHTML = elements.join("\n");
 }
 
 export function initProfcheck() {
@@ -25,9 +442,68 @@ export function initProfcheck() {
   const maxDeEl = document.getElementById("profcheckMaxDe");
   const rmsDeEl = document.getElementById("profcheckRmsDe");
   const badgeEl = document.getElementById("profcheckBadge");
+  const btnExport = document.getElementById("btnExportHistoryCsv");
+  const btnClear = document.getElementById("btnClearHistory");
+  const printerFilterSelect = document.getElementById("driftPrinterFilter");
 
   if (!btnVerify) return;
 
+  // Listen for printer filter changes in drift history
+  if (printerFilterSelect) {
+    printerFilterSelect.addEventListener("change", () => {
+      loadVerificationHistory(printerFilterSelect.value);
+    });
+  }
+
+  // Export CSV button handler
+  if (btnExport) {
+    btnExport.addEventListener("click", async () => {
+      try {
+        const profileName = profileBasename || wizardState.basename || "verification";
+        const defaultName = `${profileName}_history.csv`;
+        const chosenPath = await invoke("select_csv_save_path", { defaultName });
+        if (chosenPath) {
+          const printerFilter = printerFilterSelect ? printerFilterSelect.value : "";
+          const count = await invoke("export_verification_history_csv", {
+            destPath: chosenPath,
+            profileName: profileName || null,
+            printerName: printerFilter || null,
+          });
+          wizardState.showNotice(`✓ Exported ${count} verification records to ${chosenPath}`, "success");
+        }
+      } catch (err) {
+        logger.error(`CSV Export failed: ${err}`, 'Stage5-Profcheck');
+        wizardState.showNotice(`Failed to export CSV: ${err}`, "error");
+      }
+    });
+  }
+
+  // Clear History button handler
+  if (btnClear) {
+    btnClear.addEventListener("click", async () => {
+      if (confirm("Are you sure you want to clear all verification history records? This cannot be undone.")) {
+        try {
+          await invoke("clear_verification_history");
+          await loadVerificationHistory();
+          wizardState.showNotice("Verification history cleared.", "info");
+        } catch (err) {
+          logger.error(`Clear history failed: ${err}`, 'Stage5-Profcheck');
+          wizardState.showNotice(`Failed to clear history: ${err}`, "error");
+        }
+      }
+    });
+  }
+
+  // Listen for Stage 5 navigation to load history
+  window.addEventListener("stage-changed", (event) => {
+    if (event.detail && event.detail.stage === 5) {
+      loadVerificationHistory();
+    }
+  });
+
+  // Initial load
+  loadVerificationHistory();
+
   btnVerify.addEventListener("click", async () => {
     const basename = profileBasename || wizardState.basename;
     const cwd = profileCwd || wizardState.cwd;
@@ -94,7 +570,55 @@ export function initProfcheck() {
 
           if (event.payload.code === 0) {
             logPre.textContent += "\n[SUCCESS] profcheck verification finished.\n";
-            parseAndRenderReport(stdoutAccumulator);
+            const report = parseProfcheckReport(stdoutAccumulator);
+
+            reportCard.classList.remove("hidden");
+            if (report.warnings.length > 0) {
+              logPre.textContent += `\n[WARN] ${report.warnings.join(' ')}\n`;
+            }
+
+            avgDeEl.textContent = report.avgDe.toFixed(2);
+            maxDeEl.textContent = report.maxDe.toFixed(2);
+            rmsDeEl.textContent = report.rmsDe.toFixed(2);
+
+            // Quality verdict
+            badgeEl.className = "report-badge";
+            if (report.avgDe < 1.0) {
+              badgeEl.textContent = "EXCELLENT";
+              badgeEl.classList.add("badge-excellent");
+            } else if (report.avgDe < 2.0) {
+              badgeEl.textContent = "GOOD";
+              badgeEl.classList.add("badge-good");
+            } else if (report.avgDe < 3.5) {
+              badgeEl.textContent = "ACCEPTABLE";
+              badgeEl.classList.add("badge-acceptable");
+            } else {
+              badgeEl.textContent = "POOR";
+              badgeEl.classList.add("badge-poor");
+            }
+
+            // Auto-save record to verification history
+            const record = {
+              id: "",
+              timestamp: new Date().toISOString(),
+              printer_name: wizardState.printerName || "Unknown",
+              profile_name: profileBasename || wizardState.basename || "Unknown",
+              avg_de: report.avgDe,
+              max_de: report.maxDe,
+              rms_de: report.rmsDe,
+              patch_count: report.patchCount,
+              status: "",
+            };
+
+            try {
+              await invoke("save_verification_record", { record });
+            } catch (saveErr) {
+              logger.warn(`Could not auto-save verification record: ${saveErr}`, 'Stage5-Profcheck');
+              logPre.textContent += `\n[WARN] Could not auto-save verification record: ${saveErr}\n`;
+            }
+
+            // Refresh verification history display
+            await loadVerificationHistory();
 
             // Ensure gamut mesh is loaded into 3D viewer
             const gamFilePath = cwd ? `${cwd}${sep}${basename}.gam` : `${basename}.gam`;
@@ -119,110 +643,4 @@ export function initProfcheck() {
       btnVerify.disabled = false;
     }
   });
-
-  /**
-   * Parse profcheck output for Average, Peak, and RMS delta-E values.
-   * Supports both Argyll's JSON-style summary and plain-text legacy output.
-   * @param {string} stdout - Full profcheck stdout.
-   */
-  function parseAndRenderReport(stdout) {
-    reportCard.classList.remove("hidden");
-
-    let avgDe = 0.0;
-    let maxDe = 0.0;
-    let rmsDe = 0.0;
-    let parserWarnings = [];
-
-    // Argyll's JSON output can appear either as a compact object on a single
-    // line or embedded inside larger text. Try to find and parse the LAST valid
-    // JSON object in the output, which is most likely the summary.
-    const jsonObjects = [];
-    const re = /\{[\s\S]*?\}/g;
-    let m;
-    while ((m = re.exec(stdout)) !== null) {
-      try {
-        const parsed = JSON.parse(m[0]);
-        if (typeof parsed === 'object' && parsed !== null && ('avg_de' in parsed || 'peak_de' in parsed || 'rms_de' in parsed)) {
-          jsonObjects.push(parsed);
-        }
-      } catch (e) {
-        // Not a valid JSON object, ignore.
-      }
-    }
-
-    if (jsonObjects.length > 0) {
-      const json = jsonObjects[jsonObjects.length - 1];
-      avgDe = typeof json.avg_de === 'number' ? json.avg_de : 0;
-      maxDe = typeof json.max_de === 'number' ? json.max_de : (typeof json.peak_de === 'number' ? json.peak_de : 0);
-      rmsDe = typeof json.rms_de === 'number' ? json.rms_de : 0;
-    } else {
-      // Regex fallbacks for standard profcheck text output
-      const avgPatterns = [
-        /avg(?:\.?|erage)\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
-        /average\s+(?:dE\s*)?([\d\.]+)/i,
-        /mean\s+(?:dE\s*)?([\d\.]+)/i,
-        /dE\s+average[^\d]*([\d\.]+)/i,
-      ];
-      const maxPatterns = [
-        /max(?:\.?|imum)\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
-        /peak\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
-        /worst\s*(?:dE\s*)?([\d\.]+)/i,
-        /dE\s+max[^\d]*([\d\.]+)/i,
-      ];
-      const rmsPatterns = [
-        /RMS\s*(?:dE\s*)?[:=]\s*([\d\.]+)/i,
-        /rms\s*(?:dE\s*)?([\d\.]+)/i,
-        /root\s+mean\s+sq(?:uare)?\s*(?:dE\s*)?([\d\.]+)/i,
-      ];
-
-      const find = (patterns) => {
-        for (const p of patterns) {
-          const match = stdout.match(p);
-          if (match) return match;
-        }
-        return null;
-      };
-
-      const avgMatch = find(avgPatterns);
-      const maxMatch = find(maxPatterns);
-      const rmsMatch = find(rmsPatterns);
-
-      if (avgMatch) avgDe = parseFloat(avgMatch[1]);
-      else parserWarnings.push('Could not detect Average ΔE in profcheck output.');
-
-      if (maxMatch) maxDe = parseFloat(maxMatch[1]);
-      else parserWarnings.push('Could not detect Peak ΔE in profcheck output.');
-
-      if (rmsMatch) rmsDe = parseFloat(rmsMatch[1]);
-      else parserWarnings.push('Could not detect RMS ΔE in profcheck output.');
-
-      if (!avgMatch && !maxMatch && !rmsMatch) {
-        parserWarnings.push('No delta-E values were found in profcheck output.');
-      }
-    }
-
-    if (parserWarnings.length > 0) {
-      logPre.textContent += `\n[WARN] ${parserWarnings.join(' ')}\n`;
-    }
-
-    avgDeEl.textContent = avgDe.toFixed(2);
-    maxDeEl.textContent = maxDe.toFixed(2);
-    rmsDeEl.textContent = rmsDe.toFixed(2);
-
-    // Quality verdict
-    badgeEl.className = "report-badge";
-    if (avgDe < 1.0) {
-      badgeEl.textContent = "EXCELLENT";
-      badgeEl.classList.add("badge-excellent");
-    } else if (avgDe < 2.0) {
-      badgeEl.textContent = "GOOD";
-      badgeEl.classList.add("badge-good");
-    } else if (avgDe < 4.0) {
-      badgeEl.textContent = "ACCEPTABLE";
-      badgeEl.classList.add("badge-acceptable");
-    } else {
-      badgeEl.textContent = "POOR";
-      badgeEl.classList.add("badge-poor");
-    }
-  }
 }

src/js/profcheck.test.js

@@ -0,0 +1,136 @@
+// Unit & console tests for profcheck.js parsing and breach alert logic.
+// Can be run in browser devtools console:
+//   import('./profcheck.test.js').then(m => m.runAll())
+// Or in Node:
+//   node src/js/profcheck.test.js
+
+// Node environment polyfill for browser globals
+if (typeof window === 'undefined') {
+  globalThis.window = {
+    __TAURI__: {
+      core: { invoke: () => Promise.resolve() },
+      event: { listen: () => Promise.resolve(() => {}) }
+    },
+    addEventListener: () => {},
+    dispatchEvent: () => {}
+  };
+  globalThis.document = {
+    getElementById: () => null,
+    querySelectorAll: () => []
+  };
+}
+
+const { parseProfcheckReport, checkBreachAlert } = await import('./profcheck.js');
+
+export function runAll() {
+  console.group('Profcheck Report Parser & Drift Tests');
+  let passed = 0;
+  let total = 0;
+
+  function assert(actual, expected, message) {
+    total++;
+    const ok = JSON.stringify(actual) === JSON.stringify(expected);
+    if (ok) {
+      console.log('PASS:', message);
+      passed++;
+    } else {
+      console.error('FAIL:', message, '\nExpected:', expected, '\nGot:', actual);
+    }
+    return ok;
+  }
+
+  // 1. Real Argyll -u JSON payload
+  const realUOutput = `
+profcheck: Checking profile accuracy...
+No of test patches = 52
+{"event": "report", "peak_de2000": 2.41, "avg_de2000": 0.85, "rms": 1.02}
+Profile check complete, errors(CIEDE2000): max. = 2.41, avg. = 0.85, RMS = 1.02
+`;
+  const res1 = parseProfcheckReport(realUOutput);
+  assert(res1.avgDe, 0.85, 'real -u JSON avgDe');
+  assert(res1.maxDe, 2.41, 'real -u JSON maxDe');
+  assert(res1.rmsDe, 1.02, 'real -u JSON rmsDe');
+  assert(res1.patchCount, 52, 'real -u patchCount');
+  assert(res1.warnings.length, 0, 'real -u no warnings');
+
+  // 2. Preference for *de2000 object when multiple JSON objects appear
+  const multiJsonOutput = `
+{"event": "report", "peak_de": 3.10, "avg_de": 1.20, "rms": 1.50}
+{"event": "report", "peak_de2000": 2.15, "avg_de2000": 0.72, "rms": 0.95}
+`;
+  const res2 = parseProfcheckReport(multiJsonOutput);
+  assert(res2.avgDe, 0.72, 'prefers *de2000 avg');
+  assert(res2.maxDe, 2.15, 'prefers *de2000 peak');
+  assert(res2.rmsDe, 0.95, 'prefers *de2000 rms');
+
+  // 3. Standard text summary line without JSON
+  const textSummaryOutput = `
+Header information...
+No of test patches = 120
+Profile check complete, errors(CIEDE2000): max. = 1.95, avg. = 0.65, RMS = 0.88
+Done.
+`;
+  const res3 = parseProfcheckReport(textSummaryOutput);
+  assert(res3.avgDe, 0.65, 'text summary line avgDe');
+  assert(res3.maxDe, 1.95, 'text summary line maxDe');
+  assert(res3.rmsDe, 0.88, 'text summary line rmsDe');
+  assert(res3.patchCount, 120, 'text summary patchCount');
+
+  // 4. Legacy regex fallbacks
+  const legacyOutput = `
+Summary:
+  avg. dE = 1.15
+  max. dE = 3.42
+  rms. dE = 1.65
+`;
+  const res4 = parseProfcheckReport(legacyOutput);
+  assert(res4.avgDe, 1.15, 'legacy text avgDe');
+  assert(res4.maxDe, 3.42, 'legacy text maxDe');
+  assert(res4.rmsDe, 1.65, 'legacy text rmsDe');
+
+  // 5. checkBreachAlert tests
+  assert(checkBreachAlert([]), null, 'empty records returns null');
+  assert(checkBreachAlert([{ avg_de: 4.0, timestamp: '2026-09-01T10:00:00Z' }]), null, 'single record returns null');
+
+  // Two records in same minute >= 3.5 -> no alert
+  const sameTimeRecords = [
+    { avg_de: 3.8, timestamp: '2026-09-05T12:00:10Z' },
+    { avg_de: 3.9, timestamp: '2026-09-05T12:00:45Z' },
+  ];
+  assert(checkBreachAlert(sameTimeRecords), null, 'two records in same minute do not fire alert');
+
+  // Two records on distinct calendar dates >= 3.5 -> alert fires
+  const distinctDateRecords = [
+    { avg_de: 1.0, timestamp: '2026-08-15T10:00:00Z' },
+    { avg_de: 3.6, timestamp: '2026-09-01T10:00:00Z' },
+    { avg_de: 3.8, timestamp: '2026-09-05T10:00:00Z' },
+  ];
+  const alert = checkBreachAlert(distinctDateRecords);
+  assert(typeof alert === 'string' && alert.includes('Re-profiling Recommended') && alert.includes('2 consecutive'), true, 'distinct dates breach alert fires');
+
+  // Two records >= 1 hour apart on same day -> alert fires
+  const hourApartRecords = [
+    { avg_de: 3.7, timestamp: '2026-09-05T10:00:00Z' },
+    { avg_de: 3.9, timestamp: '2026-09-05T12:30:00Z' },
+  ];
+  const alert2 = checkBreachAlert(hourApartRecords);
+  assert(typeof alert2 === 'string' && alert2.includes('Re-profiling Recommended'), true, 'records >=1 hr apart breach alert fires');
+
+  // Trailing record is good -> no alert
+  const recoveredRecords = [
+    { avg_de: 3.7, timestamp: '2026-09-01T10:00:00Z' },
+    { avg_de: 3.9, timestamp: '2026-09-02T10:00:00Z' },
+    { avg_de: 0.9, timestamp: '2026-09-03T10:00:00Z' },
+  ];
+  assert(checkBreachAlert(recoveredRecords), null, 'recovered profile returns null');
+
+  console.log(`Profcheck tests complete: ${passed}/${total} passed`);
+  console.groupEnd();
+  return passed === total;
+}
+
+// Auto-run if executed directly in Node
+if (typeof process !== 'undefined' && process.argv && process.argv[1] && process.argv[1].endsWith('profcheck.test.js')) {
+  const ok = runAll();
+  if (!ok) process.exit(1);
+}

src/js/settings.js

@@ -21,6 +21,7 @@ export async function initSettings() {
     const deltaEGoodMax = document.getElementById('deltaEGoodMax');
     const deltaEWarningMax = document.getElementById('deltaEWarningMax');
     const deltaEThresholdError = document.getElementById('deltaEThresholdError');
+    const enableI1Pro2Leds = document.getElementById('enable_i1pro2_leds');
 
     if (!dialog || !openBtn) return;
 
@@ -57,6 +58,9 @@ export async function initSettings() {
             const settings = await invoke('load_settings');
             document.getElementById('argyll_binary_dir').value = settings.argyll_binary_dir || '';
             document.getElementById('default_instrument').value = settings.default_instrument || '';
+            if (enableI1Pro2Leds) {
+                enableI1Pro2Leds.checked = Boolean(settings.enable_i1pro2_leds);
+            }
             if (logLevelSelect && settings.log_level) {
                 logLevelSelect.value = settings.log_level;
             }
@@ -145,6 +149,7 @@ export async function initSettings() {
                     log_level: logLevelSelect ? logLevelSelect.value : (currentSettings.log_level || 'info'),
                     delta_e_good_max: getInputValueAsFloat('deltaEGoodMax', 2.0),
                     delta_e_warning_max: getInputValueAsFloat('deltaEWarningMax', 5.0),
+                    enable_i1pro2_leds: enableI1Pro2Leds ? enableI1Pro2Leds.checked : false,
                 };
                 await invoke('save_settings', { settings });
                 logger.info(`Settings saved. Log level set to: ${settings.log_level}`, 'Settings');

src/js/state.js

@@ -4,6 +4,7 @@ export const wizardState = {
   currentStage: 1,
   basename: "",
   cwd: "",
+  printerName: "",
   noticeTimer: null,
   
   setTarget(basename, cwd) {
@@ -75,6 +76,8 @@ export const wizardState = {
         s.classList.add('hidden');
       }
     });
+
+    window.dispatchEvent(new CustomEvent('stage-changed', { detail: { stage: stageNumber } }));
   },
 
   async navigateToStage(stageNumber) {

src/styles/main.css

@@ -1158,7 +1158,7 @@ button.danger:hover {
   border: 1px solid rgba(76, 175, 80, 0.3);
 }
 
-.badge-printing {
+.badge-printing, .badge-primary {
   background: rgba(33, 150, 243, 0.15);
   color: #64b5f6;
   border: 1px solid rgba(33, 150, 243, 0.3);
@@ -1671,5 +1671,236 @@ button.danger:hover {
   opacity: 0.55;
 }
 
+/* ═══════════════════════════════════════════════════════════════════════════
+   Longitudinal Printer Drift Tracking & Verification History — Stage 5
+   ═══════════════════════════════════════════════════════════════════════════ */
 
+.drift-history {
+  margin-top: 16px;
+  margin-bottom: 20px;
+}
 
+.drift-filter-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 12px;
+  font-size: 0.85rem;
+}
+
+.drift-filter-row select {
+  max-width: 240px;
+  padding: 4px 8px;
+  height: 30px;
+  font-size: 0.85rem;
+}
+
+.drift-chart-wrap {
+  width: 100%;
+  height: 240px;
+  background: rgba(0, 0, 0, 0.3);
+  border: 1px solid var(--border-color, #333);
+  border-radius: 6px;
+  margin-bottom: 14px;
+  overflow: hidden;
+  position: relative;
+}
+
+#driftTrendChart {
+  width: 100%;
+  height: 100%;
+  display: block;
+}
+
+.drift-chart-grid line {
+  stroke: rgba(255, 255, 255, 0.08);
+  stroke-width: 1;
+}
+
+.drift-chart-axis line,
+.drift-chart-axis path {
+  stroke: rgba(255, 255, 255, 0.2);
+  stroke-width: 1;
+}
+
+.drift-chart-text {
+  fill: #888;
+  font-size: 10px;
+  font-family: monospace;
+}
+
+.drift-band-label {
+  fill: rgba(255, 255, 255, 0.45);
+  font-size: 9px;
+  text-anchor: end;
+}
+
+.drift-line-avg {
+  fill: none;
+  stroke: #3b82f6;
+  stroke-width: 2.5;
+  stroke-linejoin: round;
+  stroke-linecap: round;
+}
+
+.drift-line-max {
+  fill: none;
+  stroke: #f59e0b;
+  stroke-width: 1.5;
+  stroke-dasharray: 4, 3;
+  stroke-linejoin: round;
+  stroke-linecap: round;
+}
+
+.drift-dot-avg {
+  fill: #3b82f6;
+  stroke: #1e293b;
+  stroke-width: 2;
+  cursor: pointer;
+  transition: r 0.15s ease, fill 0.15s ease;
+}
+
+.drift-dot-avg:hover {
+  r: 6;
+  fill: #60a5fa;
+}
+
+.drift-dot-max {
+  fill: #f59e0b;
+  stroke: #1e293b;
+  stroke-width: 1.5;
+  cursor: pointer;
+  transition: r 0.15s ease, fill 0.15s ease;
+}
+
+.drift-dot-max:hover {
+  r: 5;
+  fill: #fbbf24;
+}
+
+.drift-table-wrap {
+  max-height: 220px;
+  overflow-y: auto;
+  border: 1px solid var(--border-color, #333);
+  border-radius: 6px;
+  margin-bottom: 14px;
+}
+
+.drift-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.85rem;
+  text-align: left;
+}
+
+.drift-table th {
+  position: sticky;
+  top: 0;
+  background: var(--bg-surface, #1e1e1e);
+  color: var(--text-muted, #aaa);
+  font-weight: 600;
+  padding: 8px 10px;
+  border-bottom: 1px solid var(--border-color, #333);
+  z-index: 1;
+}
+
+.drift-table td {
+  padding: 7px 10px;
+  border-bottom: 1px solid rgba(255, 255, 255, 0.05);
+}
+
+.drift-table tbody tr:hover {
+  background: rgba(255, 255, 255, 0.03);
+}
+
+.drift-table tbody tr:last-child td {
+  border-bottom: none;
+}
+
+/* ═══════════════════════════════════════════════════════════════════════════
+   XY Automated Scanning Table Sequence — Stage 3
+   ═══════════════════════════════════════════════════════════════════════════ */
+
+.xy-table-panel {
+  background: rgba(0, 0, 0, 0.25);
+  border: 1px solid var(--border-color, #333);
+  border-radius: 6px;
+  padding: 12px 14px;
+  margin-bottom: 16px;
+}
+
+.xy-table-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 10px;
+}
+
+.xy-table-header h4 {
+  margin: 0;
+  font-size: 0.95rem;
+  font-weight: 600;
+  color: var(--text-color, #eee);
+}
+
+.xy-steps-list {
+  list-style: none;
+  counter-reset: xy-step-counter;
+  padding: 0;
+  margin: 0;
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+  gap: 8px;
+}
+
+.xy-step {
+  counter-increment: xy-step-counter;
+  background: rgba(255, 255, 255, 0.03);
+  border: 1px solid rgba(255, 255, 255, 0.08);
+  border-radius: 4px;
+  padding: 8px 10px;
+  font-size: 0.8rem;
+  color: var(--text-muted, #888);
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  transition: all 0.2s ease;
+}
+
+.xy-step::before {
+  content: counter(xy-step-counter);
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 18px;
+  height: 18px;
+  border-radius: 50%;
+  background: rgba(255, 255, 255, 0.1);
+  color: #ccc;
+  font-size: 0.7rem;
+  font-weight: 600;
+  flex-shrink: 0;
+}
+
+.xy-step.active {
+  background: rgba(59, 130, 246, 0.15);
+  border-color: rgba(59, 130, 246, 0.5);
+  color: #93c5fd;
+  font-weight: 500;
+}
+
+.xy-step.active::before {
+  background: var(--accent-color, #3b82f6);
+  color: #fff;
+}
+
+.xy-step.completed {
+  color: #86efac;
+  border-color: rgba(34, 197, 94, 0.3);
+}
+
+.xy-step.completed::before {
+  content: "✓";
+  background: rgba(34, 197, 94, 0.2);
+  color: #86efac;
+}