@jax-data-science/sci-image-visualizer 0.8.3 → 0.10.0

package/esm2022/lib/implementations/plotly/plotly.service.mjs

@@ -1,75 +1,66 @@
 import { Injectable, Inject, Optional } from '@angular/core';
 import * as Plotly from 'plotly.js-dist-min';
-import { Image } from 'image-js';
 import { HttpClient } from '@angular/common/http';
-import { firstValueFrom } from 'rxjs';
-import { Polygon, Rectangle, Region } from '../../models/region';
-import { Buffer } from 'buffer';
 import { TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';
 import { IMAGE_STATE_PORT } from '../../contracts/ports/image-state.port';
-import { BehaviorSubject, EMPTY, Subject, combineLatest, of } from 'rxjs';
+import { BehaviorSubject, Subject, combineLatest, of } from 'rxjs';
 import { MessageService } from 'primeng/api';
-import { ShapeSelection } from '../../models/shape';
-import { CONFIG, CONFIG_SURFACE, PlotUtilities } from '../../plot.utilities';
+import { CONFIG, CONFIG_SURFACE } from '../../plot.utilities';
 import { WandService } from '../../toolbar/wand/wand.service';
-import { WandToolService } from '../../toolbar/wand/wand-tool.service';
-import { BrushToolService } from '../../toolbar/brush/brush-tool.service';
+import { createCanvasToolManager } from '../../toolbar/canvas-tools';
 import { SamToolService } from '../../toolbar/segmentation/sam-tool.service';
 import { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';
 import { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';
 import { CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';
-import { VertexEraserToolService } from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';
-import { ZoomToBoxToolService } from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';
 import { PlotType, PLOT_TYPE_DESCRIPTORS } from '../../contracts/plot-type';
-import { PLOTLY_PLOT_TYPE_IMPLS, } from './plotly-trace-builders';
-import { bt601Luminance, histogram256 } from '../../contracts/intensity';
+import { PLOTLY_PLOT_TYPE_IMPLS, buildHeatmapTraces, buildRgbImageTraces, buildSurfaceTraces, } from './plotly-trace-builders';
+import { chartLayout, heatmapLayout, overlayLayout, surfaceLayout, volumeLayout, } from './plotly-layouts';
 import { ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.contract';
 import { PlotlyRegionOverlay } from './plotly-region-overlay';
+import { PlotlyIsosurfaceControls } from './plotly-isosurface-controls';
+import { PlotlyShapeProjection } from './plotly-shape-projection';
+import { PlotlyZoomController } from './plotly-zoom-controller';
+import { PlotlyImageLoader } from './plotly-image-loader';
+import { axesSourceRect, channelDisplayRestyle, frameHistogram, planeHistogram, tracePixels, } from './plotly-readback';
+import { PlotlyImageRecolor, recolorKind } from './plotly-image-recolor';
+import { renderIntensityInset as renderPlotlyIntensityInset } from './plotly-intensity-inset';
+import { IntensityProfileService } from '../../intensity/intensity-profile.service';
 import { PlotlyCoordinateTransform } from './plotly-coordinate-transform';
 import { VisualizerStore } from '../../store/visualizer-store.service';
 import { RegionStore } from '../../store/region-store.service';
-import { VIZ_ALERT_TOAST_KEY } from '../../toast-outlets';
+import { BaseStoreVisualizer } from '../base-store-visualizer';
+import { throwIfAborted } from '../tile-server/transport';
 import * as i0 from "@angular/core";
 import * as i1 from "primeng/api";
 import * as i2 from "@angular/common/http";
 import * as i3 from "../../toolbar/wand/wand.service";
-import * as i4 from "../../toolbar/wand/wand-tool.service";
-import * as i5 from "../../toolbar/brush/brush-tool.service";
-import * as i6 from "../../toolbar/segmentation/sam-tool.service";
-import * as i7 from "../../toolbar/segmentation/sam-point-tool.service";
-import * as i8 from "../../toolbar/segmentation/cell-segment-tool.service";
-import * as i9 from "../../toolbar/vertex-eraser/vertex-eraser-tool.service";
-import * as i10 from "../../toolbar/zoom-to-box/zoom-to-box-tool.service";
-import * as i11 from "../../store/visualizer-store.service";
-import * as i12 from "../../store/region-store.service";
+import * as i4 from "../../toolbar/segmentation/sam-tool.service";
+import * as i5 from "../../toolbar/segmentation/sam-point-tool.service";
+import * as i6 from "../../toolbar/segmentation/cell-segment-tool.service";
+import * as i7 from "../../store/visualizer-store.service";
+import * as i8 from "../../store/region-store.service";
+import * as i9 from "../../intensity/intensity-profile.service";
 // Re-exported so existing consumers can keep importing PlotType from this
 // module while it physically lives in the backend-neutral contracts/ dir.
 // TODO(plotting-abstraction): once all consumers import from
 // './contracts/plot-type' directly, drop this re-export.
 export { PlotType } from '../../contracts/plot-type';
-window.Buffer = Buffer;
-export class PlotlyService {
-    constructor(tiles, state, messageService, http, wandService, wandTool, brushTool, samTool, samPointTool, cellSegmentTool, cellSegmenter, vertexEraserTool, zoomToBoxTool, store, regionStore) {
+export class PlotlyService extends BaseStoreVisualizer {
+    constructor(tiles, state, messageService, http, wandService, samTool, samPointTool, cellSegmentTool, cellSegmenter, store, regionStore, intensity) {
+        super(regionStore, store);
         this.tiles = tiles;
         this.state = state;
         this.messageService = messageService;
-        this.http = http;
-        this.wandService = wandService;
-        this.wandTool = wandTool;
-        this.brushTool = brushTool;
         this.samTool = samTool;
         this.samPointTool = samPointTool;
         this.cellSegmentTool = cellSegmentTool;
         this.cellSegmenter = cellSegmenter;
-        this.vertexEraserTool = vertexEraserTool;
-        this.zoomToBoxTool = zoomToBoxTool;
-        this.store = store;
-        this.regionStore = regionStore;
+        this.intensity = intensity;
         /**
          * Plotly is the full-featured data backend: it supports every feature,
          * including 3D scenes, live scalar colormaps, pixel readback and the
-         * server-side high-def zoom re-fetch. (OpenSeadragon's stub advertises only
-         * image display.)
+         * server-side high-def zoom re-fetch. (OpenSeadragon, the tiled image
+         * backend, advertises only image display.)
          */
         this.capabilities = capabilitiesOf([
             ViewerFeature.ImageDisplay,
@@ -80,73 +71,77 @@ export class PlotlyService {
             ViewerFeature.StackSlider,
             ViewerFeature.Isosurface,
         ]);
-        this.shapes = [];
-        this.previousShapes = [];
-        this.isRegionSavedOn = true;
-        this.isRealZoom = true;
+        /** Plotly's render projection of the shared RegionStore (the shape dicts) and
+         *  the selection ↔ active-shape mapping (see PlotlyShapeProjection). */
+        this.shapeProjection = new PlotlyShapeProjection({ plotDiv: () => this.plotDiv, fileName: () => this.fileName }, this.regionStore);
         this.scaleratio = true;
-        this.zoomCoordinates = [];
-        this.plotUtilities = new PlotUtilities();
         this.onPlotMouseDown = null;
         this.cachedImageWidth = 0;
         this.cachedImageHeight = 0;
         this.cachedImageRatios = [1, 1];
         this.cachedIsGrayscale = false;
+        /** The channel display of a colour image's `image` traces (see PlotlyImageRecolor). */
+        this.recolor = new PlotlyImageRecolor({
+            channelStates: () => this.store.currentChannelStates(),
+            invert: () => this.store.currentInvert(),
+        });
+        /** The pending per-frame recolour (requestAnimationFrame handle), if any. */
+        this.recolorFrame = null;
+        /** A recoloured slice is being encoded; `recolorAgain`: an edit came in meanwhile. */
+        this.recoloring = false;
+        this.recolorAgain = false;
         /** Data-space coordinate of the cached frame's pixel (0,0). [0,0] for the full
-         *  image; a crop's top-left when zoomed (so the intensity profile samples the
+         *  image; a crop's top-left after a high-def zoom (so the tools sample the
          *  zoom-level pixels at the right offset/resolution). */
         this.cachedFrameOrigin = [0, 0];
-        /** Last visible image-pixel rectangle from the active backend's viewport (set by
-         *  the OSD viewport-change hook via refreshIntensitySamplingForRoi). New profile lines are
-         *  placed within it so they land on-screen when zoomed in; null → use full image. */
-        this.lastVisibleRoi = null;
-        this.stackLoading$ = new BehaviorSubject(false);
-        this.stackLoadingProgress$ = new BehaviorSubject(0);
+        /** Bumped by every render of the plot div (plot, a high-def zoom re-render,
+         *  purge, reset). A high-def zoom drops its crop if another render (or the
+         *  hand-over of the div to another backend) happened while it was fetching. */
+        this.renderGen = 0;
         // current index of image in stack (if stack), 0 if single image
         this.zIndex = new BehaviorSubject(0);
         this.autoscaleEvent = new Subject();
-        // The region update event and selection stream are owned by the shared
-        // RegionStore; getRegionUpdateEvent()/getSelectedShapeIndices$() delegate to
-        // it so every consumer (and the OSD backend) sees one stream.
-        /** Bright, well-separated colours cycled as the user adds profile-line ROIs.
-         *  The matching inset trace is drawn in the same colour. */
-        this.PROFILE_PALETTE = [
-            '#FFD400', // yellow
-            '#00E5FF', // cyan
-            '#FF2D95', // magenta
-            '#39FF14', // green
-            '#FF9500', // orange
-            '#7C4DFF', // violet
-            '#FF3B30', // red
-            '#18FFFF', // aqua
-        ];
-        /** Palette cursor for profile lines (never reset on delete, so colours keep
-         *  cycling across the session). */
-        this.profileColorSeq = 0;
-        this.intensityProfile$ = new Subject();
-        /** ISOSURFACE band as a 0–255 slider position, mapped onto the volume's real
-         *  intensity range at render time (see mapIsoBand). Defaults to the full range
-         *  so the first render shows the whole structure regardless of how bright or
-         *  dark the volume is; the user then narrows the band to isolate intensities. */
-        this.isoMin = 0;
-        this.isoMax = 255;
-        /** Actual intensity range of the volume on screen ([min,max] over the loaded
-         *  frames). The slider spans 0–255, but a given stack often occupies only a
-         *  sub-range, so we clamp the iso band into this range (with a small margin)
-         *  to guarantee non-degenerate surfaces — both on first render and on live
-         *  slider moves. Null until an isosurface volume has been measured. */
-        this.isoDataRange = null;
-        // Id minting and the selection index stream are owned by the shared
-        // RegionStore. Selection still drives Plotly's `_activeShapeIndex` (so a
-        // single shape gets the edit handles) — see setSelectedShapeIndices().
+        /** The ISOSURFACE band, mapped onto the measured volume (see PlotlyIsosurfaceControls). */
+        this.iso = new PlotlyIsosurfaceControls(() => this.plotType === PlotType.ISOSURFACE && !!this.plotDiv && !!this.liveGd(), (update) => void Plotly.restyle(this.liveGd(), update));
         this.imageCached = false;
         this.coordinateTransform = new PlotlyCoordinateTransform(() => document.getElementById(this.plotDiv), () => this.getOverlayContainer());
+        this.loader = new PlotlyImageLoader(http);
+        this.zoom = new PlotlyZoomController({
+            plotDiv: () => this.plotDiv,
+            trueImgSize: () => this.trueImgSize,
+            imageInfo: () => this.imageInfo,
+            fileName: () => this.fileName,
+            imageCached: () => this.imageCached,
+            zIndex: () => this.zIndex.value,
+            nextRenderGen: () => ++this.renderGen,
+            isCurrentRender: (gen) => gen === this.renderGen,
+            heatmapLayout: (x, y) => this.getHeatmapLayout(x, y),
+            setScreenHeight: (h) => {
+                this.screenHeight = h;
+            },
+            cropSampler: () => {
+                const gen = this.intensity.supersede();
+                return (frames, ratios, origin) => {
+                    if (!this.intensity.isCurrent(gen))
+                        return;
+                    this.setSamplingFrames(frames, ratios, origin);
+                    this.intensity.emitProfiles();
+                };
+            },
+            renderCrop: (frame, ratios, size, imageSize, fileName) => this.renderZoomCrop(frame, ratios, size, imageSize, fileName),
+            reset: () => this.reset(),
+        }, state, tiles, messageService);
         // relayout event router
-        this.onRelayoutEvent = (event) => { this.relayoutEventHandler(event); };
-        // Tool services read/mutate our state via small *Host interfaces. Stored
-        // so we can re-bind them to ourselves whenever a Plotly tool is activated
-        // (the OpenSeadragon backend re-binds the same singleton tools to itself).
-        this.wandHost = {
+        this.onRelayoutEvent = (event) => {
+            this.relayoutEventHandler(event);
+        };
+        this.onSliderChange = (event) => {
+            const active = event?.slider?.active;
+            void this.recolorShownFrame(typeof active === 'number' ? active : this.activeFrameIndex());
+        };
+        // The canvas tools read/mutate our state through one host, and this backend
+        // owns its own tool instances (RT-21) — nothing to re-bind on activation.
+        this.toolHost = {
             getRegions: () => this.regionStore.getRegions(),
             setRegions: (regions) => this.setRegions(regions),
             getCachedImageData: () => this.getCachedImageData(),
@@ -155,46 +150,46 @@ export class PlotlyService {
             getCoordinateTransform: () => this.getCoordinateTransform(),
             getFileName: () => this.fileName,
             getShapeColor: () => this.regionStore.getShapeColor(),
+            pixelToData: (px, py) => this.zoom.pixelToData(px, py),
+            applyZoomToBox: (coords) => this.zoom.applyZoomToBox(coords),
         };
-        this.eraserHost = {
-            getRegions: () => this.regionStore.getRegions(),
-            setRegions: (regions) => this.setRegions(regions),
-            invalidateWandRegion: () => this.wandTool.clearActiveRegion(),
-            getOverlayContainer: () => this.getOverlayContainer(),
-            getCoordinateTransform: () => this.getCoordinateTransform(),
-            getCachedImageRatio: () => this.cachedImageRatios[0] || 1,
-        };
-        this.wandTool.bindHost(this.wandHost);
-        // The brush reuses the wand host (same coordinate frame + region access).
-        this.brushTool.bindHost(this.wandHost);
-        this.vertexEraserTool.bindHost(this.eraserHost);
-        this.bindZoomToBoxHost();
-        this.imageCachedSubscription = this.state.isImageCached$().subscribe(imageCached => {
+        this.canvasTools = createCanvasToolManager(this.toolHost, {
+            wandService,
+            regionStore,
+            samPoint: samPointTool,
+        });
+        this.ensureSubscriptions();
+        // Service-lifetime, unlike ensureSubscriptions(): the shapes follow the
+        // store across a view teardown (they no-op while no Plotly graph is live).
+        this.shapeProjection.connect();
+    }
+    /**
+     * Subscribe to the shared stores (cached flag, filename, live channel recolor,
+     * profile-inset refresh). Idempotent and self-healing, like OSD's
+     * ensureColormapSubscription: this service is a root singleton, but
+     * `unsubscribe()` (called on VisualizerComponent destroy) tears these down and
+     * the constructor never runs again. So `load()`/`plot()` call this to
+     * re-establish them after a component teardown/recreate.
+     */
+    ensureSubscriptions() {
+        if (this.channelSub)
+            return;
+        this.imageCachedSubscription = this.state.isImageCached$().subscribe((imageCached) => {
             this.imageCached = imageCached;
         });
-        this.filenameSubscription = this.state.getFilename$().subscribe(filename => {
+        this.filenameSubscription = this.state.getFilename$().subscribe((filename) => {
             this.fileName = filename;
         });
         // Live recolor from the Channels & Histogram pane: restyle the display window (zmin/zmax for
         // a heatmap, cmin/cmax for isosurface/surface), the colorscale (colormap), and reverse/invert
-        // when the channel state OR the colormap changes. (Gamma is applied by the OSD image view; the
-        // Plotly colorscale window covers the common contrast case.)
+        // when the channel state OR the colormap changes. A colour (RGB / multichannel) image's
+        // `image` trace has no colour scale: it is recomposited per channel instead (applyChannelDisplay).
         this.channelSub = combineLatest([
             this.store.getChannelStates(),
             this.store.getReverseScale(),
             this.store.getInvert(),
             this.store.getColormap(),
         ]).subscribe(([channels, rev, inv]) => this.applyChannelDisplay(channels, rev, inv));
-        // Profile lines are store regions; any region change (add/drag/delete, on
-        // either backend) should refresh the inset traces. The live-edit stream
-        // fires per frame during a drag (OSD coalesces regionUpdate$ until release),
-        // so the inset tracks an OSD line ROI live as it's moved.
-        this.regionUpdateSubscription = this.regionStore.getRegionUpdateEvent().subscribe(() => {
-            this.emitProfiles();
-        });
-        this.regionLiveEditSubscription = this.regionStore.getRegionLiveEdit$().subscribe(() => {
-            this.emitProfiles();
-        });
     }
     getTrueImageSize() {
         if (!this.trueImgSize)
@@ -205,106 +200,35 @@ export class PlotlyService {
         };
     }
     /**
-     * Load image
-     * @param imageInfo
-     * @param zIndex index of the image to load
-     * @return an object with data and ratio keys
+     * Load slice `zIndex`, or the whole shown stack (see PlotlyImageLoader).
+     * `signal` aborts the requests: the load then rejects with an `AbortError`.
      */
-    async load(imageInfo, zIndex) {
-        const urls = imageInfo.urls;
-        // use zIndex provided if any, 0 otherwise
-        let imageUrl;
-        if (zIndex) {
-            imageUrl = urls[zIndex];
-        }
-        else {
-            imageUrl = urls[0];
-        }
-        const isGrayscale = imageInfo.isGrayscale;
-        const image = await this.loadImage(imageUrl);
-        const xRatio = imageInfo.trueImageSize[0] / image.width;
-        const yRatio = imageInfo.trueImageSize[1] / image.height;
-        const trueImageSize = [];
-        // [x0, x1, y0, y1]
-        trueImageSize[0] = 0;
-        trueImageSize[1] = imageInfo.trueImageSize[0];
-        trueImageSize[2] = 0;
-        trueImageSize[3] = imageInfo.trueImageSize[1];
-        this.trueImgSize = trueImageSize;
-        this.fileName = imageInfo.fileName;
-        if (imageInfo.isStack && imageInfo.showStack) {
-            const images = [];
-            this.stackLoadingProgress$.next(0);
-            // One URL per slice — load them all (earlier `length-1` dropped the last).
-            for (let i = 0; i < urls.length; i++) {
-                console.log(`image stack ${i}`);
-                // do not keep with loading if filename is different (a new file has been selected)
-                // or if the stackLoading value is set to false
-                if (this.fileName === imageInfo.fileName && this.stackLoading$.value) {
-                    const image = await this.loadImage(urls[i]);
-                    if (isGrayscale) {
-                        const grey = image.grey();
-                        const imgData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);
-                        images.push(imgData);
-                    }
-                    else {
-                        const rgbData = image.getPixelsArray();
-                        const rgbMatrix = this.plotUtilities.arrayToMatrix(rgbData, image.width);
-                        images.push(rgbMatrix);
-                    }
-                    this.stackLoadingProgress$.next(Math.round((i * 100) / urls.length));
-                }
-                else {
-                    // break stack loading
-                    break;
-                }
-            }
-            // reset stackLoading progress to 0
-            this.stackLoadingProgress$.next(0);
-            return { data: images, ratios: [xRatio, yRatio],
-                sizes: [image.width, image.height],
-                filename: imageInfo.fileName };
-        }
-        else {
-            let imageData;
-            if (isGrayscale) {
-                const grey = image.grey();
-                imageData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);
-            }
-            else {
-                const rgbData = image.getPixelsArray();
-                imageData = this.plotUtilities.arrayToMatrix(rgbData, image.width);
-            }
-            return { data: [imageData],
-                ratios: [xRatio, yRatio],
-                sizes: [image.width, image.height],
-                filename: imageInfo.fileName };
-        }
+    async load(imageInfo, zIndex, signal) {
+        throwIfAborted(signal);
+        // Re-establish the store subscriptions if a prior component teardown
+        // (unsubscribe()) tore them down — see ensureSubscriptions().
+        this.ensureSubscriptions();
+        return this.loader.load(imageInfo, zIndex, signal, () => {
+            // [x0, x1, y0, y1]
+            this.trueImgSize = [0, imageInfo.trueImageSize[0], 0, imageInfo.trueImageSize[1]];
+            this.fileName = imageInfo.fileName;
+        }, () => this.fileName === imageInfo.fileName);
     }
     /**
-     *
-     * @param plotDiv
-     * @param imageLoaded object with data, ratios and sizes key
-     * @param imageInfo ImageInfo object
-     * @param screenHeight size of the available screen height
-     * @param plotType type of plotting
-     */
-    /**
-     * @param inPlace when true, updates the existing plot via Plotly.react
-     *   instead of Plotly.purge + Plotly.newPlot. Used by the multi-tier
-     *   diagram swap (small → large) so the canvas doesn't briefly blank
-     *   between phases.
+     * Plot a loaded image (see {@link load}) as `plotType`. `inPlace` updates the
+     * existing plot via Plotly.react instead of purge + newPlot — the multi-tier
+     * swap (small → large) — so the canvas doesn't briefly blank between phases.
      */
     plot(plotDiv, imageLoaded, imageInfo, screenHeight, plotType, inPlace = false) {
-        const trueImageSize = [];
-        this.zoomCoordinates = [];
-        // [x0, x1, y0, y1]
-        trueImageSize[0] = 0;
-        trueImageSize[1] = imageInfo.trueImageSize[0];
-        trueImageSize[2] = 0;
-        trueImageSize[3] = imageInfo.trueImageSize[1];
+        this.ensureSubscriptions();
+        // A new image: a stroke or SAM prompt in progress belonged to the old one.
+        if (!inPlace)
+            this.canvasTools.resetAll();
+        this.renderGen++;
+        this.zoom.zoomCoordinates = [];
+        const trueImageSize = [0, imageInfo.trueImageSize[0], 0, imageInfo.trueImageSize[1]]; // [x0, x1, y0, y1]
         // Save the current image's regions and pull in any cached regions for the
-        // image we're about to display, before Plotly.newPlot reads `this.shapes`.
+        // image we're about to display, before Plotly.newPlot reads the shape projection.
         this.setActiveImage(imageInfo);
         this.imageInfo = imageInfo;
         this.plotType = plotType;
@@ -315,6 +239,12 @@ export class PlotlyService {
         this.cachedImageRatios = imageLoaded.ratios;
         this.cachedFrameOrigin = [0, 0]; // full image — reset any prior zoom-crop origin
         this.cachedIsGrayscale = !!imageInfo.isGrayscale;
+        this.cachedChannelPlanes = imageLoaded.channelPlanes;
+        // The profiles sample the image on screen from now on (superseding any
+        // sampling fetch still in flight for the previous one).
+        this.intensity.supersede();
+        this.intensity.setSamplingElement(plotDiv);
+        this.intensity.setFrames({ frames: imageLoaded.data, ratios: imageLoaded.ratios }, { imageInfo, extent: trueImageSize, frameIndex: () => this.activeFrameIndex() });
         // Pluggable plot types (contour, scatter, scatter3d, isosurface) render
         // through the trace-builder registry. The original HEATMAP/SURFACE/RGB-image
         // renderers keep their dedicated paths below (also reused by the high-def
@@ -329,148 +259,76 @@ export class PlotlyService {
                 this.imageInfo.isGrayscale = !!imageInfo.isGrayscale;
             return this.plotViaRegistry(plotDiv, impl, this.buildTraceInput(imageInfo, imageLoaded, trueImageSize), screenHeight, inPlace);
         }
+        const target = {
+            plotDiv,
+            urls: imageInfo.urls,
+            frames: imageLoaded.data,
+            trueImgSize: trueImageSize,
+            ratios: imageLoaded.ratios,
+            screenHeight,
+            inPlace,
+        };
         if (imageInfo.isGrayscale) {
-            if (plotType === PlotType.SURFACE) {
-                return this.plotSurface(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize, imageLoaded.ratios, screenHeight, inPlace);
-            }
-            return this.plotHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize, imageLoaded.ratios, screenHeight, inPlace);
+            return plotType === PlotType.SURFACE ? this.plotSurface(target) : this.plotHeatmap(target);
+        }
+        return this.plotRGBHeatmap(target, imageLoaded.sizes[0], imageLoaded.sizes[1], imageLoaded.channelPlanes);
+    }
+    /** Grayscale heatmap, one trace per z-plane. */
+    plotHeatmap(target) {
+        this.recolor.clear();
+        const { frames, trueImgSize, ratios } = target;
+        const traces = buildHeatmapTraces(frames, trueImgSize, ratios, this.store.currentColormap().data.value, this.store.currentReverseScale());
+        const layout = () => this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3], trueImgSize[2]]);
+        return this.renderPlot(target, traces, layout, CONFIG, true);
+    }
+    /** Grayscale surface. */
+    plotSurface(target) {
+        this.recolor.clear();
+        const traces = buildSurfaceTraces(target.frames, this.store.currentColormap().data.value, this.store.currentReverseScale());
+        return this.renderPlot(target, traces, () => surfaceLayout(0.4), CONFIG_SURFACE, true);
+    }
+    /** RGB image (`width` × `height` pixels), one trace per z-plane, in the current channel
+     *  display: `target.frames` are the raw frames, `planes` a serverless multichannel stack's raw
+     *  channel planes per frame. An image that follows the channel states draws a `source` per
+     *  slice (see PlotlyImageRecolor). */
+    async plotRGBHeatmap(target, width, height, planes) {
+        const { frames, trueImgSize, ratios } = target;
+        const render = this.renderGen;
+        let sources = null;
+        try {
+            sources = await this.recolor.plot(recolorKind(this.imageInfo, !!planes?.length), frames, planes);
         }
-        return this.plotRGBHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize, imageLoaded.ratios, imageLoaded.sizes[0], imageLoaded.sizes[1], screenHeight, inPlace);
-    }
-    /**
-     * Function used to plot a grayscale heatmap
-     * @param plotDiv
-     * @param urls
-     * @param images
-     * @param trueImgSize array containing the following : [x0, x1, y0, y1]
-     * @param ratios
-     * @param screenHeight
-     * @return Promise true when plotting is finished
-     */
-    plotHeatmap(plotDiv, urls, images, trueImgSize, ratios, screenHeight, inPlace = false) {
-        if (!inPlace)
-            Plotly.purge(plotDiv);
-        this.plotDiv = plotDiv;
-        this.imageLength = images.length;
-        this.urls = urls;
-        this.screenHeight = screenHeight;
-        // plot
-        const traces = [];
-        images.forEach((dataset, index) => {
-            const trace = {
-                x0: trueImgSize[0],
-                dx: ratios[0],
-                y0: trueImgSize[2],
-                dy: ratios[0],
-                z: dataset,
-                type: 'heatmap',
-                // We remove the tooltip annotation for performances reasons
-                // text: dataset.map((row: any[], i: any) => row.map((item, j) => {
-                //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),
-                hoverinfo: 'none',
-                colorscale: this.store.currentColormap().data.value,
-                reversescale: this.store.currentReverseScale(),
-                name: `Slice ${index + 1}`,
-                visible: index === 0
-            };
-            traces.push(trace);
-        });
-        const render = inPlace ? Plotly.react : Plotly.newPlot;
-        return render(plotDiv, traces, this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3],
-            trueImgSize[2]]), CONFIG).then(() => {
-            // handle the relayout event for zoom / rois and the click event
-            this.setEvents(plotDiv, true, screenHeight);
+        catch (err) {
+            console.warn('[plotly] channel display unavailable; drawing the image as it is', err);
+            this.recolor.clear();
+        }
+        // A newer render took the plot over while the slices were encoded: it draws instead.
+        if (render !== this.renderGen)
             return true;
-        });
+        // As autorange is off and the axis not reversed, the y range is set here.
+        const traces = buildRgbImageTraces(frames, trueImgSize, ratios, width, height, sources ?? undefined);
+        const layout = () => this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3], trueImgSize[2]]);
+        return this.renderPlot(target, traces, layout, CONFIG, false);
     }
     /**
-     * Function used to plot a grayscale surface
-     * @param plotDiv
-     * @param urls
-     * @param images
-     * @param trueImgSize array containing the following : [x0, x1, y0, y1]
-     * @param ratios
-     * @param screenHeight
-     * @return Promise true when plotting is finished
+     * Render `traces` into the plot div and wire the relayout/click events. In
+     * place (`Plotly.react`) for the multi-tier small → large swap — `Plotly.purge`
+     * + `Plotly.newPlot` blanks the canvas for ~100ms, which looks like a
+     * regression to "loading" before the sharper version appears. The layout is
+     * built after the per-plot state (screen height, slice count) is set.
      */
-    plotSurface(plotDiv, urls, images, trueImgSize, ratios, screenHeight, inPlace = false) {
+    renderPlot(target, traces, layout, config, isGrayscale) {
+        const { plotDiv, screenHeight, inPlace } = target;
         if (!inPlace)
             Plotly.purge(plotDiv);
         this.plotDiv = plotDiv;
-        this.imageLength = images.length;
-        this.urls = urls;
+        this.imageLength = target.frames.length;
+        this.urls = target.urls;
         this.screenHeight = screenHeight;
-        // plot
-        const traces = [];
-        images.forEach((dataset, index) => {
-            const trace = {
-                z: dataset,
-                type: 'surface',
-                // hoverinfo: 'none',
-                colorscale: this.store.currentColormap().data.value,
-                reversescale: this.store.currentReverseScale(),
-                // name: `Slice ${index + 1}`,
-                // visible: index === 0
-            };
-            traces.push(trace);
-        });
-        const xrange = [trueImgSize[0], trueImgSize[1]];
-        const yrange = [trueImgSize[2], trueImgSize[3]];
         const render = inPlace ? Plotly.react : Plotly.newPlot;
-        return render(plotDiv, traces, this.getSurfaceLayout(xrange, yrange, 0.4), CONFIG_SURFACE).then(() => {
+        return render(plotDiv, traces, layout(), config).then(() => {
             // handle the relayout event for zoom / rois and the click event
-            this.setEvents(plotDiv, true, screenHeight);
-            return true;
-        });
-    }
-    /**
-     * Function used to plot an RGB heatmap
-     * @param plotDiv
-     * @param urls
-     * @param images
-     * @param trueImgSize
-     * @param width
-     * @param height
-     * @param ratios
-     * @param screenHeight
-     * @return Promise
-     */
-    plotRGBHeatmap(plotDiv, urls, images, trueImgSize, ratios, width, height, screenHeight, inPlace = false) {
-        // Plotly.react updates in place; Plotly.purge + Plotly.newPlot blanks
-        // the canvas for ~100ms which makes the multi-tier small→large swap
-        // look like a regression to "loading" before the sharper version
-        // appears.
-        if (!inPlace)
-            Plotly.purge(plotDiv);
-        this.plotDiv = plotDiv;
-        this.imageLength = images.length;
-        this.urls = urls;
-        this.screenHeight = screenHeight;
-        // as autorange is set to false, and not reversed we need to set the yrange correcly here
-        const layout = this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3], trueImgSize[2]]);
-        const traces = [];
-        images.forEach((dataset, index) => {
-            const trace = {
-                x0: trueImgSize[0],
-                dx: ratios[0],
-                y0: trueImgSize[2],
-                dy: ratios[0],
-                x: Array.from(Array(width).keys()),
-                y: Array.from(Array(height).keys()),
-                z: dataset,
-                // text: dataset.map((row: any[], i: any) => row.map((item, j) => {
-                //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),
-                hoverinfo: 'none',
-                type: 'image',
-                name: `Slice ${index + 1}`,
-                visible: index === 0
-            };
-            traces.push(trace);
-        });
-        const render = inPlace ? Plotly.react : Plotly.newPlot;
-        return render(plotDiv, traces, layout, CONFIG).then(() => {
-            // handle the relayout event
-            this.setEvents(plotDiv, false, screenHeight);
+            this.setEvents(plotDiv, isGrayscale, screenHeight);
             return true;
         });
     }
@@ -483,9 +341,9 @@ export class PlotlyService {
         // into it (the slider is a fixed 0–255 but a stack may occupy only part of
         // that, which would otherwise leave the surfaces with nothing to cross).
         if (this.plotType === PlotType.ISOSURFACE) {
-            this.isoDataRange = this.measureIntensityRange(imageLoaded.data, !!imageInfo.isGrayscale);
+            this.iso.measure(imageLoaded.data, !!imageInfo.isGrayscale);
         }
-        const [isoMin, isoMax] = this.mapIsoBand(this.isoMin, this.isoMax);
+        const [isoMin, isoMax] = this.iso.band();
         return {
             frames: imageLoaded.data,
             width: imageLoaded.sizes[0],
@@ -501,148 +359,43 @@ export class PlotlyService {
             isoMax,
         };
     }
-    /** Min/max intensity over every voxel of the loaded frames (RGB → luminance),
-     *  used to keep the iso band inside the data. Returns null for empty input. */
-    measureIntensityRange(frames, isGrayscale) {
-        let min = Infinity, max = -Infinity;
-        for (const frame of frames || []) {
-            for (const row of frame || []) {
-                for (const cell of row || []) {
-                    const v = isGrayscale ? cell
-                        : 0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2];
-                    if (!Number.isFinite(v))
-                        continue;
-                    if (v < min)
-                        min = v;
-                    if (v > max)
-                        max = v;
-                }
-            }
-        }
-        return (Number.isFinite(min) && Number.isFinite(max) && max > min) ? [min, max] : null;
-    }
-    /** Map the 0–255 slider band onto the volume's actual intensity range. The
-     *  slider is fixed 0–255, but a stack often occupies only a narrow sub-range
-     *  (e.g. this EDOF volume is ~2–50 with structure near 6–10). Mapping spreads
-     *  the data across the whole slider so every intensity is easy to reach and
-     *  the band always lands inside the data — a small inset keeps the extreme
-     *  surfaces off the exact data edges, which are degenerate and draw nothing. */
-    mapIsoBand(isoMin, isoMax) {
-        let lo = Math.min(isoMin, isoMax);
-        let hi = Math.max(isoMin, isoMax);
-        if (this.isoDataRange) {
-            const [vMin, vMax] = this.isoDataRange;
-            const span = vMax - vMin;
-            const pad = 0.03 * span;
-            const usable = span - 2 * pad;
-            const SLIDER_MAX = 255; // toolbar slider domain (isoValueMax)
-            lo = vMin + pad + (lo / SLIDER_MAX) * usable;
-            hi = vMin + pad + (hi / SLIDER_MAX) * usable;
-            if (lo > hi) {
-                const t = lo;
-                lo = hi;
-                hi = t;
-            }
-        }
-        return [lo, hi];
-    }
-    /**
-     * Update the isosurface intensity bounds. When isosurface is on screen this
-     * restyles `isomin`/`isomax` in place for a live update (no volume rebuild).
-     * Slider values are mapped onto the volume's real range so the surfaces always
-     * have data to cross (matching the initial render).
-     */
+    /** Update the isosurface intensity band (see PlotlyIsosurfaceControls). */
     setIsoRange(isoMin, isoMax) {
-        this.isoMin = isoMin;
-        this.isoMax = isoMax;
-        if (this.plotType === PlotType.ISOSURFACE && this.plotDiv) {
-            const [lo, hi] = this.mapIsoBand(isoMin, isoMax);
-            try {
-                Plotly.restyle(this.plotDiv, { isomin: [lo], isomax: [hi] });
-            }
-            catch { /* plot not ready */ }
-        }
+        this.iso.setIsoRange(isoMin, isoMax);
     }
     /** Plotly renders isosurfaces, so it exposes the isosurface controls (itself). */
-    getIsosurfaceControls() { return this; }
+    getIsosurfaceControls() {
+        return this.iso;
+    }
     /**
      * Render a registry-backed plot type: build its traces from the input, pick
      * the matching layout, render, and wire the usual relayout/click events.
      * Mirrors the structure of the dedicated heatmap/surface renderers.
      */
     plotViaRegistry(plotDiv, impl, input, screenHeight, inPlace = false) {
-        if (!inPlace)
-            Plotly.purge(plotDiv);
-        this.plotDiv = plotDiv;
-        this.imageLength = input.frames.length;
-        this.urls = this.imageInfo?.urls ?? this.urls;
-        this.screenHeight = screenHeight;
-        const traces = impl.buildTraces(input);
+        this.recolor.clear();
         const [x0, x1, y0, y1] = input.trueImageSize;
-        let layout;
-        switch (impl.layoutKind) {
-            case '3d-volume':
-                layout = this.getVolumeLayout();
-                break;
-            case '2d-chart':
-                layout = this.getChartLayout();
-                break;
-            case '2d-overlay':
-                layout = this.getOverlayLayout([x0, x1], [y1, y0]); // reversed y like the image
-                break;
-            default: // '2d-image'
-                layout = this.getHeatmapLayout([x0, x1], [y1, y0]);
-        }
-        const config = impl.threeD ? CONFIG_SURFACE : CONFIG;
-        const render = inPlace ? Plotly.react : Plotly.newPlot;
-        return render(plotDiv, traces, layout, config).then(() => {
-            this.setEvents(plotDiv, input.isGrayscale, screenHeight);
-            return true;
-        });
-    }
-    /** Plain 2D chart axes (intensity profile / line plots). */
-    getChartLayout() {
-        return {
-            margin: { t: 30, b: 45, l: 60, r: 20 },
-            height: this.screenHeight,
-            autosize: true,
-            xaxis: { title: 'Position (px)' },
-            yaxis: { title: 'Intensity' },
-            dragmode: false,
-        };
-    }
-    /** Image-aligned 2D axes without the z-plane slider (region scatter). */
-    getOverlayLayout(xRange, yRange) {
-        return {
-            xaxis: { constrain: 'range', constraintoward: 'center', side: 'top', ticks: '', range: xRange },
-            yaxis: {
-                constrain: 'range', constraintoward: 'center', range: yRange, ticks: '',
-                ticksuffix: '  ', autorange: false, scaleanchor: this.scaleratio ? 'x' : false,
-            },
-            margin: { t: 30, b: 5, l: 55, r: 5 },
-            height: this.screenHeight,
-            autosize: true,
-            shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),
-            dragmode: this.dragMode ? this.dragMode : false,
-        };
-    }
-    /** 3D scene for volumetric plot types (scatter3d, isosurface). */
-    getVolumeLayout() {
-        return {
-            margin: { t: 0, b: 0, l: 0, r: 0 },
-            height: this.screenHeight,
-            autosize: true,
-            scene: {
-                xaxis: { title: 'X' },
-                yaxis: { title: 'Y' },
-                zaxis: { title: 'Z-plane' },
-                // 'cube' (not 'data'): a z-stack has far fewer planes than X/Y pixels,
-                // so 'data' squashes the volume into a near-flat slab that reads as
-                // empty edge-on. A cube gives the z dimension real height so the
-                // isosurface/voxels are actually visible.
-                aspectmode: 'cube',
-            },
+        const layout = () => {
+            switch (impl.layoutKind) {
+                case '3d-volume':
+                    return volumeLayout(this.screenHeight);
+                case '2d-chart':
+                    return chartLayout(this.screenHeight);
+                case '2d-overlay':
+                    return overlayLayout(this.layoutContext(), [x0, x1], [y1, y0]); // reversed y
+                default:
+                    return this.getHeatmapLayout([x0, x1], [y1, y0]); // '2d-image'
+            }
         };
+        return this.renderPlot({
+            plotDiv,
+            urls: this.imageInfo?.urls ?? this.urls,
+            frames: input.frames,
+            trueImgSize: input.trueImageSize,
+            ratios: input.ratios,
+            screenHeight,
+            inPlace,
+        }, impl.buildTraces(input), layout, impl.threeD ? CONFIG_SURFACE : CONFIG, input.isGrayscale);
     }
     /** Plot types this backend advertises (drives the UI selector). */
     getPlotTypeDescriptors() {
@@ -656,324 +409,65 @@ export class PlotlyService {
         return this.regionOverlay;
     }
     // ── Intensity profile (Region-based line ROIs) ──────────────────────
-    /** Emits the full set of intensity profiles (one per profile-line region)
-     *  whenever a profile line is added, moved, or removed. */
-    getIntensityProfile$() {
-        return this.intensityProfile$.asObservable();
-    }
     /** Plotly renders the line ROIs + inset, so it exposes the intensity controls. */
-    getIntensityControls() { return this; }
-    /**
-     * Render the floating intensity-profile inset chart into `divId` — one line
-     * trace per ROI, each drawn in its ROI's colour. Kept here (not in the diagram
-     * component) so the consumer never touches Plotly directly.
-     */
+    getIntensityControls() {
+        return this;
+    }
+    /** Render the floating intensity-profile inset (see plotly-intensity-inset.ts),
+     *  so the consumer never touches Plotly directly. */
     renderIntensityInset(divId, profiles) {
-        const el = document.getElementById(divId);
-        if (!el)
-            return;
-        const traces = (profiles ?? []).map((p, i) => ({
-            x: p.positions,
-            y: p.values,
-            type: 'scatter',
-            mode: 'lines',
-            line: { color: p.color ?? '#FFD400', width: 2 },
-            name: `Line ${i + 1}`,
-            hoverinfo: 'x+y',
-        }));
-        // X axis is in microns when the image carries a physical pixel size (mpp),
-        // otherwise in pixels — driven by the unit the sampler tagged on the profile.
-        const unit = (profiles ?? []).find(p => p.unit)?.unit ?? 'px';
-        const xTitle = unit === 'µm' ? 'Position (µm)' : 'Position (px)';
-        Plotly.react(el, traces, {
-            margin: { t: 6, r: 8, b: 38, l: 40 },
-            xaxis: { title: xTitle, zeroline: false, color: '#ddd' },
-            yaxis: { title: 'Intensity', zeroline: false, color: '#ddd' },
-            showlegend: false,
-            paper_bgcolor: 'rgba(25,25,25,0.9)',
-            plot_bgcolor: 'rgba(25,25,25,0.9)',
-            font: { color: '#eee', size: 10 },
-        }, { displayModeBar: false, responsive: true });
+        renderPlotlyIntensityInset(divId, profiles);
     }
-    /**
-     * Region shapes (filtered/redrawn for the current file). The profile-line ROIs
-     * are ordinary store regions (tagged `kind: 'profile'`), so they are already
-     * part of `this.shapes` — no separate append is needed.
-     */
+    /** Region shapes for the image on screen (profile lines included: they are
+     *  ordinary store regions). */
     currentRenderShapes(showLabel = this.regionStore.getShowShapeLabel()) {
-        return this.shapesToRedraw(showLabel);
+        return this.shapeProjection.shapesToRedraw(showLabel);
     }
     /**
-     * IIntensityControls: add another intensity-profile line as a neutral Region
-     * (tagged `kind: 'profile'`). It is a horizontal open 2-point polyline spanning
-     * the image width, staggered vertically so successive lines stay distinct, in
-     * the next bright palette colour. Added to the shared store so both backends
-     * (Plotly + OpenSeadragon) render and drag it; excluded from the Regions tab
-     * and exports by its kind.
+     * IIntensityControls: add another profile line (see IntensityProfileService).
+     * It is a store region, so a Plotly plot on screen draws it from the store's
+     * region-update event, like the OSD/napari overlays.
      */
     addProfileLine() {
-        if (!this.trueImgSize)
-            return null;
-        const count = this.getProfileRegions().length;
-        const imgX0 = this.trueImgSize[0], imgX1 = this.trueImgSize[1];
-        const imgTop = this.trueImgSize[2], imgBottom = this.trueImgSize[3];
-        // Place the line within the currently VISIBLE image area, so when zoomed in it
-        // lands on-screen instead of spanning the whole (mostly off-screen) image, at
-        // 2/3 of the visible width and horizontally centred. Falls back to the full
-        // image when no viewport ROI is known (Plotly heatmap) or a stale ROI no longer
-        // overlaps the image.
-        const roi = this.lastVisibleRoi;
-        const overlaps = !!roi && roi.width > 0 && roi.height > 0
-            && roi.x < imgX1 && roi.x + roi.width > imgX0
-            && roi.y < imgBottom && roi.y + roi.height > imgTop;
-        const x0v = overlaps ? Math.max(imgX0, roi.x) : imgX0;
-        const x1v = overlaps ? Math.min(imgX1, roi.x + roi.width) : imgX1;
-        const topV = overlaps ? Math.max(imgTop, roi.y) : imgTop;
-        const bottomV = overlaps ? Math.min(imgBottom, roi.y + roi.height) : imgBottom;
-        const cx = (x0v + x1v) / 2;
-        const half = ((x1v - x0v) * (2 / 3)) / 2; // line spans 2/3 of the visible width
-        const x0 = cx - half, x1 = cx + half;
-        const bandH = bottomV - topV;
-        const midY = (topV + bottomV) / 2;
-        // Stagger successive lines across the visible band so they stay distinct.
-        const y = Math.min(bottomV, Math.max(topV, midY + count * bandH * 0.12));
-        const poly = new Polygon();
-        poly.npoints = 2;
-        poly.xpoints = [x0, x1];
-        poly.ypoints = [y, y];
-        poly.coordinates = [[x0, y], [x1, y]];
-        poly.closed = false;
-        const region = new Region();
-        region.bounds = poly;
-        region.kind = 'profile';
-        region.color = this.PROFILE_PALETTE[this.profileColorSeq++ % this.PROFILE_PALETTE.length];
-        // Leave region.label undefined so applyClassificationColors won't recolor it.
-        this.regionStore.addRegion(region);
-        // If a Plotly plot is on screen, re-render shapes so the new line appears.
-        // (The OSD overlay renders automatically via its region-update subscription.)
-        if (this.plotDiv) {
-            this.syncShapesFromStore();
-            try {
-                Plotly.relayout(this.plotDiv, { shapes: this.currentRenderShapes() });
-            }
-            catch { /* div not a Plotly plot (OSD owns it) */ }
-        }
-        return region;
-    }
-    /** The profile-line ROIs currently in the store (kind === 'profile'). */
-    getProfileRegions() {
-        return this.regionStore.getRegions().filter(r => r.kind === 'profile');
-    }
-    /** Recompute and broadcast a profile for every profile-line region (id + colour
-     *  tagged so the inset trace matches its line). */
-    emitProfiles() {
-        this.intensityProfile$.next(this.getProfileRegions().map(r => ({
-            ...this.computeIntensityProfileForRegion(r),
-            id: r.id,
-            color: r.color,
-        })));
+        return this.intensity.addProfileLine();
     }
     /**
-     * Sample the intensity profile for a profile-line region: extract its two
-     * polygon endpoints and reuse the shared `computeIntensityProfile` sampling.
-     */
-    computeIntensityProfileForRegion(region) {
-        // Duck-typed (not `instanceof Polygon`): after a drag round-trips through the
-        // store the bounds can be a plain object, so match on the point arrays.
-        const poly = region.bounds;
-        if (!poly || !Array.isArray(poly.xpoints) || !Array.isArray(poly.ypoints) ||
-            poly.xpoints.length < 2 || poly.ypoints.length < 2) {
-            return { positions: [], values: [] };
-        }
-        return this.computeIntensityProfile({
-            x0: poly.xpoints[0], y0: poly.ypoints[0],
-            x1: poly.xpoints[1], y1: poly.ypoints[1],
-        });
-    }
-    /**
-     * Supply pixel frames for intensity sampling (used by the OSD/image backend,
-     * whose cached frames may be empty). Optionally also sets the data/pixel ratios.
+     * Point the pixel tools at these frames (e.g. a high-def zoom crop whose pixel
+     * (0,0) sits at image `origin`), and sample the intensity profiles from them.
      */
     setSamplingFrames(frames, ratios, origin = [0, 0]) {
         this.cachedImageFrames = frames;
         if (ratios)
             this.cachedImageRatios = ratios;
         this.cachedFrameOrigin = origin;
+        // The wand/brush bounds-check against these, so they must describe THESE
+        // frames (e.g. a zoom crop), not the image cached before.
+        const frame = frames?.[0];
+        if (frame?.length) {
+            this.cachedImageHeight = frame.length;
+            this.cachedImageWidth = frame[0]?.length ?? 0;
+        }
+        this.intensity.setFrames({ frames, ratios: this.cachedImageRatios, origin });
     }
-    /**
-     * Populate the sampling cache for the intensity profiles when OpenSeadragon is
-     * the active backend (the Image plot type). In OSD mode Plotly never rendered,
-     * so `cachedImageFrames`/`trueImgSize` are unset — fetch the current slice's
-     * preview (the same pixels the heatmap would sample) so the line ROIs have
-     * pixel data and a placement extent. Re-emits the profiles once loaded.
-     */
-    async ensureIntensitySampling(imageInfo, zIndex) {
-        if (!imageInfo?.urls?.length)
-            return;
-        // Sample just the displayed slice (showStack off → single frame); `load`
-        // also sets `this.trueImgSize`, which addProfileLine needs for placement.
-        const single = { ...imageInfo, showStack: false };
-        const loaded = await this.load(single, zIndex || 0);
-        this.cachedImageFrames = loaded.data;
-        this.cachedImageRatios = loaded.ratios;
-        this.cachedImageWidth = loaded.sizes?.[0] ?? this.cachedImageWidth;
-        this.cachedImageHeight = loaded.sizes?.[1] ?? this.cachedImageHeight;
-        this.cachedFrameOrigin = [0, 0]; // full preview
-        this.cachedIsGrayscale = !!imageInfo.isGrayscale;
-        this.emitProfiles();
-    }
-    /**
-     * {@link IIntensitySampling} stub — the viewport-change signal is OpenSeadragon's
-     * (it re-samples on OSD zoom/pan). Plotly's own high-def zoom updates the
-     * sampling cache inline, so it never emits here; returns EMPTY so a uniform
-     * `IVisualizer` consumer can subscribe regardless of the active backend.
-     */
-    getViewportChange$() {
-        return EMPTY;
+    /** No viewport signal: Plotly's own high-def zoom re-samples the profiles inline. */
+    getIntensitySampling() {
+        return null;
     }
-    /**
-     * Re-fetch the given image-pixel ROI at the display resolution and use it as
-     * the intensity-sampling source, so the profile reflects the data at the
-     * current zoom level. Shared by both backends: the OSD viewport-change hook
-     * calls it on zoom/pan; Plotly's own high-def zoom (triggerZoom) updates the
-     * same cache inline. `roi` is in full-image pixel coordinates.
-     */
-    refreshIntensitySamplingForRoi(x, y, width, height, zIndex) {
-        if (width <= 0 || height <= 0)
-            return;
-        // Remember the visible region so a new profile line is placed inside it.
-        this.lastVisibleRoi = { x, y, width, height };
-        const roi = new Rectangle();
-        roi.x = Math.round(x);
-        roi.y = Math.round(y);
-        roi.width = Math.round(width);
-        roi.height = Math.round(height);
-        const screen = this.plotUtilities.getDomRectangle('diagram');
-        // Snapshot the filename so a response that arrives after the user switched
-        // files is dropped (the request carried the file selected at call time).
-        const reqName = this.fileName;
-        this.tiles.zoomOnRegion(roi, screen, zIndex || 0).subscribe({
-            next: (zoomData) => {
-                Image.load(Buffer.from(new Uint8Array(zoomData))).then((image) => {
-                    if (this.fileName !== reqName)
-                        return;
-                    const isGray = !!this.imageInfo?.isGrayscale;
-                    const frame = isGray
-                        ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)
-                        : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);
-                    this.setSamplingFrames([frame], [roi.width / image.width, roi.height / image.height], [roi.x, roi.y]);
-                    this.emitProfiles();
-                });
-            },
-            error: () => { },
-        });
+    /** No navigator and no smoothing toggle (OpenSeadragon/napari-js view options). */
+    getOsdViewOptions() {
+        return null;
     }
-    /**
-     * Sample the active frame's intensity (grayscale value or RGB luminance)
-     * along the line ROI. Returns distance-along-line positions and values.
-     */
-    computeIntensityProfile(line) {
-        const empty = { positions: [], values: [] };
-        if (!this.cachedImageFrames?.length || !line)
-            return empty;
-        const frame = this.cachedImageFrames[this.activeFrameIndex()] ?? this.cachedImageFrames[0];
-        if (!frame?.length)
-            return empty;
-        const rx = this.cachedImageRatios[0] || 1;
-        const ry = this.cachedImageRatios[1] || rx;
-        const [ox, oy] = this.cachedFrameOrigin;
-        const x0 = +line.x0, y0 = +line.y0, x1 = +line.x1, y1 = +line.y1;
-        const dxData = x1 - x0, dyData = y1 - y0;
-        // Scale the along-line distance by the physical pixel size (microns/pixel)
-        // when the image carries one — anisotropic mppX/mppY are applied per axis so
-        // diagonal lines measure the true physical length. Falls back to pixels.
-        const { mppX, mppY } = this.currentMpp();
-        const useMicrons = mppX != null;
-        const lenData = useMicrons
-            ? Math.hypot(dxData * mppX, dyData * (mppY ?? mppX))
-            : Math.hypot(dxData, dyData);
-        const lenPx = Math.hypot(dxData / rx, dyData / ry);
-        const n = Math.max(2, Math.round(lenPx));
-        const h = frame.length;
-        const w = frame[0].length;
-        const positions = [];
-        const values = [];
-        for (let i = 0; i < n; i++) {
-            const t = i / (n - 1);
-            // Map data coords to the cached frame's pixel grid, offset by the frame's
-            // origin (non-zero when the frame is a zoomed crop).
-            const px = Math.round((x0 + t * dxData - ox) / rx);
-            const py = Math.round((y0 + t * dyData - oy) / ry);
-            let v = 0;
-            if (px >= 0 && px < w && py >= 0 && py < h) {
-                const cell = frame[py][px];
-                v = Array.isArray(cell) ? (0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2]) : cell;
-            }
-            positions.push(t * lenData);
-            values.push(v);
-        }
-        return { positions, values, unit: useMicrons ? 'µm' : 'px' };
-    }
-    /** Physical pixel size (microns/pixel) for the current image, if known.
-     *  mpp is constant across frames/channels, so the first metadata entry that
-     *  carries a positive mppX wins. Returns nulls when the image is unscaled. */
-    currentMpp() {
-        const meta = this.imageInfo?.imageMeta;
-        const m = Array.isArray(meta)
-            ? (meta.find(e => e && (e.mppX ?? 0) > 0) ?? meta[0])
-            : undefined;
-        const mppX = m && (m.mppX ?? 0) > 0 ? m.mppX : null;
-        const mppY = m && (m.mppY ?? 0) > 0 ? m.mppY : null;
-        return { mppX, mppY };
+    /** Plotly renders no decimated volumes (napari-js's Resolution control). */
+    getVolumeResolution() {
+        return null;
     }
-    /**
-     * autoscale the plot
-     */
+    /** Autoscale the plot (see PlotlyZoomController). */
     autoscale() {
-        if (this.plotDiv) {
-            this.zoomCoordinates = [];
-            Plotly.relayout(this.plotDiv, {
-                'xaxis.autorange': true,
-                'yaxis.autorange': false
-            });
-        }
+        this.zoom.autoscale();
     }
-    /**
-     * relayout the plot
-     */
+    /** Re-apply the image layout at the current height, over the zoom box if any. */
     relayout(trueImageSize) {
-        let imgSize;
-        if (trueImageSize) {
-            imgSize = trueImageSize;
-        }
-        else {
-            imgSize = this.trueImgSize;
-        }
-        if (this.plotDiv) {
-            // Refresh height from current DOM so panel resizes are reflected
-            const plotEl = document.getElementById(this.plotDiv);
-            if (plotEl?.offsetHeight) {
-                this.screenHeight = plotEl.offsetHeight;
-            }
-            try {
-                if (this.zoomCoordinates.length > 0) {
-                    Plotly.relayout(this.plotDiv, this.getHeatmapLayout([this.zoomCoordinates[0], this.zoomCoordinates[1]], [this.zoomCoordinates[2], this.zoomCoordinates[3]])); // reverse the y range
-                }
-                else {
-                    // as autorange is set to false, and not reversed we need to set the yrange correcly here
-                    Plotly.relayout(this.plotDiv, this.getHeatmapLayout([imgSize[0], imgSize[1]], [imgSize[3], imgSize[2]]));
-                }
-            }
-            catch (err) {
-                const msg = err?.error?.message || err?.message || err?.statusText || String(err);
-                console.error('Error occured', err);
-                this.messageService.add({ key: VIZ_ALERT_TOAST_KEY, sticky: true, severity: 'error', summary: 'An error occured', detail: `The following
-                                  error occured: ${msg}. Please try to open the image again through the
-                                  file navigator.` });
-                // TODO correctly clear the plot
-                this.reset();
-            }
-        }
+        this.zoom.relayout(trueImageSize);
     }
     setEvents(plotDiv, isGrayscale, screenHeight) {
         if (this.imageInfo)
@@ -981,15 +475,19 @@ export class PlotlyService {
         this.screenHeight = screenHeight;
         const plot = document.getElementById(plotDiv);
         if (plot) {
-            // unbind previous event
-            plot.removeEventListener('plotly_relayout', this.onRelayoutEvent);
-            // bind new event
+            // Rebind the relayout handler. gd.on() registers on Plotly's own
+            // EventEmitter, so it must be unbound with removeListener — the DOM's
+            // removeEventListener is a no-op for it, and every in-place render
+            // (Plotly.react keeps the emitter) used to add another handler.
+            plot.removeListener?.('plotly_relayout', this.onRelayoutEvent);
             plot.on('plotly_relayout', this.onRelayoutEvent);
+            plot.removeListener?.('plotly_sliderchange', this.onSliderChange);
+            plot.on('plotly_sliderchange', this.onSliderChange);
             // Clicking on a shape activates it but Plotly doesn't fire a dedicated
             // event — sample _activeShapeIndex on the next microtask so subscribers
             // (Region Editor) can mirror the selection.
             plot.removeEventListener('mousedown', this.onPlotMouseDown);
-            this.onPlotMouseDown = () => setTimeout(() => this.maybeEmitActiveShapeIndex(), 0);
+            this.onPlotMouseDown = () => setTimeout(() => this.shapeProjection.syncSelectionFromPlot(), 0);
             plot.addEventListener('mousedown', this.onPlotMouseDown);
         }
     }
@@ -997,68 +495,11 @@ export class PlotlyService {
         if (Object.keys(event).includes('dragmode')) {
             this.dragMode = event.dragmode;
         }
-        // when relayout event occurs
-        // update the region selection udpdates
         const keys = Object.keys(event);
-        let shapesModified = false;
-        keys.forEach((key) => {
-            if (typeof key === 'string' && key.startsWith('shapes[')) {
-                const shapeNumber = +key.split('[')[1].split(']')[0];
-                const shapeChange = key.split('.')[1];
-                if (this.shapes && this.shapes[shapeNumber]) {
-                    if (shapeChange === 'path') {
-                        this.shapes[shapeNumber][shapeChange] = this.plotUtilities.roundPathCoordinates(event[key]);
-                    }
-                    else {
-                        this.shapes[shapeNumber][shapeChange] = Math.round(+event[key]);
-                    }
-                    shapesModified = true;
-                }
-            }
-        });
-        if (shapesModified) {
-            // Mirror the in-place edit into the shared store (syncs its cache + emits).
-            this.commitShapesToStore();
-        }
-        // manage high def zoom (not if we are showing a stack)
-        if (keys.length === 4 && this.isRealZoom) {
-            const coordinates = [];
-            keys.forEach(key => {
-                if (key.startsWith('xaxis.range[')) {
-                    coordinates.push(event[key]);
-                }
-                if (key.startsWith('yaxis.range[')) {
-                    coordinates.push(event[key]);
-                }
-            });
-            this.zoomCoordinates = coordinates;
-            if (!this.imageInfo?.showStack) {
-                this.triggerZoom(coordinates);
-            }
-        }
-        // when shape is created
-        if (keys.length === 1 && 'shapes' in event) {
-            this.shapes = event.shapes;
-            for (let i = 0; i < this.shapes.length; i++) {
-                // A freshly Plotly-drawn shape has no id yet — give it a label object
-                // (when labels are on) before the store mints id + default name.
-                const isNew = this.shapes[i].id == null;
-                this.shapes[i].fileName = this.fileName;
-                this.shapes[i] = this.plotUtilities.snapRegion(this.shapes[i]);
-                if (isNew && this.regionStore.getShowShapeLabel()) {
-                    this.shapes[i].label = { text: this.shapes[i].label,
-                        texttemplate: this.shapes[i].label,
-                        font: { color: this.regionStore.getShapeColor() },
-                        textposition: 'top left'
-                    };
-                }
-            }
-            // Mint ids/names in the store, write them back onto the dicts, and emit.
-            this.commitShapesToStore();
-            if (this.isRegionSavedOn) {
-                this.previousShapes = this.shapes.slice();
-            }
-        }
+        // In-place shape edits and natively drawn shapes, mirrored into the store.
+        this.shapeProjection.applyRelayout(event);
+        // Drag-zoom: remember the box and re-fetch it at high definition.
+        this.zoom.onRelayout(event);
         // if autoscale
         if (keys.includes('xaxis.autorange') && keys.includes('yaxis.autorange')) {
             // trigger an autoscale event to reset the selected image mode dropdown
@@ -1074,108 +515,28 @@ export class PlotlyService {
         // Plotly may have updated the active shape index as part of the relayout
         // (e.g. clicking a shape's edit handle, or finishing a draw) — surface
         // that change to the Region Editor.
-        this.maybeEmitActiveShapeIndex();
+        this.shapeProjection.syncSelectionFromPlot();
     }
     reloadAndPlot() {
         this.setImageInfo();
     }
     // ── Tool delegations ────────────────────────────────────────────────
-    setWandMode(active, options = {}) {
-        // Re-bind to ourselves in case the OSD backend last used these singletons.
-        if (active)
-            this.wandTool.bindHost(this.wandHost);
-        this.wandTool.setMode(active, options);
-    }
-    setWandOptions(options) {
-        this.wandTool.setOptions(options);
-    }
-    clearActiveWandRegion() {
-        this.wandTool.clearActiveRegion();
-    }
-    setBrushMode(active, options = {}) {
-        // Re-bind to ourselves in case the OSD backend last used this singleton.
-        if (active)
-            this.brushTool.bindHost(this.wandHost);
-        this.brushTool.setMode(active, options);
-    }
-    setBrushOptions(options) {
-        this.brushTool.setOptions(options);
-    }
-    setVertexEraserMode(active) {
-        if (active)
-            this.vertexEraserTool.bindHost(this.eraserHost);
-        this.vertexEraserTool.setMode(active);
-    }
-    setVertexEraserRadius(radius) {
-        this.vertexEraserTool.setRadius(radius);
-    }
-    setZoomToBoxMode(active) {
-        // The zoom-to-box tool is a root singleton shared with the OSD backend,
-        // which rebinds it to its own host on activation. Rebind to ours when we
-        // activate so a prior OSD zoom-to-box doesn't leave the singleton pointing
-        // at OSD's coordinate/zoom handlers (which would break box-zoom on heatmaps).
-        if (active)
-            this.bindZoomToBoxHost();
-        this.zoomToBoxTool.setMode(active);
-    }
-    /** Bind the shared zoom-to-box tool to this (Plotly) backend's host. */
-    bindZoomToBoxHost() {
-        this.zoomToBoxTool.bindHost({
-            getPlotDiv: () => this.plotDiv,
-            pixelToData: (px, py) => this.zoomBoxPixelToData(px, py),
-            applyZoomToBox: (coords) => this.applyZoomToBox(coords),
-        });
-    }
-    /** Box-prompted SAM: segment the drawn rectangles. The SAM tool reuses the
-     *  wand host (cached frame + coordinate transform + region store). */
+    // The canvas tools (setActiveTool and the per-tool setters) are run by
+    // BaseStoreVisualizer over this.canvasTools; Plotly needs no pointer gating.
+    /** Box-prompted SAM: segment the drawn rectangles against our tool host
+     *  (cached frame + coordinate transform + region store). */
     segmentRectangles() {
-        this.samTool.bindHost(this.wandHost);
-        return this.samTool.segmentBoxes();
+        return this.samTool.segmentBoxes(this.toolHost);
     }
     segmentRectanglesCellpose() {
         if (!this.cellSegmenter)
             return Promise.resolve(0);
-        this.cellSegmentTool.bindHost(this.wandHost);
-        return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);
+        return this.cellSegmentTool.segmentBoxes(this.toolHost, this.cellSegmenter);
     }
     setSamModel(id) {
         this.samTool.setModel(id);
         this.samPointTool.setModel(id);
     }
-    setSamPointMode(active) {
-        if (active)
-            this.samPointTool.bindHost(this.wandHost);
-        this.samPointTool.setMode(active);
-    }
-    commitSamPoints() { this.samPointTool.commit(); }
-    clearSamPoints() { this.samPointTool.clear(); }
-    /**
-     * Tool-host callback: apply the zoom-to-box selection. Stack mode does a
-     * pure axis-range relayout; non-stack mode goes through the high-def
-     * triggerZoom pipeline so the image is re-fetched at the new resolution.
-     */
-    /** Overlay-pixel -> Plotly data coords via the axis objects (subtracting the
-     *  plot margin offset). The zoom-to-box tool calls this through its host. */
-    zoomBoxPixelToData(px, py) {
-        const gd = document.getElementById(this.plotDiv);
-        const xaxis = gd._fullLayout.xaxis;
-        const yaxis = gd._fullLayout.yaxis;
-        return { x: xaxis.p2d(px - xaxis._offset), y: yaxis.p2d(py - yaxis._offset) };
-    }
-    applyZoomToBox(coordinates) {
-        this.zoomCoordinates = coordinates;
-        if (this.imageInfo?.showStack) {
-            Plotly.relayout(this.plotDiv, {
-                'xaxis.range[0]': coordinates[0],
-                'xaxis.range[1]': coordinates[1],
-                'yaxis.range[0]': coordinates[2],
-                'yaxis.range[1]': coordinates[3],
-            });
-        }
-        else {
-            this.triggerZoom(coordinates);
-        }
-    }
     // ── IViewportHost implementation (for the on-canvas tools) ──────────
     /** The plot element the tool canvas overlays attach to. */
     getOverlayContainer() {
@@ -1185,8 +546,14 @@ export class PlotlyService {
     getCoordinateTransform() {
         return this.coordinateTransform;
     }
-    // ── WandToolHost implementation ─────────────────────────────────────
-    /** Pixel data the wand needs for sampling. null = no image loaded. */
+    // ── Canvas tool host ────────────────────────────────────────────────
+    /**
+     * Pixel data the wand needs for sampling. null = no image loaded.
+     *
+     * The traces draw cell (i, j) over `origin + [i, i + 1)·ratio` (see `firstCellCentre`), as OSD
+     * and napari draw their pixels, so the frame starts at the cached origin: a click anywhere on a
+     * cell floors to that cell, and traced outlines run along the cells' edges.
+     */
     getCachedImageData() {
         if (!this.cachedImageFrames || this.cachedImageFrames.length === 0)
             return null;
@@ -1196,67 +563,11 @@ export class PlotlyService {
             height: this.cachedImageHeight,
             ratios: this.cachedImageRatios,
             isGrayscale: this.cachedIsGrayscale,
+            // A high-def zoom caches the crop, whose pixel (0,0) is not image (0,0).
+            originX: this.cachedFrameOrigin[0],
+            originY: this.cachedFrameOrigin[1],
         };
     }
-    // ── shared-store sync helpers ──────────────────────────────────────────
-    //
-    // `this.shapes` is Plotly's own representation (the dict array Plotly.relayout
-    // consumes). The shared RegionStore is the single source of truth, holding the
-    // neutral Region model. These helpers bridge the two: writes mirror
-    // `this.shapes` INTO the store; image switches/external changes project the
-    // store back OUT to `this.shapes`.
-    /** Build Plotly shape dicts from the store's regions (the render projection). */
-    regionsToShapeDicts() {
-        const showLabel = this.regionStore.getShowShapeLabel();
-        return this.regionStore.getRegions().map(r => {
-            r.filename = this.fileName;
-            return { ...r.getShape(showLabel) };
-        });
-    }
-    /** Rebuild the dict working-set from the store (after an image switch, or when
-     *  regions changed while another backend was rendering). */
-    syncShapesFromStore() {
-        this.shapes = this.regionsToShapeDicts();
-    }
-    /**
-     * Make the shared store authoritative for the current dict working-set: convert
-     * `this.shapes` to neutral regions and replace the store's list (the store
-     * mints ids, applies class colours, syncs its per-image cache and emits the
-     * region-update event). Store-minted ids are written back onto the dicts so the
-     * two representations stay aligned. Profile-line ROIs are ordinary regions
-     * (tagged `kind: 'profile'`) and round-trip through here too.
-     */
-    commitShapesToStore() {
-        const regions = this.shapes
-            .map(s => Object.assign(new ShapeSelection(), s).getRegion());
-        this.regionStore.setRegions(regions, this.regionStore.getShowShapeLabel(), true, this.regionStore.getFillColor(), false);
-        const stored = this.regionStore.getRegions();
-        for (let i = 0; i < this.shapes.length && i < stored.length; i++) {
-            if (this.shapes[i].id == null)
-                this.shapes[i].id = stored[i].id;
-            if (this.shapes[i].name == null)
-                this.shapes[i].name = stored[i].name;
-        }
-    }
-    /**
-     * Push the current `this.shapes` to Plotly, mirror them into the shared store
-     * (which syncs its cache + emits the region-update event), and refresh the
-     * local previous-shapes buffer. The wand/eraser tools call this after mutating
-     * the shapes array directly.
-     */
-    applyShapesChange() {
-        if (this.isRegionSavedOn) {
-            this.previousShapes = this.shapes.slice();
-        }
-        this.commitShapesToStore();
-        if (this.plotDiv) {
-            const dictArray = this.shapes.map(s => ({ ...s }));
-            try {
-                Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray));
-            }
-            catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }
-        }
-    }
     /** Active frame index in the cached image stack. */
     activeFrameIndex() {
         if (!this.cachedImageFrames || this.cachedImageFrames.length <= 1)
@@ -1284,82 +595,32 @@ export class PlotlyService {
             Plotly.relayout(this.plotDiv, { 'scene.camera': {} });
         }
     }
-    triggerZoom(coordinates) {
-        if (coordinates.length === 0 || !this.trueImgSize)
-            return;
-        this.zoomCoordinates = coordinates;
-        const rect = this.plotUtilities.getRectangle(coordinates, this.trueImgSize);
-        if (this.plotUtilities.isZoomSameAsImgSize(rect, this.trueImgSize)) {
-            this.autoscale();
-            return;
-        }
-        // A brief "Caching image..." message for uncached files (large files take a
-        // moment to cache); just a spinner otherwise.
-        this.state.setImageLoadingMessage(this.imageCached ? '' : 'Caching image...');
-        const screen = this.plotUtilities.getDomRectangle('diagram');
-        const imageSize = [];
-        imageSize[0] = rect.x;
-        imageSize[1] = rect.x + rect.width;
-        imageSize[2] = rect.y;
-        imageSize[3] = rect.y + rect.height;
-        // Snapshot the filename so a response that arrives after the user switched
-        // files is dropped (the request carried the file selected at call time).
-        const reqName = this.fileName;
-        this.state.setImageLoading(true);
-        this.state.setZoom(true);
-        this.tiles.zoomOnRegion(rect, screen, this.zIndex.value).subscribe({ next: zoomData => {
-                const uint8Array = new Uint8Array(zoomData);
-                const buffer = Buffer.from(uint8Array);
-                Image.load(buffer).then((image) => {
-                    const xRatio = rect.width / image.width;
-                    const yRatio = rect.height / image.height;
-                    if (this.fileName === reqName) {
-                        const isGray = this.imageInfo?.isGrayscale;
-                        const frame = isGray
-                            ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)
-                            : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);
-                        // Also sample the intensity profiles from this high-def crop so the
-                        // inset reflects the zoom-level resolution (origin = crop top-left).
-                        this.setSamplingFrames([frame], [xRatio, yRatio], [imageSize[0], imageSize[2]]);
-                        this.emitProfiles();
-                        // Re-render the high-def crop in the SAME plot type the user is
-                        // viewing. Without this the zoom re-fetch always fell back to a
-                        // heatmap, so zooming in contour (or any registry type) reverted
-                        // to heatmap.
-                        const impl = PLOTLY_PLOT_TYPE_IMPLS[this.plotType];
-                        const renderPromise = impl
-                            ? this.plotViaRegistry(this.plotDiv, impl, this.buildTraceInput(this.imageInfo, {
-                                data: [frame], ratios: [xRatio, yRatio],
-                                sizes: [image.width, image.height], filename: reqName,
-                            }, imageSize), this.screenHeight)
-                            : (isGray
-                                ? this.plotHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio], this.screenHeight)
-                                : this.plotRGBHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio], image.width, image.height, this.screenHeight));
-                        // plotViaRegistry already applies the type's own layout/range for
-                        // non-image layouts (chart/overlay); only re-apply the heatmap
-                        // range for the image-aligned paths.
-                        const reapplyRange = !impl || impl.layoutKind === '2d-image';
-                        renderPromise.then(() => {
-                            this.state.setImageCached(true);
-                            this.state.setImageLoading(false);
-                            image = null;
-                            if (reapplyRange)
-                                this.relayout(imageSize);
-                        });
-                    }
-                });
-            }, error: err => {
-                const msg = err?.error?.message || err?.message || err?.statusText || String(err);
-                console.error('Error occured when zooming', err);
-                this.messageService.add({ key: VIZ_ALERT_TOAST_KEY, sticky: true, severity: 'error', summary: 'An error occured',
-                    detail: `The following error occured while zooming: ${msg}.
-                          Please try to open the image again through the file navigator and
-                          zoom on the selected area once more.` });
-                this.state.setLoadingError(true);
-                this.state.setImageLoading(false);
-            }, complete: () => {
-                console.log('zooming complete');
-            } });
+    /** Re-render a high-def zoom crop in the plot type on screen. Without this the
+     *  re-fetch always fell back to a heatmap, so zooming in contour (or any
+     *  registry type) reverted to heatmap. */
+    renderZoomCrop(frame, ratios, size, imageSize, fileName) {
+        const impl = PLOTLY_PLOT_TYPE_IMPLS[this.plotType];
+        const target = {
+            plotDiv: this.plotDiv,
+            urls: this.urls,
+            frames: [frame],
+            trueImgSize: imageSize,
+            ratios,
+            screenHeight: this.screenHeight,
+        };
+        const rendered = impl
+            ? this.plotViaRegistry(this.plotDiv, impl, this.buildTraceInput(this.imageInfo, {
+                data: [frame],
+                ratios,
+                sizes: size,
+                filename: fileName,
+            }, imageSize), this.screenHeight)
+            : this.imageInfo?.isGrayscale
+                ? this.plotHeatmap(target)
+                : this.plotRGBHeatmap(target, size[0], size[1]);
+        // plotViaRegistry already applies the type's own layout/range for non-image
+        // layouts (chart/overlay); only the image-aligned paths re-apply the range.
+        return { rendered, reapplyRange: !impl || impl.layoutKind === '2d-image' };
     }
     setPlotType(plotType) {
         this.plotType = plotType;
@@ -1385,264 +646,41 @@ export class PlotlyService {
             imgInfo.fileName = this.fileName;
         this.state.setImageInfo(imgInfo);
     }
-    getShapes() {
-        return this.shapes;
-    }
-    /**
-     * Framework-neutral view of the current regions — delegates to the shared
-     * RegionStore (the single source of truth). The canonical accessor on the
-     * `IVisualizer` contract; consumers should prefer this over `getShapes()`
-     * (which exposes Plotly-shaped dicts).
-     */
-    getRegions() {
-        return this.regionStore.getRegions();
-    }
     /**
      * Switch the active image. The shared RegionStore owns the per-image region
      * cache (snapshot outgoing / restore incoming / clear selection / emit); we
      * delegate to it, then re-project the store's regions into Plotly's dict
      * working-set. Re-projecting unconditionally (even when the store no-ops for
      * the same image) means Plotly also picks up regions another backend (OSD)
-     * added while it was off-screen. Called from `plot()` and from the router
-     * before any backend renders.
+     * added while it was off-screen. The switch is not redrawn onto the plot on
+     * screen — that still shows the outgoing image, and the next plot draws the
+     * incoming one's shapes. Called from `plot()` and from the router before any
+     * backend renders.
      */
     setActiveImage(imageInfo) {
-        this.regionStore.setActiveImage(imageInfo);
-        this.syncShapesFromStore();
-        this.previousShapes = this.shapes.slice();
-    }
-    /** Test/dev hook — drop the entire per-image cache (logout / project switch). */
-    clearRegionsByImageKey() {
-        this.regionStore.clearRegionsByImageKey();
+        this.shapeProjection.quietly(() => this.regionStore.setActiveImage(imageInfo));
+        this.shapeProjection.syncFromStore();
     }
-    /**
-     * Get all the selected regions as polygons. Open polylines (closed === false)
-     * are excluded — they're annotation-only and cannot be used as filled regions
-     * for image processing. Delegates to the shared store.
-     */
-    getRegionPolygons() {
-        return this.regionStore.getRegionPolygons();
-    }
-    isRectangle(bnds) {
-        return 'x' in bnds && 'y' in bnds && 'width' in bnds && 'height' in bnds;
-    }
-    isPolygon(bnds) {
-        return 'npoints' in bnds && 'xpoints' in bnds && 'ypoints' in bnds;
-    }
-    /**
-     * Set plot regions. Delegates the state change to the shared RegionStore
-     * (id/name minting, classification colours, append de-duplication, per-image
-     * cache and the region-update event all live there), then re-projects the
-     * store's regions into Plotly's dict working-set and renders.
-     *
-     * When `isRegionSaveOn` is false the regions are shown transiently — rendered
-     * without altering the stored working-set (preserves the prior behaviour).
-     */
-    setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append = false) {
-        const showLabel = showRegionLabel === undefined ? this.regionStore.getShowShapeLabel() : showRegionLabel;
-        const save = isRegionSaveOn === undefined ? this.isRegionSavedOn : isRegionSaveOn;
-        this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);
-        this.isRegionSavedOn = save;
-        if (save) {
-            // Re-project the authoritative regions into Plotly's working-set and render.
-            this.syncShapesFromStore();
-            this.renderShapes();
-        }
-        else {
-            // Transient display only — render the passed regions, don't touch the
-            // working-set (and the store didn't store them either).
-            const dicts = regions.map(r => { r.filename = this.fileName; return { ...r.getShape(showLabel) }; });
-            try {
-                Plotly.relayout(this.plotDiv, this.shapesRelayout(dicts));
-            }
-            catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }
-        }
-    }
-    /** The shapes-relayout payload: region shapes (profile-line ROIs included, as
-     *  they are ordinary regions) plus the active-shape fill colour. */
-    shapesRelayout(shapeDicts) {
-        return {
-            shapes: shapeDicts,
-            activeshape: { fillcolor: this.regionStore.getFillColor() },
-        };
-    }
-    /** Push the current dict working-set to Plotly (no-op when another backend
-     *  owns the div). */
-    renderShapes() {
-        if (!this.plotDiv)
-            return;
-        const dictArray = this.shapes.map(s => ({ ...s }));
-        try {
-            Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray));
-        }
-        catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }
-    }
-    getShowShapeLabel() {
-        return this.regionStore.getShowShapeLabel();
+    /** The plot div while it hosts a live Plotly graph, else null. `plotDiv`
+     *  stays set after purgePlot() hands the div to another backend (OSD,
+     *  napari-js), and Plotly.relayout/restyle throw on a non-Plotly div. */
+    liveGd() {
+        const gd = this.plotDiv ? document.getElementById(this.plotDiv) : null;
+        return gd?._fullLayout ? gd : null;
     }
-    /**
-     * Set previous saved shapes
-     */
-    plotPreviousShapes() {
-        // convert to dict so that plotly recognises the shapes
-        const dictArray = this.previousShapes.map(s => ({ ...s }));
-        try {
-            Plotly.relayout(this.plotDiv, { shapes: dictArray });
-        }
-        catch { /* div owned by another backend (OSD) */ }
-    }
-    setPreviousShapes(shapes) {
-        this.previousShapes = shapes;
-    }
-    getPreviousShapes() {
-        return this.previousShapes;
-    }
-    // Undo (jit-ui#85): region history lives in the shared RegionStore, so the
-    // active backend's overlay re-renders off its regionUpdate$ on restore.
-    undo() { this.regionStore.undo(); }
-    redo() { this.regionStore.redo(); }
-    canUndo() { return this.regionStore.canUndo(); }
-    canRedo() { return this.regionStore.canRedo(); }
-    getCanUndo$() { return this.regionStore.getCanUndo$(); }
-    getCanRedo$() { return this.regionStore.getCanRedo$(); }
-    resetUndoHistory() { this.regionStore.resetUndoHistory(); }
-    // ── Per-slice z-stack regions → RegionStore (jit-ui#93) ──────────────────
-    enterStackMode(slices, initialZ, saveLayout) {
-        this.regionStore.enterStackMode(slices, initialZ, saveLayout);
-    }
-    exitStackMode() { this.regionStore.exitStackMode(); }
-    isStackMode() { return this.regionStore.isStackMode(); }
-    getStackSaveLayout() {
-        return this.regionStore.getStackSaveLayout();
-    }
-    setDisplaySlice(z) { this.regionStore.setDisplaySlice(z); }
-    getSliceRegions() { return this.regionStore.getSliceRegions(); }
-    getStackSaveSlices() { return this.regionStore.getStackSaveSlices(); }
-    getHeatmapLayout(xRange, yRange) {
+    /** The live state an image-aligned layout is built from. */
+    layoutContext() {
         return {
-            xaxis: {
-                constrain: 'range',
-                constraintoward: 'center',
-                side: 'top',
-                ticks: '',
-                range: xRange
-            },
-            yaxis: {
-                constrain: 'range',
-                constraintoward: 'center',
-                range: yRange,
-                ticks: '',
-                ticksuffix: '  ',
-                // set autorange to false so that plotly does not overwrite the range for the y axis
-                autorange: false,
-                scaleanchor: this.scaleratio ? 'x' : false
-            },
-            margin: { t: 30, b: 5, l: 55, r: 5 },
-            height: this.screenHeight,
-            sliders: [{
-                    pad: { t: 50 },
-                    currentvalue: {
-                        visible: true,
-                        prefix: 'Z-plane:',
-                        xanchor: 'right',
-                    },
-                    steps: this.getSteps()
-                }],
-            autosize: true,
+            screenHeight: this.screenHeight,
+            scaleratio: this.scaleratio,
+            dragMode: this.dragMode,
             shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),
-            activeshape: { fillcolor: this.regionStore.getFillColor() },
-            dragmode: this.dragMode ? this.dragMode : false,
-            newshape: { line: { color: this.regionStore.getShapeColor(), width: 3 } }
-        };
-    }
-    shapesToRedraw(showLabel) {
-        const shapesToRedraw = [];
-        for (const shape of this.shapes) {
-            if (JSON.stringify(shape.fileName) === JSON.stringify(this.fileName)) {
-                // Set label
-                if (showLabel) {
-                    shape.label = {
-                        text: `${shape.legend}`,
-                        texttemplate: `${shape.legend}`,
-                        textposition: 'top left',
-                        font: { color: `${shape.line.color}` }
-                    };
-                }
-                else {
-                    shape.label = {};
-                }
-                shapesToRedraw.push(shape);
-            }
-        }
-        // convert to dict so that plotly recognises the shapes
-        return shapesToRedraw.map(s => ({ ...s }));
-    }
-    /**
-     * Unused (will be used when surface plot is added)
-     * @param xRange
-     * @param yRange
-     * @param zRatio
-     * @private
-     */
-    getSurfaceLayout(xRange, yRange, zRatio) {
-        return {
-            margin: { t: 0, b: 0, l: 0, r: 0 },
-            scene: {
-                xaxis: {
-                    gridcolor: 'rgb(255, 255, 255)',
-                    zerolinecolor: 'rgb(255, 255, 255)',
-                    showbackground: true,
-                    backgroundcolor: 'rgb(230, 230,230)',
-                    // range: xRange
-                },
-                yaxis: {
-                    gridcolor: 'rgb(255, 255, 255)',
-                    zerolinecolor: 'rgb(255, 255, 255)',
-                    showbackground: true,
-                    backgroundcolor: 'rgb(230, 230, 230)',
-                    // autorange: 'reversed',
-                    // range: yRange,
-                    // scaleanchor: 'x'
-                },
-                zaxis: {
-                    gridcolor: 'rgb(255, 255, 255)',
-                    zerolinecolor: 'rgb(255, 255, 255)',
-                    showbackground: true,
-                    backgroundcolor: 'rgb(230, 230,230)'
-                },
-                aspectratio: { x: 1, y: 1, z: zRatio },
-                aspectmode: 'manual',
-                sliders: [{
-                        pad: { t: 50 },
-                        currentvalue: {
-                            visible: true,
-                            prefix: 'Z-plane:',
-                            xanchor: 'right',
-                        },
-                        steps: this.getSteps()
-                    }],
-            }
+            fillColor: this.regionStore.getFillColor(),
+            shapeColor: this.regionStore.getShapeColor(),
         };
     }
-    getSteps() {
-        const steps = [];
-        for (let i = 0; i < this.imageLength; i++) {
-            steps.push({
-                label: i + 1,
-                method: 'restyle',
-                args: ['visible', Array(this.imageLength).fill(false).fill(true, i, i + 1)],
-            });
-        }
-        return steps;
-    }
-    /**
-     * Fetch an image via Angular HttpClient so that auth interceptors (Bearer token)
-     * are applied, then decode it with image-js. This avoids raw browser fetch()
-     * calls that bypass the interceptor chain and fail behind an OAuth2 proxy.
-     */
-    async loadImage(url) {
-        const buffer = await firstValueFrom(this.http.get(url, { responseType: 'arraybuffer' }));
-        return Image.load(Buffer.from(buffer));
+    getHeatmapLayout(xRange, yRange) {
+        return heatmapLayout(this.layoutContext(), xRange, yRange, this.imageLength);
     }
     /**
      * Get the currently displayed image as an image-js Image instance.
@@ -1654,7 +692,7 @@ export class PlotlyService {
         }
         const zIdx = this.zIndex.value || 0;
         const url = this.imageInfo.urls[zIdx] || this.imageInfo.urls[0];
-        return this.loadImage(url);
+        return this.loader.loadImage(url);
     }
     /**
      * Get the currently displayed plot pixel data as a flat Uint8ClampedArray.
@@ -1662,76 +700,24 @@ export class PlotlyService {
      * Returns { width, height, channels, data } or null if no plot is displayed.
      */
     getDisplayedPixelData() {
-        if (!this.plotDiv)
-            return null;
-        const gd = document.getElementById(this.plotDiv);
+        const gd = this.plotDiv ? document.getElementById(this.plotDiv) : null;
         if (!gd?.data || gd.data.length === 0)
             return null;
-        // Find the visible trace
-        const frameIdx = this.activeFrameIndex();
-        const trace = gd.data[frameIdx] || gd.data[0];
-        if (!trace || !trace.z)
-            return null;
-        const zData = trace.z;
-        const height = zData.length;
-        if (height === 0)
-            return null;
-        const width = zData[0].length;
-        if (trace.type === 'image') {
-            // RGB image: z[row][col] = [r, g, b] or [r, g, b, a]
-            const sample = zData[0][0];
-            const channels = Array.isArray(sample) ? sample.length : 3;
-            const data = new Uint8ClampedArray(width * height * channels);
-            for (let y = 0; y < height; y++) {
-                for (let x = 0; x < width; x++) {
-                    const pixel = zData[y][x];
-                    const offset = (y * width + x) * channels;
-                    for (let c = 0; c < channels; c++) {
-                        data[offset + c] = pixel[c];
-                    }
-                }
-            }
-            return { width, height, channels, data };
-        }
-        else {
-            // Heatmap (grayscale): z[row][col] = scalar value
-            const data = new Uint8ClampedArray(width * height);
-            for (let y = 0; y < height; y++) {
-                for (let x = 0; x < width; x++) {
-                    data[y * width + x] = Math.round(zData[y][x]);
-                }
-            }
-            return { width, height, channels: 1, data };
-        }
+        const index = gd.data[this.activeFrameIndex()] ? this.activeFrameIndex() : 0;
+        // A trace drawn from a `source` has no `z`: its pixels are the channel display's.
+        return tracePixels(gd.data[index]) ?? this.recolor.displayedPixels(index);
     }
-    /**
-     * Region of the original image that the displayed `z` grid covers, in
-     * full-image pixel coords. On a server zoom (`triggerZoom`) the trace `z` is
-     * replaced with the high-def crop and the axes are relaid out to the crop's
-     * original-image bounds (`imageSize`), so the live axis ranges ARE that
-     * rectangle; when the whole image is in view the ranges span `trueImgSize`.
-     * Reading the ranges therefore yields the crop origin + extent without
-     * tracking zoom state separately. Falls back to the full image, then `null`.
-     */
+    /** The image rect the displayed `z` grid covers, in full-image pixel coords —
+     *  read off the live axis ranges (a high-def zoom relays them out to the crop),
+     *  else the whole image (see axesSourceRect). */
     getDisplayedSourceRect() {
         const gd = this.plotDiv ? document.getElementById(this.plotDiv) : null;
-        const xr = gd?._fullLayout?.xaxis?.range;
-        const yr = gd?._fullLayout?.yaxis?.range;
-        if (xr && yr) {
-            const x0 = Math.min(xr[0], xr[1]);
-            const y0 = Math.min(yr[0], yr[1]); // y axis is reversed for image layouts
-            return { x: x0, y: y0, width: Math.abs(xr[1] - xr[0]), height: Math.abs(yr[1] - yr[0]) };
-        }
-        if (!this.trueImgSize)
-            return null;
-        return {
-            x: this.trueImgSize[0],
-            y: this.trueImgSize[2],
-            width: this.trueImgSize[1] - this.trueImgSize[0],
-            height: this.trueImgSize[3] - this.trueImgSize[2],
-        };
+        return axesSourceRect(gd?._fullLayout?.xaxis?.range, gd?._fullLayout?.yaxis?.range, this.trueImgSize);
     }
     reset() {
+        this.renderGen++;
+        this.recolor.clear();
+        this.intensity.supersede();
         if (this.plotDiv) {
             Plotly.newPlot(this.plotDiv, [], this.getHeatmapLayout([0, 100], [100, 0]), CONFIG);
         }
@@ -1742,6 +728,8 @@ export class PlotlyService {
      * which re-renders an empty plot and would leave the Plotly axes showing.
      */
     purgePlot() {
+        this.renderGen++;
+        this.recolor.clear();
         if (this.plotDiv) {
             Plotly.purge(this.plotDiv);
         }
@@ -1753,12 +741,11 @@ export class PlotlyService {
     }
     downloadImage() {
         if (this.plotDiv) {
-            Plotly.downloadImage(this.plotDiv, { format: 'png', filename: this.fileName || 'image' });
+            void Plotly.downloadImage(this.plotDiv, { format: 'png', filename: this.fileName || 'image' });
         }
     }
     resetAxes() {
-        this.zoomCoordinates = [];
-        this.relayout();
+        this.zoom.resetAxes();
     }
     setDragMode(mode) {
         this.dragMode = mode ? mode : '';
@@ -1775,141 +762,36 @@ export class PlotlyService {
             return;
         Plotly.relayout(this.plotDiv, { dragmode: mode });
     }
-    /** {@link IDataRenderer} stub — Plotly has no overview navigator (it's an
-     *  OpenSeadragon feature), so toggling it is a no-op here. */
-    setNavigatorVisible(_visible) {
-        /* no-op: navigator is OpenSeadragon-only */
-    }
-    /** {@link IDataRenderer} stub — image smoothing is an OpenSeadragon canvas-drawer
-     *  setting; the Plotly image/heatmap traces don't expose it, so it's a no-op. */
-    setImageSmoothingEnabled(_enabled) {
-        /* no-op: smoothing toggle is OpenSeadragon-only */
-    }
     zoomIn() {
-        if (!this.plotDiv)
-            return;
-        const gd = document.getElementById(this.plotDiv);
-        if (!gd?._fullLayout)
-            return;
-        const xl = gd._fullLayout.xaxis;
-        const yl = gd._fullLayout.yaxis;
-        // 3D scenes have no 2D xaxis/yaxis (they live under `scene`); the step-zoom
-        // is meaningless there and would throw on `xl.range`. Plotly's scene handles
-        // scroll-zoom natively, so just bail.
-        if (!xl?.range || !yl?.range)
-            return;
-        const xc = (xl.range[0] + xl.range[1]) / 2;
-        const yc = (yl.range[0] + yl.range[1]) / 2;
-        const dx = (xl.range[1] - xl.range[0]) / 1.3;
-        const dy = (yl.range[1] - yl.range[0]) / 1.3;
-        const x0 = xc - dx / 2, x1 = xc + dx / 2;
-        const y0 = yc - dy / 2, y1 = yc + dy / 2;
-        this.zoomCoordinates = [x0, x1, y0, y1];
-        Plotly.relayout(this.plotDiv, {
-            'xaxis.range[0]': x0, 'xaxis.range[1]': x1,
-            'yaxis.range[0]': y0, 'yaxis.range[1]': y1
-        });
-    }
-    /**
-     * Delete every currently selected shape. Falls back to the single
-     * `_activeShapeIndex` when no multi-selection is active (covers the case
-     * where Plotly clicked a shape without going through the table).
-     */
-    deleteActiveShape() {
-        // Note: no `plotDiv` guard — when OpenSeadragon is the renderer, Plotly
-        // never plotted (plotDiv is unset), but deletion only needs the shape list
-        // + the current selection; the Plotly relayout below is guarded.
-        const gd = this.plotDiv ? document.getElementById(this.plotDiv) : null;
-        // Resolve what to delete: the store's selection, else the shape Plotly
-        // tracks as clicked (when the user clicked a shape without going through the
-        // Region Editor table).
-        if (this.regionStore.getSelectedShapeIndices().length === 0) {
-            const activeIndex = gd?._fullLayout?._activeShapeIndex;
-            if (activeIndex === undefined || activeIndex < 0)
-                return;
-            this.regionStore.setSelectedShapeIndices([activeIndex]);
-        }
-        // The store removes the selected regions, clears the selection, syncs its
-        // cache and emits the region-update event.
-        this.regionStore.deleteActiveShape();
-        // Re-project the remaining regions and render on the Plotly plot (a no-op,
-        // caught, when another backend owns the div — its overlay re-renders via
-        // the store's update event).
-        if (gd?._fullLayout)
-            gd._fullLayout._activeShapeIndex = -1;
-        this.syncShapesFromStore();
-        const dictArray = this.shapes.map(s => ({ ...s }));
-        try {
-            Plotly.relayout(this.plotDiv, { shapes: dictArray }).then(() => {
-                if (gd?._fullLayout)
-                    Plotly.redraw(gd);
-            }, () => { });
-        }
-        catch { /* div owned by another backend */ }
+        this.zoom.zoomIn();
     }
     zoomOut() {
-        if (!this.plotDiv)
-            return;
-        const gd = document.getElementById(this.plotDiv);
-        if (!gd?._fullLayout)
-            return;
-        const xl = gd._fullLayout.xaxis;
-        const yl = gd._fullLayout.yaxis;
-        // 3D scenes have no 2D xaxis/yaxis — see zoomIn().
-        if (!xl?.range || !yl?.range)
-            return;
-        const xc = (xl.range[0] + xl.range[1]) / 2;
-        const yc = (yl.range[0] + yl.range[1]) / 2;
-        const dx = (xl.range[1] - xl.range[0]) * 1.3;
-        const dy = (yl.range[1] - yl.range[0]) * 1.3;
-        const x0 = xc - dx / 2, x1 = xc + dx / 2;
-        const y0 = yc - dy / 2, y1 = yc + dy / 2;
-        this.zoomCoordinates = [x0, x1, y0, y1];
-        Plotly.relayout(this.plotDiv, {
-            'xaxis.range[0]': x0, 'xaxis.range[1]': x1,
-            'yaxis.range[0]': y0, 'yaxis.range[1]': y1
-        });
+        this.zoom.zoomOut();
     }
     isStackLoading$() {
-        return this.stackLoading$.asObservable();
+        return this.loader.stackLoading$.asObservable();
     }
     setStackLoading(stackLoading) {
-        this.stackLoading$.next(stackLoading);
+        this.loader.stackLoading$.next(stackLoading);
     }
     getStackLoadingProgress$() {
-        return this.stackLoadingProgress$.asObservable();
-    }
-    // Colormap / reverse-scale / image metadata state lives in the shared
-    // VisualizerStore; these delegate, keeping only the Plotly-specific live
-    // restyle as render glue.
-    getColormapOptions() {
-        return this.store.getColormapOptions();
+        return this.loader.stackLoadingProgress$.asObservable();
     }
+    // Colormap / reverse-scale state lives in the shared VisualizerStore (the
+    // base class forwards the getters); these setters add the Plotly-specific
+    // live restyle as render glue.
     setColormap(colormap) {
-        this.store.setColormap(colormap);
-        try {
-            Plotly.restyle(this.plotDiv, { 'colorscale': [colormap.data.value] });
-        }
-        catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }
-    }
-    getColormap() {
-        return this.store.getColormap();
+        super.setColormap(colormap);
+        const gd = this.liveGd(); // OSD/napari recolor via their own LUT
+        const scale = colormap.data?.value;
+        if (gd && scale != null)
+            void Plotly.restyle(gd, { colorscale: [scale] });
     }
     setReverseScale(reverscale) {
-        this.store.setReverseScale(reverscale);
-        try {
-            Plotly.restyle(this.plotDiv, { 'reversescale': reverscale });
-        }
-        catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }
-    }
-    getReverseScale() {
-        return this.store.getReverseScale();
-    }
-    setImageMeta(imageMeta) {
-        this.store.setImageMeta(imageMeta);
-    }
-    getImageMeta() {
-        return this.store.getImageMeta();
+        super.setReverseScale(reverscale);
+        const gd = this.liveGd(); // OSD/napari recolor via their own LUT
+        if (gd)
+            void Plotly.restyle(gd, { reversescale: reverscale });
     }
     setShowStack(showstack) {
         if (!showstack) {
@@ -1917,187 +799,95 @@ export class PlotlyService {
         }
         if (this.imageInfo)
             this.imageInfo.showStack = showstack;
-        this.stackLoading$.next(showstack);
-        Plotly.relayout(this.plotDiv, { 'showstack': showstack });
+        this.loader.stackLoading$.next(showstack);
+        Plotly.relayout(this.plotDiv, { showstack: showstack });
     }
     getAutoscaleEvent() {
         return this.autoscaleEvent.asObservable();
     }
-    getRegionUpdateEvent() {
-        return this.regionStore.getRegionUpdateEvent();
-    }
-    /**
-     * Stream of the indices of currently selected regions — owned by the shared
-     * RegionStore so the selection is consistent across backends and the Region
-     * Editor table. Empty = nothing selected.
-     */
-    getSelectedShapeIndices$() {
-        return this.regionStore.getSelectedShapeIndices$();
-    }
-    /**
-     * Programmatically select regions (or clear with []). The shared store owns
-     * the selection state (validates/dedupes/emits); here we additionally point
-     * Plotly's `_activeShapeIndex` at the last selected shape so it gets the edit
-     * handles. No visual change to non-active shapes — Plotly's own active-shape
-     * rendering is the only highlight.
-     */
-    setSelectedShapeIndices(indices) {
-        const valid = (indices || [])
-            .filter(i => Number.isFinite(i) && i >= 0 && i < this.shapes.length);
-        const seen = new Set();
-        const cleaned = [];
-        for (const i of valid) {
-            if (!seen.has(i)) {
-                seen.add(i);
-                cleaned.push(i);
-            }
-        }
-        if (this.plotDiv) {
-            const gd = document.getElementById(this.plotDiv);
-            if (gd?._fullLayout) {
-                gd._fullLayout._activeShapeIndex = cleaned.length > 0 ? cleaned[cleaned.length - 1] : -1;
-                try {
-                    Plotly.redraw(gd);
-                }
-                catch { /* noop in tests */ }
-            }
-        }
-        this.regionStore.setSelectedShapeIndices(cleaned);
-    }
-    /**
-     * Select a specific region (IRegionStore.selectRegion). Sets the shared store
-     * selection by identity and points Plotly's active-shape at the matching
-     * rendered shape so its edit handles appear.
-     */
-    selectRegion(region) {
-        this.regionStore.selectRegion(region);
-        if (this.plotDiv) {
-            const idx = this.shapes.findIndex(s => s.id === region?.id);
-            const gd = document.getElementById(this.plotDiv);
-            if (gd?._fullLayout && idx >= 0) {
-                gd._fullLayout._activeShapeIndex = idx;
-                try {
-                    Plotly.redraw(gd);
-                }
-                catch { /* noop in tests */ }
-            }
-        }
-    }
-    /**
-     * Read Plotly's `_activeShapeIndex` and push it as the selection. Called from
-     * the relayout handler and the post-click tick — Plotly doesn't fire a
-     * dedicated active-shape event for clicks, so we sample. The store no-ops if
-     * the selection is unchanged.
-     */
-    maybeEmitActiveShapeIndex() {
-        if (!this.plotDiv)
-            return;
-        const gd = document.getElementById(this.plotDiv);
-        const raw = gd?._fullLayout?._activeShapeIndex;
-        const idx = (typeof raw === 'number' && raw >= 0 && raw < this.shapes.length) ? raw : -1;
-        this.regionStore.setSelectedShapeIndices(idx >= 0 ? [idx] : []);
-    }
     setZIndex(zIndex) {
         this.zIndex.next(zIndex);
     }
-    getShapeColor() {
-        return this.regionStore.getShapeColor();
-    }
-    getFillColor() {
-        return this.regionStore.getFillColor();
-    }
-    getClassificationColors() {
-        return this.store.getClassificationColors();
-    }
-    setClassificationColor(label, color) {
-        this.store.setClassificationColor(label, color);
-    }
     /**
      * Unsubscribe Subscriptions
      */
     unsubscribe() {
-        if (this.imageCachedSubscription) {
-            this.imageCachedSubscription.unsubscribe();
-        }
-        if (this.filenameSubscription) {
-            this.filenameSubscription.unsubscribe();
-        }
-        if (this.regionUpdateSubscription) {
-            this.regionUpdateSubscription.unsubscribe();
-        }
-        if (this.regionLiveEditSubscription) {
-            this.regionLiveEditSubscription.unsubscribe();
-        }
-        if (this.channelSub) {
-            this.channelSub.unsubscribe();
-        }
+        this.imageCachedSubscription?.unsubscribe();
+        this.imageCachedSubscription = undefined;
+        this.filenameSubscription?.unsubscribe();
+        this.filenameSubscription = undefined;
+        this.channelSub?.unsubscribe();
+        this.channelSub = undefined;
+        if (this.recolorFrame != null)
+            cancelAnimationFrame(this.recolorFrame);
+        this.recolorFrame = null;
     }
     /** Live-apply the channel display window (zmin/zmax) + reverse/invert to the
-     *  heatmap. No-op when no Plotly plot is mounted (OSD owns the div). */
+     *  heatmap — or, for a colour image's `image` trace, recomposite it per channel
+     *  (PlotlyImageRecolor). No-op when no Plotly plot is mounted (OSD owns the div). */
     applyChannelDisplay(channels, rev, inv) {
-        if (!this.plotDiv)
+        const gd = this.liveGd();
+        if (!gd)
+            return;
+        if (this.recolor.active) {
+            this.scheduleRecolor();
+            return;
+        }
+        void Plotly.restyle(gd, channelDisplayRestyle(channels, rev, inv, this.store.currentColormap()?.data?.value, this.plotType));
+    }
+    /**
+     * Recolour the slice on screen on the next frame: a slider drag in the dialog
+     * emits per step, and coalescing them keeps one recomposite per frame — and
+     * none while the previous one is still encoding (see recolorShownFrame).
+     */
+    scheduleRecolor() {
+        if (this.recolorFrame != null)
+            return;
+        this.recolorFrame = requestAnimationFrame(() => {
+            this.recolorFrame = null;
+            void this.recolorShownFrame(this.activeFrameIndex());
+        });
+    }
+    /** Restyle trace `index`'s `source` into the current channel display, unless it shows it
+     *  already. One picture at a time: an edit made while one encodes is drawn after it, in the
+     *  state current by then. */
+    async recolorShownFrame(index) {
+        if (this.recoloring) {
+            this.recolorAgain = true;
             return;
-        const ch = channels?.[0];
-        const colorscale = this.store.currentColormap()?.data?.value;
-        // reverse-scale and invert each flip the ramp; both together cancel.
-        const update = { reversescale: rev !== inv };
-        if (colorscale != null)
-            update.colorscale = colorscale; // live colormap recolor
-        if (ch) {
-            // Surface/isosurface/scatter3d colour-map via cmin/cmax; heatmap/contour via zmin/zmax.
-            const threeD = this.plotType === PlotType.ISOSURFACE ||
-                this.plotType === PlotType.SURFACE ||
-                this.plotType === PlotType.SCATTER3D;
-            if (threeD) {
-                update.cmin = ch.min;
-                update.cmax = ch.max;
-                update.cauto = false;
-            }
-            else {
-                update.zmin = ch.min;
-                update.zmax = ch.max;
-                update.zauto = false;
-            }
         }
+        this.recoloring = true;
         try {
-            Plotly.restyle(this.plotDiv, update);
+            const source = await this.recolor.frame(index);
+            const gd = this.liveGd();
+            if (source && gd)
+                await Plotly.restyle(gd, { source: [source] }, [index]);
+        }
+        catch (err) {
+            console.warn('[plotly] channel display update failed', err);
         }
-        catch {
-            /* not a colour-mapped trace, or OSD owns the div */
+        finally {
+            this.recoloring = false;
+        }
+        if (this.recolorAgain) {
+            this.recolorAgain = false;
+            void this.recolorShownFrame(this.activeFrameIndex());
         }
     }
     /** Binned intensity histogram for a channel from the cached source frames
-     *  (raw, pre-LUT). Grayscale cells are numbers; RGB cells are [r,g,b]. */
+     *  (raw, pre-LUT). Grayscale cells are numbers; RGB cells are [r,g,b]; a
+     *  serverless multichannel stack bins the channel's own raw plane. */
     getHistogram(channelIndex, _bins) {
         const frames = this.cachedImageFrames;
         if (!frames?.length)
             return null;
+        const plane = this.cachedChannelPlanes?.[this.activeFrameIndex()]?.[channelIndex];
+        if (plane)
+            return planeHistogram(plane);
         const frame = frames[this.activeFrameIndex()] ?? frames[0];
         if (!frame?.length)
             return null;
-        const counts = new Array(256).fill(0);
-        for (const row of frame) {
-            if (!row)
-                continue;
-            for (const cell of row) {
-                let v;
-                if (Array.isArray(cell)) {
-                    v = channelIndex >= 0 && channelIndex < cell.length
-                        ? cell[channelIndex]
-                        : Math.round(bt601Luminance(cell[0], cell[1], cell[2]));
-                }
-                else {
-                    v = cell;
-                }
-                v = v | 0;
-                if (v < 0)
-                    v = 0;
-                else if (v > 255)
-                    v = 255;
-                counts[v]++;
-            }
-        }
-        return histogram256(counts);
+        return frameHistogram(frame, channelIndex);
     }
     /** Async histogram stream — Plotly renders heatmap frame data (already in
      *  memory, 8-bit luminance), so this just wraps the synchronous 8-bit
@@ -2110,15 +900,9 @@ export class PlotlyService {
     exportData() {
         console.warn('[plotly] 16-bit data export is not available for the heatmap backend.');
     }
-    importRegions(geoJsonStr) {
-        return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);
-    }
+    /** As the base class, but the file is named after the image on screen. */
     exportRegions(regions) {
-        const jsonString = this.plotUtilities.exportROIsToGeoJson(regions);
-        this.plotUtilities.saveToFile(jsonString, this.fileName);
-    }
-    getGeoJsonString(regions) {
-        return this.plotUtilities.exportROIsToGeoJson(regions);
+        this.regionStore.exportRegions(regions, this.fileName);
     }
     getStackLoadingProgress() {
         return this.getStackLoadingProgress$();
@@ -2126,13 +910,13 @@ export class PlotlyService {
     isStackLoading() {
         return this.isStackLoading$();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: PlotlyService, deps: [{ token: TILE_ACCESS_PORT }, { token: IMAGE_STATE_PORT }, { token: i1.MessageService }, { token: i2.HttpClient }, { token: i3.WandService }, { token: i4.WandToolService }, { token: i5.BrushToolService }, { token: i6.SamToolService }, { token: i7.SamPointToolService }, { token: i8.CellSegmentToolService }, { token: CELL_SEGMENTER, optional: true }, { token: i9.VertexEraserToolService }, { token: i10.ZoomToBoxToolService }, { token: i11.VisualizerStore }, { token: i12.RegionStore }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: PlotlyService, deps: [{ token: TILE_ACCESS_PORT }, { token: IMAGE_STATE_PORT }, { token: i1.MessageService }, { token: i2.HttpClient }, { token: i3.WandService }, { token: i4.SamToolService }, { token: i5.SamPointToolService }, { token: i6.CellSegmentToolService }, { token: CELL_SEGMENTER, optional: true }, { token: i7.VisualizerStore }, { token: i8.RegionStore }, { token: i9.IntensityProfileService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: PlotlyService, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImport: i0, type: PlotlyService, decorators: [{
             type: Injectable,
             args: [{
-                    providedIn: 'root'
+                    providedIn: 'root',
                 }]
         }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
@@ -2140,10 +924,10 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.9", ngImpor
                 }] }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [IMAGE_STATE_PORT]
-                }] }, { type: i1.MessageService }, { type: i2.HttpClient }, { type: i3.WandService }, { type: i4.WandToolService }, { type: i5.BrushToolService }, { type: i6.SamToolService }, { type: i7.SamPointToolService }, { type: i8.CellSegmentToolService }, { type: undefined, decorators: [{
+                }] }, { type: i1.MessageService }, { type: i2.HttpClient }, { type: i3.WandService }, { type: i4.SamToolService }, { type: i5.SamPointToolService }, { type: i6.CellSegmentToolService }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
                     type: Inject,
                     args: [CELL_SEGMENTER]
-                }] }, { type: i9.VertexEraserToolService }, { type: i10.ZoomToBoxToolService }, { type: i11.VisualizerStore }, { type: i12.RegionStore }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE7D,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAEtC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAkB,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAkB,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAC1F,OAAO,EAAE,eAAe,EAAE,KAAK,EAAc,OAAO,EAAgB,aAAa,EAAE,EAAE,EAAE,MAAM,MAAM,CAAC;AACpG,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAe,MAAM,iCAAiC,CAAC;AAC3E,OAAO,EAAmB,eAAe,EAAgB,MAAM,sCAAsC,CAAC;AACtG,OAAO,EAAE,gBAAgB,EAAgB,MAAM,wCAAwC,CAAC;AACxF,OAAO,EAAE,cAAc,EAAE,MAAM,6CAA6C,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,mDAAmD,CAAC;AACxF,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAC9F,OAAO,EAAkB,cAAc,EAAE,MAAM,yCAAyC,CAAC;AACzF,OAAO,EAAE,uBAAuB,EAAwB,MAAM,wDAAwD,CAAC;AACvH,OAAO,EAAE,oBAAoB,EAAE,MAAM,oDAAoD,CAAC;AAK1F,OAAO,EAAE,QAAQ,EAAE,qBAAqB,EAAsB,MAAM,2BAA2B,CAAC;AAChG,OAAO,EACL,sBAAsB,GAGvB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzE,OAAO,EAAsB,aAAa,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAE1G,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;;;;;;;;;;;;;;AAE1D,0EAA0E;AAC1E,0EAA0E;AAC1E,6DAA6D;AAC7D,yDAAyD;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAGpD,MAAc,CAAC,MAAM,GAAG,MAAM,CAAC;AAKhC,MAAM,OAAO,aAAa;IAuIxB,YAA8C,KAAqB,EACrB,KAAqB,EAChD,cAA8B,EAAU,IAAgB,EACvD,WAAwB,EACxB,QAAyB,EACzB,SAA2B,EAC3B,OAAuB,EACvB,YAAiC,EACjC,eAAuC,EACH,aAAoC,EACxE,gBAAyC,EACzC,aAAmC,EACnC,KAAsB,EACtB,WAAwB;QAbE,UAAK,GAAL,KAAK,CAAgB;QACrB,UAAK,GAAL,KAAK,CAAgB;QAChD,mBAAc,GAAd,cAAc,CAAgB;QAAU,SAAI,GAAJ,IAAI,CAAY;QACvD,gBAAW,GAAX,WAAW,CAAa;QACxB,aAAQ,GAAR,QAAQ,CAAiB;QACzB,cAAS,GAAT,SAAS,CAAkB;QAC3B,YAAO,GAAP,OAAO,CAAgB;QACvB,iBAAY,GAAZ,YAAY,CAAqB;QACjC,oBAAe,GAAf,eAAe,CAAwB;QACH,kBAAa,GAAb,aAAa,CAAuB;QACxE,qBAAgB,GAAhB,gBAAgB,CAAyB;QACzC,kBAAa,GAAb,aAAa,CAAsB;QACnC,UAAK,GAAL,KAAK,CAAiB;QACtB,gBAAW,GAAX,WAAW,CAAa;QAlJ5C;;;;;WAKG;QACM,iBAAY,GAAuB,cAAc,CAAC;YACzD,aAAa,CAAC,YAAY;YAC1B,aAAa,CAAC,SAAS;YACvB,aAAa,CAAC,cAAc;YAC5B,aAAa,CAAC,aAAa;YAC3B,aAAa,CAAC,WAAW;YACzB,aAAa,CAAC,WAAW;YACzB,aAAa,CAAC,UAAU;SACzB,CAAC,CAAC;QAEK,WAAM,GAAU,EAAE,CAAC;QACnB,mBAAc,GAAqB,EAAE,CAAC;QACtC,oBAAe,GAAG,IAAI,CAAC;QAIvB,eAAU,GAAG,IAAI,CAAC;QAClB,eAAU,GAAG,IAAI,CAAC;QAElB,oBAAe,GAAa,EAAE,CAAC;QAuB/B,kBAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QAGpC,oBAAe,GAAwB,IAAI,CAAC;QAQ5C,qBAAgB,GAAG,CAAC,CAAC;QACrB,sBAAiB,GAAG,CAAC,CAAC;QACtB,sBAAiB,GAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACrC,sBAAiB,GAAG,KAAK,CAAC;QAClC;;iEAEyD;QACjD,sBAAiB,GAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACrD;;6FAEqF;QAC7E,mBAAc,GAAmE,IAAI,CAAC;QAKtF,kBAAa,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;QACpD,0BAAqB,GAAG,IAAI,eAAe,CAAS,CAAC,CAAC,CAAC;QAC/D,gEAAgE;QACxD,WAAM,GAAG,IAAI,eAAe,CAAS,CAAC,CAAC,CAAC;QACxC,mBAAc,GAAG,IAAI,OAAO,EAAO,CAAC;QAC5C,uEAAuE;QACvE,6EAA6E;QAC7E,8DAA8D;QAC9D;oEAC4D;QAC3C,oBAAe,GAAG;YACjC,SAAS,EAAE,SAAS;YACpB,SAAS,EAAE,OAAO;YAClB,SAAS,EAAE,UAAU;YACrB,SAAS,EAAE,QAAQ;YACnB,SAAS,EAAE,SAAS;YACpB,SAAS,EAAE,SAAS;YACpB,SAAS,EAAE,MAAM;YACjB,SAAS,EAAE,OAAO;SACnB,CAAC;QACF;2CACmC;QAC3B,oBAAe,GAAG,CAAC,CAAC;QACpB,sBAAiB,GAAG,IAAI,OAAO,EAAsB,CAAC;QAC9D;;;yFAGiF;QACzE,WAAM,GAAG,CAAC,CAAC;QACX,WAAM,GAAG,GAAG,CAAC;QACrB;;;;+EAIuE;QAC/D,iBAAY,GAA4B,IAAI,CAAC;QACrD,oEAAoE;QACpE,yEAAyE;QACzE,uEAAuE;QAC/D,gBAAW,GAAG,KAAK,CAAC;QAcX,wBAAmB,GAClC,IAAI,yBAAyB,CAC3B,GAAG,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,EAC3C,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;QAgBpC,wBAAwB;QACxB,IAAI,CAAC,eAAe,GAAG,CAAC,KAAU,EAAE,EAAE,GAAG,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAE7E,yEAAyE;QACzE,0EAA0E;QAC1E,2EAA2E;QAC3E,IAAI,CAAC,QAAQ,GAAG;YACd,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE;YAC/C,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YACjD,kBAAkB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE;YACnD,mBAAmB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,gBAAgB,EAAE;YAClD,mBAAmB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE;YACrD,sBAAsB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,EAAE;YAC3D,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ;YAChC,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE;SACtD,CAAC;QACF,IAAI,CAAC,UAAU,GAAG;YAChB,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE;YAC/C,UAAU,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YACjD,oBAAoB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE;YAC7D,mBAAmB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,mBAAmB,EAAE;YACrD,sBAAsB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,sBAAsB,EAAE;YAC3D,mBAAmB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC;SAC1D,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtC,0EAA0E;QAC1E,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAChD,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEzB,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE;YACjF,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QACjC,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE;YACzE,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,6FAA6F;QAC7F,8FAA8F;QAC9F,+FAA+F;QAC/F,6DAA6D;QAC7D,IAAI,CAAC,UAAU,GAAG,aAAa,CAAC;YAC9B,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE;YAC7B,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE;YAC5B,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE;YACtB,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE;SACzB,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QACrF,0EAA0E;QAC1E,wEAAwE;QACxE,6EAA6E;QAC7E,0DAA0D;QAC1D,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE;YACrF,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,0BAA0B,GAAG,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE;YACrF,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;QACb,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QACnC,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAChD,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;SAClD,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,IAAI,CAAC,SAAqB,EAAE,MAAc;QACrD,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC;QAC5B,0CAA0C;QAC1C,IAAI,QAAQ,CAAC;QACb,IAAI,MAAM,EAAE,CAAC;YACX,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QAC1B,CAAC;aAAM,CAAC;YACN,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;QACD,MAAM,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QAC1C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC7C,MAAM,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;QACxD,MAAM,MAAM,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;QAEzD,MAAM,aAAa,GAAG,EAAE,CAAC;QACzB,mBAAmB;QACnB,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACrB,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QAC9C,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACrB,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QAC9C,IAAI,CAAC,WAAW,GAAG,aAAa,CAAC;QACjC,IAAI,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC;QACnC,IAAI,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC,SAAS,EAAE,CAAC;YAC7C,MAAM,MAAM,GAAU,EAAE,CAAC;YACzB,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACnC,2EAA2E;YAC3E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBACrC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;gBAChC,mFAAmF;gBACnF,+CAA+C;gBAC/C,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,CAAC,QAAQ,IAAI,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;oBACrE,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC5C,IAAI,WAAW,EAAE,CAAC;wBAChB,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;wBAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;wBACrF,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;oBACvB,CAAC;yBAAM,CAAC;wBACN,MAAM,OAAO,GAAG,KAAK,CAAC,cAAc,EAAE,CAAC;wBACvC,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;wBACzE,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBACzB,CAAC;oBACD,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;gBACvE,CAAC;qBAAM,CAAC;oBACN,sBAAsB;oBACtB,MAAM;gBACR,CAAC;YACH,CAAC;YACD,mCAAmC;YACnC,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACnC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;gBACtC,KAAK,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;gBAClC,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,IAAI,SAAS,CAAC;YACd,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;gBAC1B,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YACnF,CAAC;iBAAM,CAAC;gBACN,MAAM,OAAO,GAAG,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;YACrE,CAAC;YACD,OAAO,EAAE,IAAI,EAAE,CAAC,SAAS,CAAC;gBACxB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;gBACxB,KAAK,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC;gBAClC,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC;QACnC,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACH;;;;;OAKG;IACI,IAAI,CAAC,OAAe,EAAE,WAAgB,EAAE,SAAqB,EAAE,YAAoB,EAC9E,QAAkB,EAAE,UAAmB,KAAK;QACtD,MAAM,aAAa,GAAa,EAAE,CAAC;QACnC,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,mBAAmB;QACnB,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACrB,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QAC9C,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACrB,aAAa,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QAC9C,0EAA0E;QAC1E,2EAA2E;QAC3E,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAC/B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,yDAAyD;QACzD,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC,IAAI,CAAC;QAC1C,IAAI,CAAC,gBAAgB,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC9C,IAAI,CAAC,iBAAiB,GAAG,WAAW,CAAC,MAAM,CAAC;QAC5C,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,gDAAgD;QACjF,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC;QAEjD,wEAAwE;QACxE,6EAA6E;QAC7E,0EAA0E;QAC1E,yEAAyE;QACzE,2DAA2D;QAC3D,MAAM,IAAI,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;QAC9C,IAAI,IAAI,EAAE,CAAC;YACT,4EAA4E;YAC5E,4EAA4E;YAC5E,mDAAmD;YACnD,IAAI,IAAI,CAAC,SAAS;gBAAE,IAAI,CAAC,SAAS,CAAC,WAAW,GAAG,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC;YACzE,OAAO,IAAI,CAAC,eAAe,CACzB,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,WAAW,EAAE,aAAa,CAAC,EAC1E,YAAY,EAAE,OAAO,CAAC,CAAC;QAC3B,CAAC;QAED,IAAI,SAAS,CAAC,WAAW,EAAE,CAAC;YAC1B,IAAI,QAAQ,KAAK,QAAQ,CAAC,OAAO,EAAE,CAAC;gBAClC,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,aAAa,EAC9E,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;YAC/C,CAAC;YACD,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,aAAa,EAC9E,WAAW,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;QAC/C,CAAC;QACD,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,aAAa,EACjF,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IAC3F,CAAC;IAED;;;;;;;;;OASG;IACK,WAAW,CAAC,OAAe,EAAE,IAAc,EAAE,MAAa,EAAE,WAAqB,EACtE,MAAgB,EAAE,YAAoB,EAAE,UAAmB,KAAK;QACjF,IAAI,CAAC,OAAO;YAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,OAAO;QACP,MAAM,MAAM,GAAgE,EAAE,CAAC;QAC/E,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YAChC,MAAM,KAAK,GAAG;gBACZ,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC;gBAClB,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;gBACb,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC;gBAClB,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;gBACb,CAAC,EAAE,OAAO;gBACV,IAAI,EAAE,SAAS;gBACf,4DAA4D;gBAC5D,mEAAmE;gBACnE,0GAA0G;gBAC1G,SAAS,EAAE,MAAM;gBACjB,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK;gBACnD,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE;gBAC9C,IAAI,EAAE,SAAS,KAAK,GAAG,CAAC,EAAE;gBAC1B,OAAO,EAAE,KAAK,KAAK,CAAC;aACrB,CAAC;YACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;QACvD,OAAQ,MAAc,CAAC,OAAO,EAAE,MAAa,EAC3C,IAAI,CAAC,gBAAgB,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;YACrE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,MAAa,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC7C,gEAAgE;YAChE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;OASG;IACK,WAAW,CAAC,OAAe,EAAE,IAAc,EAAE,MAAa,EAAE,WAAqB,EACrE,MAAgB,EAAE,YAAoB,EAAE,UAAmB,KAAK;QAClF,IAAI,CAAC,OAAO;YAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,OAAO;QACP,MAAM,MAAM,GAAiC,EAAE,CAAC;QAChD,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YAChC,MAAM,KAAK,GAAG;gBACZ,CAAC,EAAE,OAAO;gBACV,IAAI,EAAE,SAAS;gBACf,qBAAqB;gBACrB,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK;gBACnD,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE;gBAC9C,8BAA8B;gBAC9B,uBAAuB;aACxB,CAAC;YACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;QACvD,OAAQ,MAAc,CAAC,OAAO,EAAE,MAAa,EAC3C,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,cAAqB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC7E,gEAAgE;YAChE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;YAC5C,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;OAWG;IACK,cAAc,CAAC,OAAe,EAAE,IAAc,EAAE,MAAa,EAAE,WAAqB,EACrE,MAAgB,EAAE,KAAa,EAAE,MAAc,EAC/C,YAAoB,EAAE,UAAmB,KAAK;QACnE,sEAAsE;QACtE,oEAAoE;QACpE,iEAAiE;QACjE,WAAW;QACX,IAAI,CAAC,OAAO;YAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QAEjC,yFAAyF;QACzF,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EACnE,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,MAAM,MAAM,GAAgE,EAAE,CAAC;QAC/E,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,EAAE,EAAE;YAChC,MAAM,KAAK,GAAG;gBACZ,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC;gBAClB,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;gBACb,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC;gBAClB,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC;gBACb,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;gBAClC,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC;gBACnC,CAAC,EAAE,OAAO;gBACV,mEAAmE;gBACnE,0GAA0G;gBAC1G,SAAS,EAAE,MAAM;gBACjB,IAAI,EAAE,OAAO;gBACb,IAAI,EAAE,SAAS,KAAK,GAAG,CAAC,EAAE;gBAC1B,OAAO,EAAE,KAAK,KAAK,CAAC;aACrB,CAAC;YACF,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC,CAAC,CAAC;QACH,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;QACvD,OAAQ,MAAc,CAAC,OAAO,EAAE,MAAa,EAAE,MAAM,EAAE,MAAa,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC9E,4BAA4B;YAC5B,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,EAAE,YAAY,CAAC,CAAC;YAC7C,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,SAAqB,EAAE,WAAgB,EACvC,aAAuB;QAC7C,2EAA2E;QAC3E,2EAA2E;QAC3E,yEAAyE;QACzE,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,UAAU,EAAE,CAAC;YAC1C,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,qBAAqB,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAC5F,CAAC;QACD,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACnE,OAAO;YACL,MAAM,EAAE,WAAW,CAAC,IAAI;YACxB,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;YAC3B,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;YAC5B,MAAM,EAAE,WAAW,CAAC,MAAM;YAC1B,aAAa;YACb,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,WAAW;YACpC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC,IAAI,CAAC,KAAK;YACnD,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,mBAAmB,EAAE;YAC9C,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE;YACjC,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE;YAC5C,MAAM;YACN,MAAM;SACP,CAAC;IACJ,CAAC;IAED;mFAC+E;IACvE,qBAAqB,CAAC,MAAa,EAAE,WAAoB;QAC/D,IAAI,GAAG,GAAG,QAAQ,EAAE,GAAG,GAAG,CAAC,QAAQ,CAAC;QACpC,KAAK,MAAM,KAAK,IAAI,MAAM,IAAI,EAAE,EAAE,CAAC;YACjC,KAAK,MAAM,GAAG,IAAI,KAAK,IAAI,EAAE,EAAE,CAAC;gBAC9B,KAAK,MAAM,IAAI,IAAI,GAAG,IAAI,EAAE,EAAE,CAAC;oBAC7B,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,IAAI;wBAC1B,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;oBACxD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;wBAAE,SAAS;oBAClC,IAAI,CAAC,GAAG,GAAG;wBAAE,GAAG,GAAG,CAAC,CAAC;oBACrB,IAAI,CAAC,GAAG,GAAG;wBAAE,GAAG,GAAG,CAAC,CAAC;gBACvB,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACzF,CAAC;IAED;;;;;oFAKgF;IACxE,UAAU,CAAC,MAAc,EAAE,MAAc;QAC/C,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC;YACvC,MAAM,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACzB,MAAM,GAAG,GAAG,IAAI,GAAG,IAAI,CAAC;YACxB,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,GAAG,CAAC;YAC9B,MAAM,UAAU,GAAG,GAAG,CAAC,CAAC,sCAAsC;YAC9D,EAAE,GAAG,IAAI,GAAG,GAAG,GAAG,CAAC,EAAE,GAAG,UAAU,CAAC,GAAG,MAAM,CAAC;YAC7C,EAAE,GAAG,IAAI,GAAG,GAAG,GAAG,CAAC,EAAE,GAAG,UAAU,CAAC,GAAG,MAAM,CAAC;YAC7C,IAAI,EAAE,GAAG,EAAE,EAAE,CAAC;gBAAC,MAAM,CAAC,GAAG,EAAE,CAAC;gBAAC,EAAE,GAAG,EAAE,CAAC;gBAAC,EAAE,GAAG,CAAC,CAAC;YAAC,CAAC;QACjD,CAAC;QACD,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;IAClB,CAAC;IAED;;;;;OAKG;IACI,WAAW,CAAC,MAAc,EAAE,MAAc;QAC/C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAC1D,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACjD,IAAI,CAAC;gBACH,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,EAAS,CAAC,CAAC;YACtE,CAAC;YAAC,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED,kFAAkF;IAC3E,qBAAqB,KAAiC,OAAO,IAAI,CAAC,CAAC,CAAC;IAE3E;;;;OAIG;IACK,eAAe,CAAC,OAAe,EAAE,IAAwB,EAAE,KAAsB,EACjE,YAAoB,EAAE,UAAmB,KAAK;QACpE,IAAI,CAAC,OAAO;YAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;QACvC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC;QAC9C,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QAEjC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QACvC,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,KAAK,CAAC,aAAa,CAAC;QAC7C,IAAI,MAAW,CAAC;QAChB,QAAQ,IAAI,CAAC,UAAU,EAAE,CAAC;YACxB,KAAK,WAAW;gBACd,MAAM,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;gBAChC,MAAM;YACR,KAAK,UAAU;gBACb,MAAM,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;gBAC/B,MAAM;YACR,KAAK,YAAY;gBACf,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,4BAA4B;gBAChF,MAAM;YACR,SAAS,aAAa;gBACpB,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC;QACvD,CAAC;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,MAAM,CAAC;QACrD,MAAM,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC;QACvD,OAAQ,MAAc,CAAC,OAAO,EAAE,MAAa,EAAE,MAAM,EAAE,MAAa,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;YAC9E,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;YACzD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC;IAED,4DAA4D;IACpD,cAAc;QACpB,OAAO;YACL,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;YACtC,MAAM,EAAE,IAAI,CAAC,YAAY;YACzB,QAAQ,EAAE,IAAI;YACd,KAAK,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE;YACjC,KAAK,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE;YAC7B,QAAQ,EAAE,KAAK;SAChB,CAAC;IACJ,CAAC;IAED,yEAAyE;IACjE,gBAAgB,CAAC,MAAgB,EAAE,MAAgB;QACzD,OAAO;YACL,KAAK,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE;YAC/F,KAAK,EAAE;gBACL,SAAS,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE;gBACvE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK;aAC/E;YACD,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE;YACpC,MAAM,EAAE,IAAI,CAAC,YAAY;YACzB,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;YACtE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK;SAChD,CAAC;IACJ,CAAC;IAED,kEAAkE;IAC1D,eAAe;QACrB,OAAO;YACL,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;YAClC,MAAM,EAAE,IAAI,CAAC,YAAY;YACzB,QAAQ,EAAE,IAAI;YACd,KAAK,EAAE;gBACL,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;gBACrB,KAAK,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE;gBACrB,KAAK,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE;gBAC3B,uEAAuE;gBACvE,oEAAoE;gBACpE,iEAAiE;gBACjE,0CAA0C;gBAC1C,UAAU,EAAE,MAAM;aACnB;SACF,CAAC;IACJ,CAAC;IAED,mEAAmE;IAC5D,sBAAsB;QAC3B,OAAO,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAA2B,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1F,CAAC;IAED;oEACgE;IACzD,gBAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,IAAI,CAAC,aAAa,GAAG,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAC5E,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED,uEAAuE;IAEvE;+DAC2D;IACpD,oBAAoB;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;IAC/C,CAAC;IAED,kFAAkF;IAC3E,oBAAoB,KAAgC,OAAO,IAAI,CAAC,CAAC,CAAC;IAEzE;;;;OAIG;IACI,oBAAoB,CAAC,KAAa,EAAE,QAA4B;QACrE,MAAM,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,CAAC,EAAE;YAAE,OAAO;QAChB,MAAM,MAAM,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;YAC7C,CAAC,EAAE,CAAC,CAAC,SAAS;YACd,CAAC,EAAE,CAAC,CAAC,MAAM;YACX,IAAI,EAAE,SAAS;YACf,IAAI,EAAE,OAAO;YACb,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,IAAI,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE;YAC/C,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE;YACrB,SAAS,EAAE,KAAK;SACjB,CAAC,CAAC,CAAC;QACJ,2EAA2E;QAC3E,8EAA8E;QAC9E,MAAM,IAAI,GAAG,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,IAAI,IAAI,IAAI,CAAC;QAC9D,MAAM,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC;QACjE,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,MAAa,EAAE;YAC9B,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;YACpC,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE;YACxD,KAAK,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE;YAC7D,UAAU,EAAE,KAAK;YACjB,aAAa,EAAE,oBAAoB;YACnC,YAAY,EAAE,oBAAoB;YAClC,IAAI,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE;SAC3B,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAS,CAAC,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACK,mBAAmB,CAAC,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE;QAC1E,OAAO,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;OAOG;IACI,cAAc;QACnB,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC,MAAM,CAAC;QAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QAEpE,+EAA+E;QAC/E,8EAA8E;QAC9E,4EAA4E;QAC5E,gFAAgF;QAChF,sBAAsB;QACtB,MAAM,GAAG,GAAG,IAAI,CAAC,cAAc,CAAC;QAChC,MAAM,QAAQ,GAAG,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,KAAK,GAAG,CAAC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;eACpD,GAAG,CAAC,CAAC,GAAG,KAAK,IAAI,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,GAAG,KAAK;eAC1C,GAAG,CAAC,CAAC,GAAG,SAAS,IAAI,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC;QACtD,MAAM,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACvD,MAAM,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAI,CAAC,CAAC,GAAG,GAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;QACpE,MAAM,IAAI,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,GAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC1D,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,GAAI,CAAC,CAAC,GAAG,GAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEjF,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QAC3B,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,sCAAsC;QAChF,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;QAErC,MAAM,KAAK,GAAG,OAAO,GAAG,IAAI,CAAC;QAC7B,MAAM,IAAI,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;QAClC,0EAA0E;QAC1E,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC;QAEzE,MAAM,IAAI,GAAG,IAAI,OAAO,EAAE,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACxB,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACtB,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QAEpB,MAAM,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QAC5B,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,MAAM,CAAC,IAAI,GAAG,SAAS,CAAC;QACxB,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,EAAE,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QAC1F,8EAA8E;QAE9E,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAEnC,2EAA2E;QAC3E,8EAA8E;QAC9E,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,IAAI,CAAC;gBACH,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,mBAAmB,EAAE,EAAS,CAAC,CAAC;YAC/E,CAAC;YAAC,MAAM,CAAC,CAAC,yCAAyC,CAAC,CAAC;QACvD,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,yEAAyE;IACjE,iBAAiB;QACvB,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAE,CAAS,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC;IAClF,CAAC;IAED;uDACmD;IAC3C,YAAY;QAClB,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC7D,GAAG,IAAI,CAAC,gCAAgC,CAAC,CAAC,CAAC;YAC3C,EAAE,EAAE,CAAC,CAAC,EAAE;YACR,KAAK,EAAE,CAAC,CAAC,KAAK;SACf,CAAC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACK,gCAAgC,CAAC,MAAc;QACrD,8EAA8E;QAC9E,wEAAwE;QACxE,MAAM,IAAI,GAAQ,MAAM,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC;YACrE,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvD,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QACvC,CAAC;QACD,OAAO,IAAI,CAAC,uBAAuB,CAAC;YAClC,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YACxC,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;SACzC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,iBAAiB,CAAC,MAAa,EAAE,MAAgB,EAAE,SAA2B,CAAC,CAAC,EAAE,CAAC,CAAC;QACzF,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC;QAChC,IAAI,MAAM;YAAE,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC;QAC5C,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,uBAAuB,CAAC,SAAqB,EAAE,MAAc;QACxE,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM;YAAE,OAAO;QACrC,yEAAyE;QACzE,0EAA0E;QAC1E,MAAM,MAAM,GAAG,EAAE,GAAG,SAAS,EAAE,SAAS,EAAE,KAAK,EAAgB,CAAC;QAChE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC;QACpD,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,IAAI,CAAC;QACrC,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,MAAM,CAAC;QACvC,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC;QACnE,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC;QACrE,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe;QAChD,IAAI,CAAC,iBAAiB,GAAG,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC;QACjD,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACI,kBAAkB;QACvB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACI,8BAA8B,CAAC,CAAS,EAAE,CAAS,EAAE,KAAa,EAAE,MAAc,EACnD,MAAc;QAClD,IAAI,KAAK,IAAI,CAAC,IAAI,MAAM,IAAI,CAAC;YAAE,OAAO;QACtC,yEAAyE;QACzE,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAC9C,MAAM,GAAG,GAAG,IAAI,SAAS,EAAE,CAAC;QAC5B,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC7C,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC/D,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC7D,2EAA2E;QAC3E,yEAAyE;QACzE,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;YAC1D,IAAI,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACjB,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAU,EAAE,EAAE;oBACpE,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO;wBAAE,OAAO;oBACtC,MAAM,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC;oBAC7C,MAAM,KAAK,GAAG,MAAM;wBAClB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;wBAClE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;oBAC1E,IAAI,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,EAClF,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBAClB,IAAI,CAAC,YAAY,EAAE,CAAC;gBACtB,CAAC,CAAC,CAAC;YACL,CAAC;YACD,KAAK,EAAE,GAAG,EAAE,GAAiE,CAAC;SAC/E,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACK,uBAAuB,CAAC,IAAS;QACvC,MAAM,KAAK,GAAqB,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;QAC9D,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,IAAI,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QAC3D,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,IAAI,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC;QAC3F,IAAI,CAAC,KAAK,EAAE,MAAM;YAAE,OAAO,KAAK,CAAC;QACjC,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAC1C,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC3C,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACxC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACjE,MAAM,MAAM,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE,GAAG,EAAE,CAAC;QACzC,2EAA2E;QAC3E,6EAA6E;QAC7E,yEAAyE;QACzE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QACzC,MAAM,UAAU,GAAG,IAAI,IAAI,IAAI,CAAC;QAChC,MAAM,OAAO,GAAG,UAAU;YACxB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC;YACpD,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC;QACnD,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QACzC,MAAM,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;QACvB,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC1B,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAa,EAAE,CAAC;QAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACtB,0EAA0E;YAC1E,qDAAqD;YACrD,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;YACnD,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;YACnD,IAAI,CAAC,GAAG,CAAC,CAAC;YACV,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;gBAC3C,MAAM,IAAI,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC;gBAC3B,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;YACzF,CAAC;YACD,SAAS,CAAC,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACjB,CAAC;QACD,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC/D,CAAC;IAED;;kFAE8E;IACtE,UAAU;QAChB,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC;QACvC,MAAM,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;YAC3B,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;YACrD,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC,CAAC,IAAe,CAAC,CAAC,CAAC,IAAI,CAAC;QAChE,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAE,CAAC,CAAC,IAAe,CAAC,CAAC,CAAC,IAAI,CAAC;QAChE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACxB,CAAC;IAED;;OAEG;IACI,SAAS;QACd,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;YAC1B,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE;gBAC5B,iBAAiB,EAAE,IAAI;gBACvB,iBAAiB,EAAE,KAAK;aAAE,CAC3B,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACI,QAAQ,CAAC,aAAwB;QACtC,IAAI,OAAO,CAAC;QACZ,IAAI,aAAa,EAAE,CAAC;YAClB,OAAO,GAAG,aAAa,CAAC;QAC1B,CAAC;aAAM,CAAC;YACN,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC;QAC7B,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,iEAAiE;YACjE,MAAM,MAAM,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrD,IAAI,MAAM,EAAE,YAAY,EAAE,CAAC;gBACzB,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;YAC1C,CAAC;YACD,IAAI,CAAC;gBACH,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACpC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CACjD,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAClD,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAI,sBAAsB;gBACnF,CAAC;qBAAM,CAAC;oBACN,yFAAyF;oBACzF,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,gBAAgB,CACjD,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACzD,CAAC;YACH,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAClB,MAAM,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,OAAO,IAAI,GAAG,EAAE,OAAO,IAAI,GAAG,EAAE,UAAU,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;gBAClF,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC;gBACpC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,OAAO,EAAE,OAAO,EAAC,kBAAkB,EAAE,MAAM,EAAC;mDAC5E,GAAG;kDACJ,EAAE,CAAC,CAAC;gBAC9C,gCAAgC;gBAChC,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,CAAC;QACH,CAAC;IACH,CAAC;IAEO,SAAS,CAAC,OAAe,EAAE,WAAoB,EAAE,YAAoB;QAC3E,IAAI,IAAI,CAAC,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,WAAW,GAAG,WAAW,CAAC;QAC7D,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,MAAM,IAAI,GAAQ,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QACnD,IAAI,IAAI,EAAE,CAAC;YACT,wBAAwB;YACxB,IAAI,CAAC,mBAAmB,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;YAClE,iBAAiB;YACjB,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;YAEjD,uEAAuE;YACvE,wEAAwE;YACxE,4CAA4C;YAC5C,IAAI,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;YAC5D,IAAI,CAAC,eAAe,GAAG,GAAG,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,yBAAyB,EAAE,EAAE,CAAC,CAAC,CAAC;YACnF,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAC3D,CAAC;IACH,CAAC;IAEO,oBAAoB,CAAC,KAAU;QACrC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YAC5C,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;QACjC,CAAC;QACD,6BAA6B;QAC7B,uCAAuC;QACvC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,cAAc,GAAG,KAAK,CAAC;QAC3B,IAAI,CAAC,OAAO,CAAC,CAAC,GAAQ,EAAE,EAAE;YACxB,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;gBACzD,MAAM,WAAW,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBACrD,MAAM,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;gBACtC,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;oBAC5C,IAAI,WAAW,KAAK,MAAM,EAAE,CAAC;wBAC3B,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;oBAC9F,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;oBAClE,CAAC;oBACD,cAAc,GAAG,IAAI,CAAC;gBACxB,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;QACH,IAAI,cAAc,EAAE,CAAC;YACnB,4EAA4E;YAC5E,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC7B,CAAC;QACD,uDAAuD;QACvD,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACzC,MAAM,WAAW,GAAU,EAAE,CAAC;YAC9B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;gBACjB,IAAI,GAAG,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;oBACnC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC/B,CAAC;gBACD,IAAI,GAAG,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;oBACnC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;gBAC/B,CAAC;YACH,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;YACnC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC;gBAC/B,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;QACD,wBAAwB;QACxB,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,IAAI,KAAK,EAAE,CAAC;YAC3C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAe,CAAC;YACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5C,sEAAsE;gBACtE,iEAAiE;gBACjE,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,CAAC;gBACxC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;gBACxC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC/D,IAAI,KAAK,IAAI,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,EAAE,CAAC;oBAClD,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK;wBACjD,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK;wBAClC,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,EAAE;wBACjD,YAAY,EAAE,UAAU;qBACzB,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,yEAAyE;YACzE,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;gBACzB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;YAC5C,CAAC;QACH,CAAC;QACD,eAAe;QACf,IAAI,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC;YACzE,uEAAuE;YACvE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,2BAA2B,CAAC,CAAC;YACtD,sGAAsG;YACtG,IAAI,CAAC,KAAK,CAAC,oBAAoB,EAAE,CAAC;QACpC,CAAC;QACD,oCAAoC;QACpC,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,IAAI,KAAK,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACrE,8CAA8C;YAC9C,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;QACxD,CAAC;QAED,yEAAyE;QACzE,uEAAuE;QACvE,oCAAoC;QACpC,IAAI,CAAC,yBAAyB,EAAE,CAAC;IACnC,CAAC;IAEM,aAAa;QAClB,IAAI,CAAC,YAAY,EAAE,CAAC;IACtB,CAAC;IAGD,uEAAuE;IAEhE,WAAW,CAAC,MAAe,EAAE,UAAuB,EAAE;QAC3D,2EAA2E;QAC3E,IAAI,MAAM;YAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAEM,cAAc,CAAC,OAAoB;QACxC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IAEM,qBAAqB;QAC1B,IAAI,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC;IACpC,CAAC;IAEM,YAAY,CAAC,MAAe,EAAE,UAAwB,EAAE;QAC7D,yEAAyE;QACzE,IAAI,MAAM;YAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAEM,eAAe,CAAC,OAAqB;QAC1C,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAEM,mBAAmB,CAAC,MAAe;QACxC,IAAI,MAAM;YAAE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC5D,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;IAEM,qBAAqB,CAAC,MAAc;QACzC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAEM,gBAAgB,CAAC,MAAe;QACrC,wEAAwE;QACxE,yEAAyE;QACzE,2EAA2E;QAC3E,8EAA8E;QAC9E,IAAI,MAAM;YAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC;QACrC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IAED,wEAAwE;IAChE,iBAAiB;QACvB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC;YAC1B,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO;YAC9B,WAAW,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,EAAE,EAAE,EAAE,CAAC;YACxD,cAAc,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC;SACxD,CAAC,CAAC;IACL,CAAC;IAED;0EACsE;IAC/D,iBAAiB;QACtB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;IACrC,CAAC;IACM,yBAAyB;QAC9B,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC7C,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC/D,CAAC;IACM,WAAW,CAAC,EAAU;QAC3B,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC1B,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IACjC,CAAC;IACM,eAAe,CAAC,MAAe;QACpC,IAAI,MAAM;YAAE,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACtD,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IACM,eAAe,KAAW,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACvD,cAAc,KAAW,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAE5D;;;;OAIG;IACH;iFAC6E;IACrE,kBAAkB,CAAC,EAAU,EAAE,EAAU;QAC/C,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;QACnC,MAAM,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;QACnC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;IAChF,CAAC;IAEO,cAAc,CAAC,WAAqB;QAC1C,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;QACnC,IAAI,IAAI,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC;YAC9B,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE;gBAC5B,gBAAgB,EAAE,WAAW,CAAC,CAAC,CAAC;gBAChC,gBAAgB,EAAE,WAAW,CAAC,CAAC,CAAC;gBAChC,gBAAgB,EAAE,WAAW,CAAC,CAAC,CAAC;gBAChC,gBAAgB,EAAE,WAAW,CAAC,CAAC,CAAC;aAC1B,CAAC,CAAC;QACZ,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,uEAAuE;IAEvE,2DAA2D;IACpD,mBAAmB;QACxB,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACrE,CAAC;IAED,0EAA0E;IACnE,sBAAsB;QAC3B,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,uEAAuE;IAEvE,sEAAsE;IAC9D,kBAAkB;QACxB,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAChF,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,iBAAiB;YAC9B,KAAK,EAAE,IAAI,CAAC,gBAAgB;YAC5B,MAAM,EAAE,IAAI,CAAC,iBAAiB;YAC9B,MAAM,EAAE,IAAI,CAAC,iBAAiB;YAC9B,WAAW,EAAE,IAAI,CAAC,iBAAiB;SACpC,CAAC;IACJ,CAAC;IAED,0EAA0E;IAC1E,EAAE;IACF,+EAA+E;IAC/E,+EAA+E;IAC/E,oEAAoE;IACpE,4EAA4E;IAC5E,mCAAmC;IAEnC,iFAAiF;IACzE,mBAAmB;QACzB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACvD,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;YAC3C,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC3B,OAAO,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACtC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;gEAC4D;IACpD,mBAAmB;QACzB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC3C,CAAC;IAED;;;;;;;OAOG;IACK,mBAAmB;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM;aACxB,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,cAAc,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC;QAChE,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAC7E,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,EAAE,KAAK,CAAC,CAAC;QAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;QAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACjE,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI;gBAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAChE,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI;gBAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACxE,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACI,iBAAiB;QACtB,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAC5C,CAAC;QACD,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;YACnD,IAAI,CAAC;gBACH,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,SAAS,CAAQ,CAAC,CAAC;YACvE,CAAC;YAAC,MAAM,CAAC,CAAC,qEAAqE,CAAC,CAAC;QACnF,CAAC;IACH,CAAC;IAED,oDAAoD;IAC5C,gBAAgB;QACtB,IAAI,CAAC,IAAI,CAAC,iBAAiB,IAAI,IAAI,CAAC,iBAAiB,CAAC,MAAM,IAAI,CAAC;YAAE,OAAO,CAAC,CAAC;QAC5E,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,MAAM,YAAY,GAAG,EAAE,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAC3D,IAAI,OAAO,YAAY,KAAK,QAAQ;YAAE,OAAO,YAAY,CAAC;QAC1D,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;IAChC,CAAC;IAED,6EAA6E;IAC7E,oBAAoB;QAClB,OAAO;YACL,kBAAkB,EAAE,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC;YACnE,kBAAkB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,EAAE;SACpD,CAAC;IACJ,CAAC;IAEM,kBAAkB,CAAC,IAAY;QACpC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,gBAAgB,EAAE,IAAI,EAAS,CAAC,CAAC;QACnE,CAAC;IACH,CAAC;IAEM,kBAAkB;QACvB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,cAAc,EAAE,EAAE,EAAS,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAEO,WAAW,CAAC,WAAqB;QACvC,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAC1D,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC;QACnC,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC5E,IAAI,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;YACnE,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,OAAO;QACT,CAAC;QACD,4EAA4E;QAC5E,8CAA8C;QAC9C,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC;QAC9E,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC7D,MAAM,SAAS,GAAU,EAAE,CAAC;QAC5B,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACtB,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QACnC,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACtB,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QACpC,2EAA2E;QAC3E,yEAAyE;QACzE,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC9B,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACzB,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE;gBACpF,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,QAAQ,CAAC,CAAC;gBAC5C,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBACvC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,KAAU,EAAE,EAAE;oBACrC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;oBACxC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;oBAC1C,IAAI,IAAI,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC;wBAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,WAAW,CAAC;wBAC3C,MAAM,KAAK,GAAG,MAAM;4BAClB,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;4BAClE,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,KAAK,CAAC,cAAc,EAAE,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;wBAC1E,oEAAoE;wBACpE,qEAAqE;wBACrE,IAAI,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;wBAChF,IAAI,CAAC,YAAY,EAAE,CAAC;wBACpB,gEAAgE;wBAChE,gEAAgE;wBAChE,iEAAiE;wBACjE,cAAc;wBACd,MAAM,IAAI,GAAG,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;wBACnD,MAAM,aAAa,GAAG,IAAI;4BACxB,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EACrC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,EAAE;gCACnC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;gCACvC,KAAK,EAAE,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAO;6BACtD,EAAE,SAAS,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC;4BACrC,CAAC,CAAC,CAAC,MAAM;gCACL,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5E,IAAI,CAAC,YAAY,CAAC;gCACtB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/E,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;wBACzD,kEAAkE;wBAClE,+DAA+D;wBAC/D,qCAAqC;wBACrC,MAAM,YAAY,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,CAAC;wBAC7D,aAAa,CAAC,IAAI,CAAC,GAAG,EAAE;4BACtB,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;4BAChC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;4BAClC,KAAK,GAAG,IAAI,CAAC;4BACb,IAAI,YAAY;gCAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;wBAC7C,CAAC,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,EAAE,KAAK,EAAE,GAAG,CAAC,EAAE;gBACd,MAAM,GAAG,GAAG,GAAG,EAAE,KAAK,EAAE,OAAO,IAAI,GAAG,EAAE,OAAO,IAAI,GAAG,EAAE,UAAU,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC;gBAClF,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,GAAG,CAAC,CAAC;gBACjD,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,mBAAmB,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAC,OAAO,EAAE,OAAO,EAAC,kBAAkB;oBAC5G,MAAM,EAAC,8CAA8C,GAAG;;+DAED,EAAE,CAAC,CAAC;gBAC7D,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;gBACjC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE;gBAChB,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YAClC,CAAC,EAAE,CAAC,CAAC;IACP,CAAC;IAEM,WAAW,CAAC,QAAkB;QACnC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAEO,YAAY,CAAC,SAAmB,EAAE,UAAoB;QAC5D,0FAA0F;QAC1F,iFAAiF;QACjF,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;YAClC,OAAO;QACT,CAAC;QACD,yEAAyE;QACzE,MAAM,OAAO,GAAwB;YACnC,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE,WAAW;YACxC,aAAa,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACzD,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;YAC7B,UAAU,EAAE,UAAU,KAAK,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU;SACpE,CAAC;QACF,IAAI,SAAS,KAAK,SAAS;YAAE,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3D,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;QACpD,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC;IAEM,SAAS;QACd,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACI,UAAU;QACf,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;IACvC,CAAC;IAED;;;;;;;;OAQG;IACI,cAAc,CAAC,SAAqB;QACzC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC5C,CAAC;IAED,iFAAiF;IAC1E,sBAAsB;QAC3B,IAAI,CAAC,WAAW,CAAC,sBAAsB,EAAE,CAAC;IAC5C,CAAC;IAED;;;;OAIG;IACI,iBAAiB;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;IAC9C,CAAC;IAED,WAAW,CAAC,IAAS;QACnB,OAAO,GAAG,IAAI,IAAI,IAAI,GAAG,IAAI,IAAI,IAAI,OAAO,IAAI,IAAI,IAAI,QAAQ,IAAI,IAAI,CAAC;IAC3E,CAAC;IAED,SAAS,CAAC,IAAS;QACjB,OAAO,SAAS,IAAI,IAAI,IAAI,SAAS,IAAI,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC;IACrE,CAAC;IAED;;;;;;;;OAQG;IACI,UAAU,CAAC,OAAiB,EAAE,eAAyB,EAC5C,cAAwB,EAAE,SAAkB,EAC5C,SAAkB,KAAK;QACvC,MAAM,SAAS,GAAG,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC;QACzG,MAAM,IAAI,GAAG,cAAc,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,cAAc,CAAC;QAElF,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QACzF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAE5B,IAAI,IAAI,EAAE,CAAC;YACT,6EAA6E;YAC7E,IAAI,CAAC,mBAAmB,EAAE,CAAC;YAC3B,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC;aAAM,CAAC;YACN,sEAAsE;YACtE,wDAAwD;YACxD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YACrG,IAAI,CAAC;gBACH,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAQ,CAAC,CAAC;YACnE,CAAC;YAAC,MAAM,CAAC,CAAC,qEAAqE,CAAC,CAAC;QACnF,CAAC;IACH,CAAC;IAED;wEACoE;IAC5D,cAAc,CAAC,UAAiB;QACtC,OAAO;YACL,MAAM,EAAE,UAAU;YAClB,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,EAAE;SAC5D,CAAC;IACJ,CAAC;IAED;yBACqB;IACb,YAAY;QAClB,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC;YACH,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CAAC,SAAS,CAAQ,CAAC,CAAC;QACvE,CAAC;QAAC,MAAM,CAAC,CAAC,qEAAqE,CAAC,CAAC;IACnF,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;IAC9C,CAAC;IAED;;OAEG;IACI,kBAAkB;QACvB,uDAAuD;QACvD,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC;YACH,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;QACvD,CAAC;QAAC,MAAM,CAAC,CAAC,wCAAwC,CAAC,CAAC;IACtD,CAAC;IAED,iBAAiB,CAAC,MAAwB;QACxC,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC;IAC/B,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED,2EAA2E;IAC3E,wEAAwE;IACjE,IAAI,KAAW,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACzC,IAAI,KAAW,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;IACzC,OAAO,KAAc,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACzD,OAAO,KAAc,OAAO,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACzD,WAAW,KAA0B,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAC7E,WAAW,KAA0B,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAC7E,gBAAgB,KAAW,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;IAExE,4EAA4E;IACrE,cAAc,CAAC,MAA6B,EAAE,QAAiB,EAChD,UAA0C;QAC9D,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;IAChE,CAAC;IACM,aAAa,KAAW,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;IAC3D,WAAW,KAAc,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IACjE,kBAAkB;QACvB,OAAO,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC;IAC/C,CAAC;IACM,eAAe,CAAC,CAAS,IAAU,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACzE,eAAe,KAAe,OAAO,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;IAC1E,kBAAkB,KAA4B,OAAO,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC,CAAC,CAAC;IAE5F,gBAAgB,CAAC,MAAgB,EAAE,MAAgB;QACzD,OAAO;YACL,KAAK,EAAE;gBACL,SAAS,EAAE,OAAO;gBAClB,eAAe,EAAE,QAAQ;gBACzB,IAAI,EAAE,KAAK;gBACX,KAAK,EAAE,EAAE;gBACT,KAAK,EAAE,MAAM;aACd;YACD,KAAK,EAAE;gBACL,SAAS,EAAE,OAAO;gBAClB,eAAe,EAAE,QAAQ;gBACzB,KAAK,EAAE,MAAM;gBACb,KAAK,EAAE,EAAE;gBACT,UAAU,EAAE,IAAI;gBACpB,oFAAoF;gBACpF,SAAS,EAAE,KAAK;gBACZ,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK;aAC5C;YACA,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE;YACpC,MAAM,EAAE,IAAI,CAAC,YAAY;YACzB,OAAO,EAAE,CAAC;oBACR,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;oBACd,YAAY,EAAE;wBACZ,OAAO,EAAE,IAAI;wBACb,MAAM,EAAE,UAAU;wBAClB,OAAO,EAAE,OAAO;qBACjB;oBACD,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE;iBACvB,CAAC;YACF,QAAQ,EAAE,IAAI;YACd,MAAM,EAAE,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;YACtE,WAAW,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,EAAE;YAC3D,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK;YAC/C,QAAQ,EAAE,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;SAC1E,CAAC;IACJ,CAAC;IAEO,cAAc,CAAC,SAAkB;QACvC,MAAM,cAAc,GAAqB,EAAE,CAAC;QAC5C,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChC,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACrE,YAAY;gBACZ,IAAI,SAAS,EAAE,CAAC;oBACd,KAAK,CAAC,KAAK,GAAG;wBACZ,IAAI,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE;wBACvB,YAAY,EAAE,GAAG,KAAK,CAAC,MAAM,EAAE;wBAC/B,YAAY,EAAE,UAAU;wBACxB,IAAI,EAAE,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE;qBACvC,CAAC;gBACJ,CAAC;qBAAM,CAAC;oBACN,KAAK,CAAC,KAAK,GAAG,EAAE,CAAC;gBACnB,CAAC;gBACD,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QACD,uDAAuD;QACvD,OAAO,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7C,CAAC;IACD;;;;;;OAMG;IACK,gBAAgB,CAAC,MAAgB,EAAE,MAAgB,EAAE,MAAc;QACzE,OAAO;YACL,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;YAClC,KAAK,EAAE;gBACL,KAAK,EAAE;oBACL,SAAS,EAAE,oBAAoB;oBAC/B,aAAa,EAAE,oBAAoB;oBACnC,cAAc,EAAE,IAAI;oBACpB,eAAe,EAAE,mBAAmB;oBACpC,gBAAgB;iBACjB;gBACD,KAAK,EAAE;oBACL,SAAS,EAAE,oBAAoB;oBAC/B,aAAa,EAAE,oBAAoB;oBACnC,cAAc,EAAE,IAAI;oBACpB,eAAe,EAAE,oBAAoB;oBACrC,yBAAyB;oBACzB,iBAAiB;oBACjB,mBAAmB;iBACpB;gBACD,KAAK,EAAE;oBACL,SAAS,EAAE,oBAAoB;oBAC/B,aAAa,EAAE,oBAAoB;oBACnC,cAAc,EAAE,IAAI;oBACpB,eAAe,EAAE,mBAAmB;iBACrC;gBACD,WAAW,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE;gBACtC,UAAU,EAAE,QAAQ;gBACpB,OAAO,EAAE,CAAC;wBACR,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACd,YAAY,EAAE;4BACZ,OAAO,EAAE,IAAI;4BACb,MAAM,EAAE,UAAU;4BAClB,OAAO,EAAE,OAAO;yBACjB;wBACD,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE;qBACvB,CAAC;aACH;SACF,CAAC;IACJ,CAAC;IAEO,QAAQ;QACd,MAAM,KAAK,GAAG,EAAE,CAAC;QACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,KAAK,CAAC,IAAI,CAAC;gBACT,KAAK,EAAE,CAAC,GAAG,CAAC;gBACZ,MAAM,EAAE,SAAS;gBACjB,IAAI,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5E,CAAC,CAAC;QACL,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,SAAS,CAAC,GAAW;QACjC,MAAM,MAAM,GAAG,MAAM,cAAc,CACjC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC,CACpD,CAAC;QACF,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACzC,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,eAAe;QAC1B,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChF,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;QACpC,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAChE,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACI,qBAAqB;QAE1B,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAC/B,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,IAAI,CAAC,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAEnD,yBAAyB;QACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACzC,MAAM,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC9C,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAC;YAAE,OAAO,IAAI,CAAC;QAEpC,MAAM,KAAK,GAAY,KAAK,CAAC,CAAC,CAAC;QAC/B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC5B,IAAI,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAC9B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAE9B,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;YAC3B,qDAAqD;YACrD,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3D,MAAM,IAAI,GAAG,IAAI,iBAAiB,CAAC,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC;YAC9D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC/B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC1B,MAAM,MAAM,GAAG,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,QAAQ,CAAC;oBAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;wBAClC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC9B,CAAC;gBACH,CAAC;YACH,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;QAC3C,CAAC;aAAM,CAAC;YACN,kDAAkD;YAClD,MAAM,IAAI,GAAG,IAAI,iBAAiB,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC;YACnD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC/B,IAAI,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;YACD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC;QAC9C,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACI,sBAAsB;QAC3B,MAAM,EAAE,GAAQ,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC5E,MAAM,EAAE,GAAyB,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC;QAC/D,MAAM,EAAE,GAAyB,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC;QAC/D,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC;YACb,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,uCAAuC;YAC1E,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3F,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QACnC,OAAO;YACL,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YACtB,CAAC,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YACtB,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;YAChD,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC;SAClD,CAAC;IACJ,CAAC;IAEM,KAAK;QACV,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,EAC7B,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,MAAa,CAAC,CAAC;QAC9D,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,SAAS;QACd,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED;sEACkE;IAC3D,eAAe;QACpB,IAAI,CAAC,aAAa,EAAE,CAAC;IACvB,CAAC;IAEM,aAAa;QAClB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAChB,MAAc,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,IAAI,OAAO,EAAE,CAAC,CAAC;QACrG,CAAC;IACH,CAAC;IAEM,SAAS;QACd,IAAI,CAAC,eAAe,GAAG,EAAE,CAAC;QAC1B,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,CAAC;IAEM,WAAW,CAAC,IAAoB;QACrC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAE,IAAe,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7C,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,8FAA8F;QAC9F,kFAAkF;QAClF,uFAAuF;QACvF,0FAA0F;QAC1F,0FAA0F;QAC1F,wEAAwE;QACxE,MAAM,EAAE,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAgD,CAAC;QAChG,IAAI,CAAC,EAAE,EAAE,WAAW;YAAE,OAAO;QAC7B,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAS,CAAC,CAAC;IAC3D,CAAC;IAED;kEAC8D;IACvD,mBAAmB,CAAC,QAAiB;QAC1C,4CAA4C;IAC9C,CAAC;IAED;qFACiF;IAC1E,wBAAwB,CAAC,QAAiB;QAC/C,mDAAmD;IACrD,CAAC;IAEM,MAAM;QACX,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,IAAI,CAAC,EAAE,EAAE,WAAW;YAAE,OAAO;QAC7B,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;QAChC,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;QAChC,4EAA4E;QAC5E,6EAA6E;QAC7E,sCAAsC;QACtC,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE,EAAE,KAAK;YAAE,OAAO;QACrC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QAC7C,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QAC7C,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QACzC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACxC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE;YAC5B,gBAAgB,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE;YAC1C,gBAAgB,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE;SACpC,CAAC,CAAC;IACZ,CAAC;IAED;;;;OAIG;IACI,iBAAiB;QACtB,wEAAwE;QACxE,2EAA2E;QAC3E,iEAAiE;QACjE,MAAM,EAAE,GAAQ,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAE5E,uEAAuE;QACvE,6EAA6E;QAC7E,wBAAwB;QACxB,IAAI,IAAI,CAAC,WAAW,CAAC,uBAAuB,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5D,MAAM,WAAW,GAAW,EAAE,EAAE,WAAW,EAAE,iBAAiB,CAAC;YAC/D,IAAI,WAAW,KAAK,SAAS,IAAI,WAAW,GAAG,CAAC;gBAAE,OAAO;YACzD,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;QAC1D,CAAC;QACD,0EAA0E;QAC1E,2CAA2C;QAC3C,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QAErC,2EAA2E;QAC3E,yEAAyE;QACzE,6BAA6B;QAC7B,IAAI,EAAE,EAAE,WAAW;YAAE,EAAE,CAAC,WAAW,CAAC,iBAAiB,GAAG,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACnD,IAAI,CAAC;YACH,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,EAAS,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE;gBACpE,IAAI,EAAE,EAAE,WAAW;oBAAG,MAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAClD,CAAC,EAAE,GAAG,EAAE,GAA+B,CAAC,CAAC,CAAC;QAC5C,CAAC;QAAC,MAAM,CAAC,CAAC,kCAAkC,CAAC,CAAC;IAChD,CAAC;IAEM,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,IAAI,CAAC,EAAE,EAAE,WAAW;YAAE,OAAO;QAC7B,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;QAChC,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;QAChC,mDAAmD;QACnD,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI,CAAC,EAAE,EAAE,KAAK;YAAE,OAAO;QACrC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QAC7C,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;QAC7C,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QACzC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;QACzC,IAAI,CAAC,eAAe,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QACxC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE;YAC5B,gBAAgB,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE;YAC1C,gBAAgB,EAAE,EAAE,EAAE,gBAAgB,EAAE,EAAE;SACpC,CAAC,CAAC;IACZ,CAAC;IAEM,eAAe;QACpB,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC;IAC3C,CAAC;IACM,eAAe,CAAC,YAAqB;QAC1C,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IACxC,CAAC;IACM,wBAAwB;QAC7B,OAAO,IAAI,CAAC,qBAAqB,CAAC,YAAY,EAAE,CAAC;IACnD,CAAC;IAED,sEAAsE;IACtE,yEAAyE;IACzE,0BAA0B;IAC1B,kBAAkB;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;IACzC,CAAC;IACD,WAAW,CAAC,QAAa;QACvB,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QACjC,IAAI,CAAC;YACH,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,YAAY,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACxE,CAAC;QAAC,MAAM,CAAC,CAAC,kEAAkE,CAAC,CAAC;IAChF,CAAC;IACD,WAAW;QACT,OAAO,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IAClC,CAAC;IAED,eAAe,CAAC,UAAe;QAC7B,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QACvC,IAAI,CAAC;YACH,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,CAAC,CAAC;QAC/D,CAAC;QAAC,MAAM,CAAC,CAAC,kEAAkE,CAAC,CAAC;IAChF,CAAC;IAED,eAAe;QACb,OAAO,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,CAAC;IACtC,CAAC;IAED,YAAY,CAAC,SAA2B;QACtC,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;IACnC,CAAC;IAED,YAAY,CAAC,SAAkB;QAC7B,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtB,CAAC;QACD,IAAI,IAAI,CAAC,SAAS;YAAE,IAAI,CAAC,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC;QACzD,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACnC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,WAAW,EAAE,SAAS,EAAS,CAAC,CAAC;IACnE,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,CAAC;IAC5C,CAAC;IAED,oBAAoB;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,wBAAwB;QACtB,OAAO,IAAI,CAAC,WAAW,CAAC,wBAAwB,EAAE,CAAC;IACrD,CAAC;IAED;;;;;;OAMG;IACI,uBAAuB,CAAC,OAAiB;QAC9C,MAAM,KAAK,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;aAC1B,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACvE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;QAC/B,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;gBAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;gBAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAAC,CAAC;QACrD,CAAC;QACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtD,IAAI,EAAE,EAAE,WAAW,EAAE,CAAC;gBACpB,EAAE,CAAC,WAAW,CAAC,iBAAiB,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACzF,IAAI,CAAC;oBAAE,MAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAAC,CAAC;gBAAC,MAAM,CAAC,CAAC,mBAAmB,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;QACD,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACI,YAAY,CAAC,MAAc;QAChC,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QACtC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,EAAE,EAAE,CAAC,CAAC;YAC5D,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtD,IAAI,EAAE,EAAE,WAAW,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC;gBAChC,EAAE,CAAC,WAAW,CAAC,iBAAiB,GAAG,GAAG,CAAC;gBACvC,IAAI,CAAC;oBAAE,MAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAAC,CAAC;gBAAC,MAAM,CAAC,CAAC,mBAAmB,CAAC,CAAC;YACnE,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,yBAAyB;QAC/B,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,EAAE,GAAQ,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtD,MAAM,GAAG,GAAG,EAAE,EAAE,WAAW,EAAE,iBAAiB,CAAC;QAC/C,MAAM,GAAG,GAAG,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACzF,IAAI,CAAC,WAAW,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAClE,CAAC;IACD,SAAS,CAAC,MAAc;QACtB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3B,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IACD,YAAY;QACV,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IACzC,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,uBAAuB,EAAE,CAAC;IAC9C,CAAC;IAED,sBAAsB,CAAC,KAAa,EAAE,KAAa;QACjD,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACH,WAAW;QACT,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;YACjC,IAAI,CAAC,uBAAuB,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC;QACD,IAAI,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC9B,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,CAAC;QAC1C,CAAC;QACD,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAClC,IAAI,CAAC,wBAAwB,CAAC,WAAW,EAAE,CAAC;QAC9C,CAAC;QACD,IAAI,IAAI,CAAC,0BAA0B,EAAE,CAAC;YACpC,IAAI,CAAC,0BAA0B,CAAC,WAAW,EAAE,CAAC;QAChD,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;QAChC,CAAC;IACH,CAAC;IAED;4EACwE;IAChE,mBAAmB,CAAC,QAAe,EAAE,GAAY,EAAE,GAAY;QACrE,IAAI,CAAC,IAAI,CAAC,OAAO;YAAE,OAAO;QAC1B,MAAM,EAAE,GAAG,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;QACzB,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,EAAE,EAAE,IAAI,EAAE,KAAK,CAAC;QAC7D,qEAAqE;QACrE,MAAM,MAAM,GAAQ,EAAE,YAAY,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC;QAClD,IAAI,UAAU,IAAI,IAAI;YAAE,MAAM,CAAC,UAAU,GAAG,UAAU,CAAC,CAAC,wBAAwB;QAChF,IAAI,EAAE,EAAE,CAAC;YACP,wFAAwF;YACxF,MAAM,MAAM,GACV,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,UAAU;gBACrC,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,OAAO;gBAClC,IAAI,CAAC,QAAQ,KAAK,QAAQ,CAAC,SAAS,CAAC;YACvC,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,CAAC;gBACrB,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,CAAC;gBACrB,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;YACvB,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,CAAC;gBACrB,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC,GAAG,CAAC;gBACrB,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;YACvB,CAAC;QACH,CAAC;QACD,IAAI,CAAC;YACH,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QACvC,CAAC;QAAC,MAAM,CAAC;YACP,oDAAoD;QACtD,CAAC;IACH,CAAC;IAED;8EAC0E;IAC1E,YAAY,CAAC,YAAoB,EAAE,KAAa;QAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,MAAM;YAAE,OAAO,IAAI,CAAC;QACjC,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC;QAC3D,IAAI,CAAC,KAAK,EAAE,MAAM;YAAE,OAAO,IAAI,CAAC;QAChC,MAAM,MAAM,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACtC,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;YACxB,IAAI,CAAC,GAAG;gBAAE,SAAS;YACnB,KAAK,MAAM,IAAI,IAAI,GAAG,EAAE,CAAC;gBACvB,IAAI,CAAS,CAAC;gBACd,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;oBACxB,CAAC,GAAG,YAAY,IAAI,CAAC,IAAI,YAAY,GAAG,IAAI,CAAC,MAAM;wBACjD,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC;wBACpB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5D,CAAC;qBAAM,CAAC;oBACN,CAAC,GAAG,IAAI,CAAC;gBACX,CAAC;gBACD,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACV,IAAI,CAAC,GAAG,CAAC;oBAAE,CAAC,GAAG,CAAC,CAAC;qBAAM,IAAI,CAAC,GAAG,GAAG;oBAAE,CAAC,GAAG,GAAG,CAAC;gBAC5C,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;YACd,CAAC;QACH,CAAC;QACD,OAAO,YAAY,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAED;;+EAE2E;IAC3E,aAAa,CAAC,YAAoB,EAAE,IAAY;QAC9C,OAAO,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC;IACnD,CAAC;IAED;sFACkF;IAClF,UAAU;QACR,OAAO,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;IACxF,CAAC;IAED,aAAa,CAAC,UAAkB;QAC9B,OAAO,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAC9D,CAAC;IAED,aAAa,CAAC,OAAiB;QAC7B,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QACnE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC3D,CAAC;IAED,gBAAgB,CAAC,OAAiB;QAChC,OAAO,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;IACzD,CAAC;IAED,uBAAuB;QACrB,OAAO,IAAI,CAAC,wBAAwB,EAAE,CAAC;IACzC,CAAC;IAED,cAAc;QACZ,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC;IAChC,CAAC;8GAvqEU,aAAa,kBAuIJ,gBAAgB,aAChB,gBAAgB,sQAQJ,cAAc;kHAhJnC,aAAa,cAFZ,MAAM;;2FAEP,aAAa;kBAHzB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAwIc,MAAM;2BAAC,gBAAgB;;0BACvB,MAAM;2BAAC,gBAAgB;;0BAQvB,QAAQ;;0BAAI,MAAM;2BAAC,cAAc","sourcesContent":["import { Injectable, Inject, Optional } from '@angular/core';\n\nimport * as Plotly from 'plotly.js-dist-min';\nimport { Image } from 'image-js';\nimport { HttpClient } from '@angular/common/http';\nimport { firstValueFrom } from 'rxjs';\n\nimport { Polygon, Rectangle, Region } from '../../models/region';\nimport { Buffer } from 'buffer';\nimport { IImageInfo, IImageMetadata } from '../../contracts/image.contract';\nimport { TileAccessPort, TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';\nimport { ImageStatePort, IMAGE_STATE_PORT } from '../../contracts/ports/image-state.port';\nimport { BehaviorSubject, EMPTY, Observable, Subject, Subscription, combineLatest, of } from 'rxjs';\nimport { MessageService } from 'primeng/api';\nimport { ShapeSelection } from '../../models/shape';\nimport { CONFIG, CONFIG_SURFACE, PlotUtilities } from '../../plot.utilities';\nimport { WandService, WandOptions } from '../../toolbar/wand/wand.service';\nimport { CachedImageData, WandToolService, WandToolHost } from '../../toolbar/wand/wand-tool.service';\nimport { BrushToolService, BrushOptions } from '../../toolbar/brush/brush-tool.service';\nimport { SamToolService } from '../../toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';\nimport { ICellSegmenter, CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';\nimport { VertexEraserToolService, VertexEraserToolHost } from '../../toolbar/vertex-eraser/vertex-eraser-tool.service';\nimport { ZoomToBoxToolService } from '../../toolbar/zoom-to-box/zoom-to-box-tool.service';\nimport {\n  parseSvgPathPolygon,\n  verticesToSvgPath,\n} from '../../models/geometry';\nimport { PlotType, PLOT_TYPE_DESCRIPTORS, PlotTypeDescriptor } from '../../contracts/plot-type';\nimport {\n  PLOTLY_PLOT_TYPE_IMPLS,\n  PlotlyPlotTypeImpl,\n  TraceBuildInput,\n} from './plotly-trace-builders';\nimport { IVisualizer, IntensityProfile, IIsosurfaceControls, IIntensityControls } from '../../contracts/visualizer.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { bt601Luminance, histogram256 } from '../../contracts/intensity';\nimport { ViewerCapabilities, ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.contract';\nimport { IRegionOverlay } from '../../contracts/region-overlay.contract';\nimport { PlotlyRegionOverlay } from './plotly-region-overlay';\nimport { ICoordinateTransform } from '../../contracts/coordinate-transform.contract';\nimport { PlotlyCoordinateTransform } from './plotly-coordinate-transform';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { RegionStore } from '../../store/region-store.service';\nimport { VIZ_ALERT_TOAST_KEY } from '../../toast-outlets';\n\n// Re-exported so existing consumers can keep importing PlotType from this\n// module while it physically lives in the backend-neutral contracts/ dir.\n// TODO(plotting-abstraction): once all consumers import from\n// './contracts/plot-type' directly, drop this re-export.\nexport { PlotType } from '../../contracts/plot-type';\n\n\n(window as any).Buffer = Buffer;\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PlotlyService implements IVisualizer {\n\n  /**\n   * Plotly is the full-featured data backend: it supports every feature,\n   * including 3D scenes, live scalar colormaps, pixel readback and the\n   * server-side high-def zoom re-fetch. (OpenSeadragon's stub advertises only\n   * image display.)\n   */\n  readonly capabilities: ViewerCapabilities = capabilitiesOf([\n    ViewerFeature.ImageDisplay,\n    ViewerFeature.Surface3D,\n    ViewerFeature.ScalarColormap,\n    ViewerFeature.PixelReadback,\n    ViewerFeature.HighDefZoom,\n    ViewerFeature.StackSlider,\n    ViewerFeature.Isosurface,\n  ]);\n\n  private shapes: any[] = [];\n  private previousShapes: ShapeSelection[] = [];\n  private isRegionSavedOn = true;\n  private imageLength!: number;\n  private screenHeight!: number;\n  private plotDiv!: string;\n  private isRealZoom = true;\n  private scaleratio = true;\n  private trueImgSize!: number[];\n  private zoomCoordinates: number[] = [];\n  private fileName!: string | undefined;\n\n  private dragMode!: string;\n  // Region data (the list + per-image cache), selection, id minting, the region\n  // update event and the shape colour/label prefs now live in the shared\n  // RegionStore (injected as `this.regionStore`) — the single source of truth\n  // both backends delegate to. `this.shapes` below is kept as Plotly's *render\n  // projection* of those regions (the dict array Plotly.relayout consumes) and\n  // is mirrored into the store on every write. Colormap, reverse-scale, image\n  // metadata and classification colours live in the shared VisualizerStore\n  // (injected as `this.store`).\n  private urls!: string[];\n  /**\n   * The image currently plotted.\n   *\n   * The `!` is a definite-assignment ASSERTION, not a guarantee: nothing sets this until\n   * an image loads, and a host can clear its image while these paths still run — a\n   * spatial-omics dataset that brings no tissue section does exactly that. So reads here\n   * are optional and assignments guarded; an unguarded one threw\n   * \"can't access property isGrayscale\" and aborted the load.\n   */\n  imageInfo!: IImageInfo;\n  private plotUtilities = new PlotUtilities();\n  private plotType!: PlotType;\n\n  private onPlotMouseDown: (() => void) | null = null;\n\n  // The per-image region cache (regionsByImageKey/currentImageKey) now lives in\n  // the shared RegionStore; setActiveImage() delegates to it and re-projects\n  // `this.shapes` from the store afterwards.\n\n  /** Pixel data cached for wand sampling. data[zIndex] is a 2-D matrix. */\n  private cachedImageFrames?: any[];\n  private cachedImageWidth = 0;\n  private cachedImageHeight = 0;\n  private cachedImageRatios: number[] = [1, 1];\n  private cachedIsGrayscale = false;\n  /** Data-space coordinate of the cached frame's pixel (0,0). [0,0] for the full\n   *  image; a crop's top-left when zoomed (so the intensity profile samples the\n   *  zoom-level pixels at the right offset/resolution). */\n  private cachedFrameOrigin: [number, number] = [0, 0];\n  /** Last visible image-pixel rectangle from the active backend's viewport (set by\n   *  the OSD viewport-change hook via refreshIntensitySamplingForRoi). New profile lines are\n   *  placed within it so they land on-screen when zoomed in; null → use full image. */\n  private lastVisibleRoi: { x: number; y: number; width: number; height: number } | null = null;\n\n  /** events */\n  private onRelayoutEvent: any;\n\n  private stackLoading$ = new BehaviorSubject<boolean>(false);\n  private stackLoadingProgress$ = new BehaviorSubject<number>(0);\n  // current index of image in stack (if stack), 0 if single image\n  private zIndex = new BehaviorSubject<number>(0);\n  private autoscaleEvent = new Subject<any>();\n  // The region update event and selection stream are owned by the shared\n  // RegionStore; getRegionUpdateEvent()/getSelectedShapeIndices$() delegate to\n  // it so every consumer (and the OSD backend) sees one stream.\n  /** Bright, well-separated colours cycled as the user adds profile-line ROIs.\n   *  The matching inset trace is drawn in the same colour. */\n  private readonly PROFILE_PALETTE = [\n    '#FFD400', // yellow\n    '#00E5FF', // cyan\n    '#FF2D95', // magenta\n    '#39FF14', // green\n    '#FF9500', // orange\n    '#7C4DFF', // violet\n    '#FF3B30', // red\n    '#18FFFF', // aqua\n  ];\n  /** Palette cursor for profile lines (never reset on delete, so colours keep\n   *  cycling across the session). */\n  private profileColorSeq = 0;\n  private intensityProfile$ = new Subject<IntensityProfile[]>();\n  /** ISOSURFACE band as a 0–255 slider position, mapped onto the volume's real\n   *  intensity range at render time (see mapIsoBand). Defaults to the full range\n   *  so the first render shows the whole structure regardless of how bright or\n   *  dark the volume is; the user then narrows the band to isolate intensities. */\n  private isoMin = 0;\n  private isoMax = 255;\n  /** Actual intensity range of the volume on screen ([min,max] over the loaded\n   *  frames). The slider spans 0–255, but a given stack often occupies only a\n   *  sub-range, so we clamp the iso band into this range (with a small margin)\n   *  to guarantee non-degenerate surfaces — both on first render and on live\n   *  slider moves. Null until an isosurface volume has been measured. */\n  private isoDataRange: [number, number] | null = null;\n  // Id minting and the selection index stream are owned by the shared\n  // RegionStore. Selection still drives Plotly's `_activeShapeIndex` (so a\n  // single shape gets the edit handles) — see setSelectedShapeIndices().\n  private imageCached = false;\n  private imageCachedSubscription: Subscription;\n  private filenameSubscription: Subscription;\n  /** Drives the intensity inset off region adds/drags/deletes (both backends). */\n  private regionUpdateSubscription?: Subscription;\n  /** Live (per-frame, non-coalesced) region edits — so the inset tracks an OSD\n   *  line ROI live during a drag (OSD batches regionUpdate$ until release). */\n  private regionLiveEditSubscription?: Subscription;\n  private channelSub?: Subscription;\n\n  private wandHost!: WandToolHost;\n  private eraserHost!: VertexEraserToolHost;\n  /** This backend's region renderer (lazily created in getRegionOverlay). */\n  private regionOverlay?: IRegionOverlay;\n  private readonly coordinateTransform: ICoordinateTransform =\n    new PlotlyCoordinateTransform(\n      () => document.getElementById(this.plotDiv),\n      () => this.getOverlayContainer());\n\n  constructor(@Inject(TILE_ACCESS_PORT) private tiles: TileAccessPort,\n              @Inject(IMAGE_STATE_PORT) private state: ImageStatePort,\n              public messageService: MessageService, private http: HttpClient,\n              private wandService: WandService,\n              private wandTool: WandToolService,\n              private brushTool: BrushToolService,\n              private samTool: SamToolService,\n              private samPointTool: SamPointToolService,\n              private cellSegmentTool: CellSegmentToolService,\n              @Optional() @Inject(CELL_SEGMENTER) private cellSegmenter: ICellSegmenter | null,\n              private vertexEraserTool: VertexEraserToolService,\n              private zoomToBoxTool: ZoomToBoxToolService,\n              private store: VisualizerStore,\n              private regionStore: RegionStore) {\n    // relayout event router\n    this.onRelayoutEvent = (event: any) => { this.relayoutEventHandler(event); };\n\n    // Tool services read/mutate our state via small *Host interfaces. Stored\n    // so we can re-bind them to ourselves whenever a Plotly tool is activated\n    // (the OpenSeadragon backend re-binds the same singleton tools to itself).\n    this.wandHost = {\n      getRegions: () => this.regionStore.getRegions(),\n      setRegions: (regions) => this.setRegions(regions),\n      getCachedImageData: () => this.getCachedImageData(),\n      getActiveFrameIndex: () => this.activeFrameIndex(),\n      getOverlayContainer: () => this.getOverlayContainer(),\n      getCoordinateTransform: () => this.getCoordinateTransform(),\n      getFileName: () => this.fileName,\n      getShapeColor: () => this.regionStore.getShapeColor(),\n    };\n    this.eraserHost = {\n      getRegions: () => this.regionStore.getRegions(),\n      setRegions: (regions) => this.setRegions(regions),\n      invalidateWandRegion: () => this.wandTool.clearActiveRegion(),\n      getOverlayContainer: () => this.getOverlayContainer(),\n      getCoordinateTransform: () => this.getCoordinateTransform(),\n      getCachedImageRatio: () => this.cachedImageRatios[0] || 1,\n    };\n    this.wandTool.bindHost(this.wandHost);\n    // The brush reuses the wand host (same coordinate frame + region access).\n    this.brushTool.bindHost(this.wandHost);\n    this.vertexEraserTool.bindHost(this.eraserHost);\n    this.bindZoomToBoxHost();\n\n    this.imageCachedSubscription = this.state.isImageCached$().subscribe(imageCached => {\n      this.imageCached = imageCached;\n    });\n    this.filenameSubscription = this.state.getFilename$().subscribe(filename => {\n      this.fileName = filename;\n    });\n    // Live recolor from the Channels & Histogram pane: restyle the display window (zmin/zmax for\n    // a heatmap, cmin/cmax for isosurface/surface), the colorscale (colormap), and reverse/invert\n    // when the channel state OR the colormap changes. (Gamma is applied by the OSD image view; the\n    // Plotly colorscale window covers the common contrast case.)\n    this.channelSub = combineLatest([\n      this.store.getChannelStates(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getColormap(),\n    ]).subscribe(([channels, rev, inv]) => this.applyChannelDisplay(channels, rev, inv));\n    // Profile lines are store regions; any region change (add/drag/delete, on\n    // either backend) should refresh the inset traces. The live-edit stream\n    // fires per frame during a drag (OSD coalesces regionUpdate$ until release),\n    // so the inset tracks an OSD line ROI live as it's moved.\n    this.regionUpdateSubscription = this.regionStore.getRegionUpdateEvent().subscribe(() => {\n      this.emitProfiles();\n    });\n    this.regionLiveEditSubscription = this.regionStore.getRegionLiveEdit$().subscribe(() => {\n      this.emitProfiles();\n    });\n  }\n\n  getTrueImageSize(): { width: number; height: number } | null {\n     if (!this.trueImgSize) return null;\n     return {\n       width: this.trueImgSize[1] - this.trueImgSize[0],\n       height: this.trueImgSize[3] - this.trueImgSize[2],\n     };\n  }\n\n  /**\n   * Load image\n   * @param imageInfo\n   * @param zIndex index of the image to load\n   * @return an object with data and ratio keys\n   */\n  public async load(imageInfo: IImageInfo, zIndex: number) {\n    const urls = imageInfo.urls;\n    // use zIndex provided if any, 0 otherwise\n    let imageUrl;\n    if (zIndex) {\n      imageUrl = urls[zIndex];\n    } else {\n      imageUrl = urls[0];\n    }\n    const isGrayscale = imageInfo.isGrayscale;\n    const image = await this.loadImage(imageUrl);\n    const xRatio = imageInfo.trueImageSize[0] / image.width;\n    const yRatio = imageInfo.trueImageSize[1] / image.height;\n\n    const trueImageSize = [];\n    // [x0, x1, y0, y1]\n    trueImageSize[0] = 0;\n    trueImageSize[1] = imageInfo.trueImageSize[0];\n    trueImageSize[2] = 0;\n    trueImageSize[3] = imageInfo.trueImageSize[1];\n    this.trueImgSize = trueImageSize;\n    this.fileName = imageInfo.fileName;\n    if (imageInfo.isStack && imageInfo.showStack) {\n      const images: any[] = [];\n      this.stackLoadingProgress$.next(0);\n      // One URL per slice — load them all (earlier `length-1` dropped the last).\n      for (let i = 0; i < urls.length; i++) {\n        console.log(`image stack ${i}`);\n        // do not keep with loading if filename is different (a new file has been selected)\n        // or if the stackLoading value is set to false\n        if (this.fileName === imageInfo.fileName && this.stackLoading$.value) {\n          const image = await this.loadImage(urls[i]);\n          if (isGrayscale) {\n            const grey = image.grey();\n            const imgData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);\n            images.push(imgData);\n          } else {\n            const rgbData = image.getPixelsArray();\n            const rgbMatrix = this.plotUtilities.arrayToMatrix(rgbData, image.width);\n            images.push(rgbMatrix);\n          }\n          this.stackLoadingProgress$.next(Math.round((i * 100) / urls.length));\n        } else {\n          // break stack loading\n          break;\n        }\n      }\n      // reset stackLoading progress to 0\n      this.stackLoadingProgress$.next(0);\n      return { data: images, ratios: [xRatio, yRatio],\n               sizes: [image.width, image.height],\n               filename: imageInfo.fileName };\n    } else {\n      let imageData;\n      if (isGrayscale) {\n        const grey = image.grey();\n        imageData = this.plotUtilities.arrayToMatrix(Array.from(grey.data), image.width);\n      } else {\n        const rgbData = image.getPixelsArray();\n        imageData = this.plotUtilities.arrayToMatrix(rgbData, image.width);\n      }\n      return { data: [imageData],\n        ratios: [xRatio, yRatio],\n        sizes: [image.width, image.height],\n        filename: imageInfo.fileName };\n    }\n  }\n\n  /**\n   *\n   * @param plotDiv\n   * @param imageLoaded object with data, ratios and sizes key\n   * @param imageInfo ImageInfo object\n   * @param screenHeight size of the available screen height\n   * @param plotType type of plotting\n   */\n  /**\n   * @param inPlace when true, updates the existing plot via Plotly.react\n   *   instead of Plotly.purge + Plotly.newPlot. Used by the multi-tier\n   *   diagram swap (small → large) so the canvas doesn't briefly blank\n   *   between phases.\n   */\n  public plot(plotDiv: string, imageLoaded: any, imageInfo: IImageInfo, screenHeight: number,\n              plotType: PlotType, inPlace: boolean = false) {\n    const trueImageSize: number[] = [];\n    this.zoomCoordinates = [];\n    // [x0, x1, y0, y1]\n    trueImageSize[0] = 0;\n    trueImageSize[1] = imageInfo.trueImageSize[0];\n    trueImageSize[2] = 0;\n    trueImageSize[3] = imageInfo.trueImageSize[1];\n    // Save the current image's regions and pull in any cached regions for the\n    // image we're about to display, before Plotly.newPlot reads `this.shapes`.\n    this.setActiveImage(imageInfo);\n    this.imageInfo = imageInfo;\n    this.plotType = plotType;\n    // Cache pixel matrices so the wand tool can sample them.\n    this.cachedImageFrames = imageLoaded.data;\n    this.cachedImageWidth = imageLoaded.sizes[0];\n    this.cachedImageHeight = imageLoaded.sizes[1];\n    this.cachedImageRatios = imageLoaded.ratios;\n    this.cachedFrameOrigin = [0, 0]; // full image — reset any prior zoom-crop origin\n    this.cachedIsGrayscale = !!imageInfo.isGrayscale;\n\n    // Pluggable plot types (contour, scatter, scatter3d, isosurface) render\n    // through the trace-builder registry. The original HEATMAP/SURFACE/RGB-image\n    // renderers keep their dedicated paths below (also reused by the high-def\n    // zoom re-fetch). Intensity profiles are no longer a plot type — they're\n    // Region-based line ROIs, available in HEATMAP/IMAGE mode.\n    const impl = PLOTLY_PLOT_TYPE_IMPLS[plotType];\n    if (impl) {\n      // Guarded: `imageInfo` is declared with a definite-assignment assertion, so\n      // nothing stops it being unset at runtime — a plot driven while no image is\n      // loaded reached here and threw on the assignment.\n      if (this.imageInfo) this.imageInfo.isGrayscale = !!imageInfo.isGrayscale;\n      return this.plotViaRegistry(\n        plotDiv, impl, this.buildTraceInput(imageInfo, imageLoaded, trueImageSize),\n        screenHeight, inPlace);\n    }\n\n    if (imageInfo.isGrayscale) {\n      if (plotType === PlotType.SURFACE) {\n        return this.plotSurface(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize,\n          imageLoaded.ratios, screenHeight, inPlace);\n      }\n      return this.plotHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize,\n        imageLoaded.ratios, screenHeight, inPlace);\n    }\n    return this.plotRGBHeatmap(plotDiv, imageInfo.urls, imageLoaded.data, trueImageSize,\n      imageLoaded.ratios, imageLoaded.sizes[0], imageLoaded.sizes[1], screenHeight, inPlace);\n  }\n\n  /**\n   * Function used to plot a grayscale heatmap\n   * @param plotDiv\n   * @param urls\n   * @param images\n   * @param trueImgSize array containing the following : [x0, x1, y0, y1]\n   * @param ratios\n   * @param screenHeight\n   * @return Promise true when plotting is finished\n   */\n  private plotHeatmap(plotDiv: string, urls: string[], images: any[], trueImgSize: number[],\n                     ratios: number[], screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = images.length;\n    this.urls = urls;\n    this.screenHeight = screenHeight;\n    // plot\n    const traces: { z: any; type: string; name: string; visible: boolean; }[] = [];\n    images.forEach((dataset, index) => {\n      const trace = {\n        x0: trueImgSize[0],\n        dx: ratios[0],\n        y0: trueImgSize[2],\n        dy: ratios[0],\n        z: dataset,\n        type: 'heatmap',\n        // We remove the tooltip annotation for performances reasons\n        // text: dataset.map((row: any[], i: any) => row.map((item, j) => {\n        //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),\n        hoverinfo: 'none',\n        colorscale: this.store.currentColormap().data.value,\n        reversescale: this.store.currentReverseScale(),\n        name: `Slice ${index + 1}`,\n        visible: index === 0\n      };\n      traces.push(trace);\n    });\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any,\n      this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3],\n        trueImgSize[2]]), CONFIG as any).then(() => {\n      // handle the relayout event for zoom / rois and the click event\n      this.setEvents(plotDiv, true, screenHeight);\n      return true;\n    });\n  }\n\n  /**\n   * Function used to plot a grayscale surface\n   * @param plotDiv\n   * @param urls\n   * @param images\n   * @param trueImgSize array containing the following : [x0, x1, y0, y1]\n   * @param ratios\n   * @param screenHeight\n   * @return Promise true when plotting is finished\n   */\n  private plotSurface(plotDiv: string, urls: string[], images: any[], trueImgSize: number[],\n                      ratios: number[], screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = images.length;\n    this.urls = urls;\n    this.screenHeight = screenHeight;\n    // plot\n    const traces: { z: any; type: string;  }[] = [];\n    images.forEach((dataset, index) => {\n      const trace = {\n        z: dataset,\n        type: 'surface',\n        // hoverinfo: 'none',\n        colorscale: this.store.currentColormap().data.value,\n        reversescale: this.store.currentReverseScale(),\n        // name: `Slice ${index + 1}`,\n        // visible: index === 0\n      };\n      traces.push(trace);\n    });\n    const xrange = [trueImgSize[0], trueImgSize[1]];\n    const yrange = [trueImgSize[2], trueImgSize[3]];\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any,\n      this.getSurfaceLayout(xrange, yrange, 0.4), CONFIG_SURFACE as any).then(() => {\n      // handle the relayout event for zoom / rois and the click event\n      this.setEvents(plotDiv, true, screenHeight);\n      return true;\n    });\n  }\n\n  /**\n   * Function used to plot an RGB heatmap\n   * @param plotDiv\n   * @param urls\n   * @param images\n   * @param trueImgSize\n   * @param width\n   * @param height\n   * @param ratios\n   * @param screenHeight\n   * @return Promise\n   */\n  private plotRGBHeatmap(plotDiv: string, urls: string[], images: any[], trueImgSize: number[],\n                         ratios: number[], width: number, height: number,\n                         screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    // Plotly.react updates in place; Plotly.purge + Plotly.newPlot blanks\n    // the canvas for ~100ms which makes the multi-tier small→large swap\n    // look like a regression to \"loading\" before the sharper version\n    // appears.\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = images.length;\n    this.urls = urls;\n    this.screenHeight = screenHeight;\n\n    // as autorange is set to false, and not reversed we need to set the yrange correcly here\n    const layout = this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]],\n      [trueImgSize[3], trueImgSize[2]]);\n    const traces: { z: any; type: string; name: string; visible: boolean; }[] = [];\n    images.forEach((dataset, index) => {\n      const trace = {\n        x0: trueImgSize[0],\n        dx: ratios[0],\n        y0: trueImgSize[2],\n        dy: ratios[0],\n        x: Array.from(Array(width).keys()),\n        y: Array.from(Array(height).keys()),\n        z: dataset,\n        // text: dataset.map((row: any[], i: any) => row.map((item, j) => {\n        //   return `x: ${+(j * ratios[0]).toFixed(2)}<br>y: ${+(i * ratios[0]).toFixed(2)}<br>value: ${item}`})),\n        hoverinfo: 'none',\n        type: 'image',\n        name: `Slice ${index + 1}`,\n        visible: index === 0\n      };\n      traces.push(trace);\n    });\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any, layout, CONFIG as any).then(() => {\n      // handle the relayout event\n      this.setEvents(plotDiv, false, screenHeight);\n      return true;\n    });\n  }\n\n  /**\n   * Assemble the normalised input the pluggable trace builders consume.\n   * Pure data only — no Plotly handles — so the builders stay backend-neutral.\n   */\n  private buildTraceInput(imageInfo: IImageInfo, imageLoaded: any,\n                          trueImageSize: number[]): TraceBuildInput {\n    // Measure the volume's real intensity range so the iso band can be clamped\n    // into it (the slider is a fixed 0–255 but a stack may occupy only part of\n    // that, which would otherwise leave the surfaces with nothing to cross).\n    if (this.plotType === PlotType.ISOSURFACE) {\n      this.isoDataRange = this.measureIntensityRange(imageLoaded.data, !!imageInfo.isGrayscale);\n    }\n    const [isoMin, isoMax] = this.mapIsoBand(this.isoMin, this.isoMax);\n    return {\n      frames: imageLoaded.data,\n      width: imageLoaded.sizes[0],\n      height: imageLoaded.sizes[1],\n      ratios: imageLoaded.ratios,\n      trueImageSize,\n      isGrayscale: !!imageInfo.isGrayscale,\n      colorscale: this.store.currentColormap().data.value,\n      reversescale: this.store.currentReverseScale(),\n      regions: this.getRegionPolygons(),\n      shapeColor: this.regionStore.getShapeColor(),\n      isoMin,\n      isoMax,\n    };\n  }\n\n  /** Min/max intensity over every voxel of the loaded frames (RGB → luminance),\n   *  used to keep the iso band inside the data. Returns null for empty input. */\n  private measureIntensityRange(frames: any[], isGrayscale: boolean): [number, number] | null {\n    let min = Infinity, max = -Infinity;\n    for (const frame of frames || []) {\n      for (const row of frame || []) {\n        for (const cell of row || []) {\n          const v = isGrayscale ? cell\n            : 0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2];\n          if (!Number.isFinite(v)) continue;\n          if (v < min) min = v;\n          if (v > max) max = v;\n        }\n      }\n    }\n    return (Number.isFinite(min) && Number.isFinite(max) && max > min) ? [min, max] : null;\n  }\n\n  /** Map the 0–255 slider band onto the volume's actual intensity range. The\n   *  slider is fixed 0–255, but a stack often occupies only a narrow sub-range\n   *  (e.g. this EDOF volume is ~2–50 with structure near 6–10). Mapping spreads\n   *  the data across the whole slider so every intensity is easy to reach and\n   *  the band always lands inside the data — a small inset keeps the extreme\n   *  surfaces off the exact data edges, which are degenerate and draw nothing. */\n  private mapIsoBand(isoMin: number, isoMax: number): [number, number] {\n    let lo = Math.min(isoMin, isoMax);\n    let hi = Math.max(isoMin, isoMax);\n    if (this.isoDataRange) {\n      const [vMin, vMax] = this.isoDataRange;\n      const span = vMax - vMin;\n      const pad = 0.03 * span;\n      const usable = span - 2 * pad;\n      const SLIDER_MAX = 255; // toolbar slider domain (isoValueMax)\n      lo = vMin + pad + (lo / SLIDER_MAX) * usable;\n      hi = vMin + pad + (hi / SLIDER_MAX) * usable;\n      if (lo > hi) { const t = lo; lo = hi; hi = t; }\n    }\n    return [lo, hi];\n  }\n\n  /**\n   * Update the isosurface intensity bounds. When isosurface is on screen this\n   * restyles `isomin`/`isomax` in place for a live update (no volume rebuild).\n   * Slider values are mapped onto the volume's real range so the surfaces always\n   * have data to cross (matching the initial render).\n   */\n  public setIsoRange(isoMin: number, isoMax: number): void {\n    this.isoMin = isoMin;\n    this.isoMax = isoMax;\n    if (this.plotType === PlotType.ISOSURFACE && this.plotDiv) {\n      const [lo, hi] = this.mapIsoBand(isoMin, isoMax);\n      try {\n        Plotly.restyle(this.plotDiv, { isomin: [lo], isomax: [hi] } as any);\n      } catch { /* plot not ready */ }\n    }\n  }\n\n  /** Plotly renders isosurfaces, so it exposes the isosurface controls (itself). */\n  public getIsosurfaceControls(): IIsosurfaceControls | null { return this; }\n\n  /**\n   * Render a registry-backed plot type: build its traces from the input, pick\n   * the matching layout, render, and wire the usual relayout/click events.\n   * Mirrors the structure of the dedicated heatmap/surface renderers.\n   */\n  private plotViaRegistry(plotDiv: string, impl: PlotlyPlotTypeImpl, input: TraceBuildInput,\n                          screenHeight: number, inPlace: boolean = false): Promise<boolean> {\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = input.frames.length;\n    this.urls = this.imageInfo?.urls ?? this.urls;\n    this.screenHeight = screenHeight;\n\n    const traces = impl.buildTraces(input);\n    const [x0, x1, y0, y1] = input.trueImageSize;\n    let layout: any;\n    switch (impl.layoutKind) {\n      case '3d-volume':\n        layout = this.getVolumeLayout();\n        break;\n      case '2d-chart':\n        layout = this.getChartLayout();\n        break;\n      case '2d-overlay':\n        layout = this.getOverlayLayout([x0, x1], [y1, y0]); // reversed y like the image\n        break;\n      default: // '2d-image'\n        layout = this.getHeatmapLayout([x0, x1], [y1, y0]);\n    }\n    const config = impl.threeD ? CONFIG_SURFACE : CONFIG;\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any, layout, config as any).then(() => {\n      this.setEvents(plotDiv, input.isGrayscale, screenHeight);\n      return true;\n    });\n  }\n\n  /** Plain 2D chart axes (intensity profile / line plots). */\n  private getChartLayout(): any {\n    return {\n      margin: { t: 30, b: 45, l: 60, r: 20 },\n      height: this.screenHeight,\n      autosize: true,\n      xaxis: { title: 'Position (px)' },\n      yaxis: { title: 'Intensity' },\n      dragmode: false,\n    };\n  }\n\n  /** Image-aligned 2D axes without the z-plane slider (region scatter). */\n  private getOverlayLayout(xRange: number[], yRange: number[]): any {\n    return {\n      xaxis: { constrain: 'range', constraintoward: 'center', side: 'top', ticks: '', range: xRange },\n      yaxis: {\n        constrain: 'range', constraintoward: 'center', range: yRange, ticks: '',\n        ticksuffix: '  ', autorange: false, scaleanchor: this.scaleratio ? 'x' : false,\n      },\n      margin: { t: 30, b: 5, l: 55, r: 5 },\n      height: this.screenHeight,\n      autosize: true,\n      shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),\n      dragmode: this.dragMode ? this.dragMode : false,\n    };\n  }\n\n  /** 3D scene for volumetric plot types (scatter3d, isosurface). */\n  private getVolumeLayout(): any {\n    return {\n      margin: { t: 0, b: 0, l: 0, r: 0 },\n      height: this.screenHeight,\n      autosize: true,\n      scene: {\n        xaxis: { title: 'X' },\n        yaxis: { title: 'Y' },\n        zaxis: { title: 'Z-plane' },\n        // 'cube' (not 'data'): a z-stack has far fewer planes than X/Y pixels,\n        // so 'data' squashes the volume into a near-flat slab that reads as\n        // empty edge-on. A cube gives the z dimension real height so the\n        // isosurface/voxels are actually visible.\n        aspectmode: 'cube',\n      },\n    };\n  }\n\n  /** Plot types this backend advertises (drives the UI selector). */\n  public getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    return Object.values(PLOT_TYPE_DESCRIPTORS).filter((d): d is PlotTypeDescriptor => !!d);\n  }\n\n  /** This backend's region renderer. Plotly draws shapes natively, so the\n   *  overlay is a thin adapter over this service's drag modes. */\n  public getRegionOverlay(): IRegionOverlay {\n    if (!this.regionOverlay) this.regionOverlay = new PlotlyRegionOverlay(this);\n    return this.regionOverlay;\n  }\n\n  // ── Intensity profile (Region-based line ROIs) ──────────────────────\n\n  /** Emits the full set of intensity profiles (one per profile-line region)\n   *  whenever a profile line is added, moved, or removed. */\n  public getIntensityProfile$(): Observable<IntensityProfile[]> {\n    return this.intensityProfile$.asObservable();\n  }\n\n  /** Plotly renders the line ROIs + inset, so it exposes the intensity controls. */\n  public getIntensityControls(): IIntensityControls | null { return this; }\n\n  /**\n   * Render the floating intensity-profile inset chart into `divId` — one line\n   * trace per ROI, each drawn in its ROI's colour. Kept here (not in the diagram\n   * component) so the consumer never touches Plotly directly.\n   */\n  public renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    const el = document.getElementById(divId);\n    if (!el) return;\n    const traces = (profiles ?? []).map((p, i) => ({\n      x: p.positions,\n      y: p.values,\n      type: 'scatter',\n      mode: 'lines',\n      line: { color: p.color ?? '#FFD400', width: 2 },\n      name: `Line ${i + 1}`,\n      hoverinfo: 'x+y',\n    }));\n    // X axis is in microns when the image carries a physical pixel size (mpp),\n    // otherwise in pixels — driven by the unit the sampler tagged on the profile.\n    const unit = (profiles ?? []).find(p => p.unit)?.unit ?? 'px';\n    const xTitle = unit === 'µm' ? 'Position (µm)' : 'Position (px)';\n    Plotly.react(el, traces as any, {\n      margin: { t: 6, r: 8, b: 38, l: 40 },\n      xaxis: { title: xTitle, zeroline: false, color: '#ddd' },\n      yaxis: { title: 'Intensity', zeroline: false, color: '#ddd' },\n      showlegend: false,\n      paper_bgcolor: 'rgba(25,25,25,0.9)',\n      plot_bgcolor: 'rgba(25,25,25,0.9)',\n      font: { color: '#eee', size: 10 },\n    } as any, { displayModeBar: false, responsive: true } as any);\n  }\n\n  /**\n   * Region shapes (filtered/redrawn for the current file). The profile-line ROIs\n   * are ordinary store regions (tagged `kind: 'profile'`), so they are already\n   * part of `this.shapes` — no separate append is needed.\n   */\n  private currentRenderShapes(showLabel = this.regionStore.getShowShapeLabel()): any[] {\n    return this.shapesToRedraw(showLabel);\n  }\n\n  /**\n   * IIntensityControls: add another intensity-profile line as a neutral Region\n   * (tagged `kind: 'profile'`). It is a horizontal open 2-point polyline spanning\n   * the image width, staggered vertically so successive lines stay distinct, in\n   * the next bright palette colour. Added to the shared store so both backends\n   * (Plotly + OpenSeadragon) render and drag it; excluded from the Regions tab\n   * and exports by its kind.\n   */\n  public addProfileLine(): Region | null {\n    if (!this.trueImgSize) return null;\n    const count = this.getProfileRegions().length;\n    const imgX0 = this.trueImgSize[0], imgX1 = this.trueImgSize[1];\n    const imgTop = this.trueImgSize[2], imgBottom = this.trueImgSize[3];\n\n    // Place the line within the currently VISIBLE image area, so when zoomed in it\n    // lands on-screen instead of spanning the whole (mostly off-screen) image, at\n    // 2/3 of the visible width and horizontally centred. Falls back to the full\n    // image when no viewport ROI is known (Plotly heatmap) or a stale ROI no longer\n    // overlaps the image.\n    const roi = this.lastVisibleRoi;\n    const overlaps = !!roi && roi.width > 0 && roi.height > 0\n      && roi.x < imgX1 && roi.x + roi.width > imgX0\n      && roi.y < imgBottom && roi.y + roi.height > imgTop;\n    const x0v = overlaps ? Math.max(imgX0, roi!.x) : imgX0;\n    const x1v = overlaps ? Math.min(imgX1, roi!.x + roi!.width) : imgX1;\n    const topV = overlaps ? Math.max(imgTop, roi!.y) : imgTop;\n    const bottomV = overlaps ? Math.min(imgBottom, roi!.y + roi!.height) : imgBottom;\n\n    const cx = (x0v + x1v) / 2;\n    const half = ((x1v - x0v) * (2 / 3)) / 2; // line spans 2/3 of the visible width\n    const x0 = cx - half, x1 = cx + half;\n\n    const bandH = bottomV - topV;\n    const midY = (topV + bottomV) / 2;\n    // Stagger successive lines across the visible band so they stay distinct.\n    const y = Math.min(bottomV, Math.max(topV, midY + count * bandH * 0.12));\n\n    const poly = new Polygon();\n    poly.npoints = 2;\n    poly.xpoints = [x0, x1];\n    poly.ypoints = [y, y];\n    poly.coordinates = [[x0, y], [x1, y]];\n    poly.closed = false;\n\n    const region = new Region();\n    region.bounds = poly;\n    region.kind = 'profile';\n    region.color = this.PROFILE_PALETTE[this.profileColorSeq++ % this.PROFILE_PALETTE.length];\n    // Leave region.label undefined so applyClassificationColors won't recolor it.\n\n    this.regionStore.addRegion(region);\n\n    // If a Plotly plot is on screen, re-render shapes so the new line appears.\n    // (The OSD overlay renders automatically via its region-update subscription.)\n    if (this.plotDiv) {\n      this.syncShapesFromStore();\n      try {\n        Plotly.relayout(this.plotDiv, { shapes: this.currentRenderShapes() } as any);\n      } catch { /* div not a Plotly plot (OSD owns it) */ }\n    }\n    return region;\n  }\n\n  /** The profile-line ROIs currently in the store (kind === 'profile'). */\n  private getProfileRegions(): Region[] {\n    return this.regionStore.getRegions().filter(r => (r as any).kind === 'profile');\n  }\n\n  /** Recompute and broadcast a profile for every profile-line region (id + colour\n   *  tagged so the inset trace matches its line). */\n  private emitProfiles(): void {\n    this.intensityProfile$.next(this.getProfileRegions().map(r => ({\n      ...this.computeIntensityProfileForRegion(r),\n      id: r.id,\n      color: r.color,\n    })));\n  }\n\n  /**\n   * Sample the intensity profile for a profile-line region: extract its two\n   * polygon endpoints and reuse the shared `computeIntensityProfile` sampling.\n   */\n  private computeIntensityProfileForRegion(region: Region): IntensityProfile {\n    // Duck-typed (not `instanceof Polygon`): after a drag round-trips through the\n    // store the bounds can be a plain object, so match on the point arrays.\n    const poly: any = region.bounds;\n    if (!poly || !Array.isArray(poly.xpoints) || !Array.isArray(poly.ypoints) ||\n        poly.xpoints.length < 2 || poly.ypoints.length < 2) {\n      return { positions: [], values: [] };\n    }\n    return this.computeIntensityProfile({\n      x0: poly.xpoints[0], y0: poly.ypoints[0],\n      x1: poly.xpoints[1], y1: poly.ypoints[1],\n    });\n  }\n\n  /**\n   * Supply pixel frames for intensity sampling (used by the OSD/image backend,\n   * whose cached frames may be empty). Optionally also sets the data/pixel ratios.\n   */\n  public setSamplingFrames(frames: any[], ratios: number[], origin: [number, number] = [0, 0]): void {\n    this.cachedImageFrames = frames;\n    if (ratios) this.cachedImageRatios = ratios;\n    this.cachedFrameOrigin = origin;\n  }\n\n  /**\n   * Populate the sampling cache for the intensity profiles when OpenSeadragon is\n   * the active backend (the Image plot type). In OSD mode Plotly never rendered,\n   * so `cachedImageFrames`/`trueImgSize` are unset — fetch the current slice's\n   * preview (the same pixels the heatmap would sample) so the line ROIs have\n   * pixel data and a placement extent. Re-emits the profiles once loaded.\n   */\n  public async ensureIntensitySampling(imageInfo: IImageInfo, zIndex: number): Promise<void> {\n    if (!imageInfo?.urls?.length) return;\n    // Sample just the displayed slice (showStack off → single frame); `load`\n    // also sets `this.trueImgSize`, which addProfileLine needs for placement.\n    const single = { ...imageInfo, showStack: false } as IImageInfo;\n    const loaded = await this.load(single, zIndex || 0);\n    this.cachedImageFrames = loaded.data;\n    this.cachedImageRatios = loaded.ratios;\n    this.cachedImageWidth = loaded.sizes?.[0] ?? this.cachedImageWidth;\n    this.cachedImageHeight = loaded.sizes?.[1] ?? this.cachedImageHeight;\n    this.cachedFrameOrigin = [0, 0]; // full preview\n    this.cachedIsGrayscale = !!imageInfo.isGrayscale;\n    this.emitProfiles();\n  }\n\n  /**\n   * {@link IIntensitySampling} stub — the viewport-change signal is OpenSeadragon's\n   * (it re-samples on OSD zoom/pan). Plotly's own high-def zoom updates the\n   * sampling cache inline, so it never emits here; returns EMPTY so a uniform\n   * `IVisualizer` consumer can subscribe regardless of the active backend.\n   */\n  public getViewportChange$(): Observable<{ x: number; y: number; width: number; height: number }> {\n    return EMPTY;\n  }\n\n  /**\n   * Re-fetch the given image-pixel ROI at the display resolution and use it as\n   * the intensity-sampling source, so the profile reflects the data at the\n   * current zoom level. Shared by both backends: the OSD viewport-change hook\n   * calls it on zoom/pan; Plotly's own high-def zoom (triggerZoom) updates the\n   * same cache inline. `roi` is in full-image pixel coordinates.\n   */\n  public refreshIntensitySamplingForRoi(x: number, y: number, width: number, height: number,\n                                        zIndex: number): void {\n    if (width <= 0 || height <= 0) return;\n    // Remember the visible region so a new profile line is placed inside it.\n    this.lastVisibleRoi = { x, y, width, height };\n    const roi = new Rectangle();\n    roi.x = Math.round(x); roi.y = Math.round(y);\n    roi.width = Math.round(width); roi.height = Math.round(height);\n    const screen = this.plotUtilities.getDomRectangle('diagram');\n    // Snapshot the filename so a response that arrives after the user switched\n    // files is dropped (the request carried the file selected at call time).\n    const reqName = this.fileName;\n    this.tiles.zoomOnRegion(roi, screen, zIndex || 0).subscribe({\n      next: (zoomData) => {\n        Image.load(Buffer.from(new Uint8Array(zoomData))).then((image: any) => {\n          if (this.fileName !== reqName) return;\n          const isGray = !!this.imageInfo?.isGrayscale;\n          const frame = isGray\n            ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)\n            : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);\n          this.setSamplingFrames([frame], [roi.width / image.width, roi.height / image.height],\n            [roi.x, roi.y]);\n          this.emitProfiles();\n        });\n      },\n      error: () => { /* keep the previous sampling frame on a failed crop fetch */ },\n    });\n  }\n\n  /**\n   * Sample the active frame's intensity (grayscale value or RGB luminance)\n   * along the line ROI. Returns distance-along-line positions and values.\n   */\n  private computeIntensityProfile(line: any): IntensityProfile {\n    const empty: IntensityProfile = { positions: [], values: [] };\n    if (!this.cachedImageFrames?.length || !line) return empty;\n    const frame = this.cachedImageFrames[this.activeFrameIndex()] ?? this.cachedImageFrames[0];\n    if (!frame?.length) return empty;\n    const rx = this.cachedImageRatios[0] || 1;\n    const ry = this.cachedImageRatios[1] || rx;\n    const [ox, oy] = this.cachedFrameOrigin;\n    const x0 = +line.x0, y0 = +line.y0, x1 = +line.x1, y1 = +line.y1;\n    const dxData = x1 - x0, dyData = y1 - y0;\n    // Scale the along-line distance by the physical pixel size (microns/pixel)\n    // when the image carries one — anisotropic mppX/mppY are applied per axis so\n    // diagonal lines measure the true physical length. Falls back to pixels.\n    const { mppX, mppY } = this.currentMpp();\n    const useMicrons = mppX != null;\n    const lenData = useMicrons\n      ? Math.hypot(dxData * mppX, dyData * (mppY ?? mppX))\n      : Math.hypot(dxData, dyData);\n    const lenPx = Math.hypot(dxData / rx, dyData / ry);\n    const n = Math.max(2, Math.round(lenPx));\n    const h = frame.length;\n    const w = frame[0].length;\n    const positions: number[] = [];\n    const values: number[] = [];\n    for (let i = 0; i < n; i++) {\n      const t = i / (n - 1);\n      // Map data coords to the cached frame's pixel grid, offset by the frame's\n      // origin (non-zero when the frame is a zoomed crop).\n      const px = Math.round((x0 + t * dxData - ox) / rx);\n      const py = Math.round((y0 + t * dyData - oy) / ry);\n      let v = 0;\n      if (px >= 0 && px < w && py >= 0 && py < h) {\n        const cell = frame[py][px];\n        v = Array.isArray(cell) ? (0.299 * cell[0] + 0.587 * cell[1] + 0.114 * cell[2]) : cell;\n      }\n      positions.push(t * lenData);\n      values.push(v);\n    }\n    return { positions, values, unit: useMicrons ? 'µm' : 'px' };\n  }\n\n  /** Physical pixel size (microns/pixel) for the current image, if known.\n   *  mpp is constant across frames/channels, so the first metadata entry that\n   *  carries a positive mppX wins. Returns nulls when the image is unscaled. */\n  private currentMpp(): { mppX: number | null; mppY: number | null } {\n    const meta = this.imageInfo?.imageMeta;\n    const m = Array.isArray(meta)\n      ? (meta.find(e => e && (e.mppX ?? 0) > 0) ?? meta[0])\n      : undefined;\n    const mppX = m && (m.mppX ?? 0) > 0 ? (m.mppX as number) : null;\n    const mppY = m && (m.mppY ?? 0) > 0 ? (m.mppY as number) : null;\n    return { mppX, mppY };\n  }\n\n  /**\n   * autoscale the plot\n   */\n  public autoscale() {\n    if (this.plotDiv) {\n      this.zoomCoordinates = [];\n      Plotly.relayout(this.plotDiv, {\n        'xaxis.autorange': true,\n        'yaxis.autorange': false }\n      );\n    }\n  }\n\n  /**\n   * relayout the plot\n   */\n  public relayout(trueImageSize?: number[]) {\n    let imgSize;\n    if (trueImageSize) {\n      imgSize = trueImageSize;\n    } else {\n      imgSize = this.trueImgSize;\n    }\n    if (this.plotDiv) {\n      // Refresh height from current DOM so panel resizes are reflected\n      const plotEl = document.getElementById(this.plotDiv);\n      if (plotEl?.offsetHeight) {\n        this.screenHeight = plotEl.offsetHeight;\n      }\n      try {\n        if (this.zoomCoordinates.length > 0) {\n          Plotly.relayout(this.plotDiv, this.getHeatmapLayout(\n            [this.zoomCoordinates[0], this.zoomCoordinates[1]],\n            [this.zoomCoordinates[2], this.zoomCoordinates[3]]));    // reverse the y range\n        } else {\n          // as autorange is set to false, and not reversed we need to set the yrange correcly here\n          Plotly.relayout(this.plotDiv, this.getHeatmapLayout(\n            [imgSize[0], imgSize[1]], [imgSize[3], imgSize[2]]));\n        }\n      } catch (err: any) {\n        const msg = err?.error?.message || err?.message || err?.statusText || String(err);\n        console.error('Error occured', err);\n        this.messageService.add({ key: VIZ_ALERT_TOAST_KEY, sticky: true, severity:'error', summary:'An error occured', detail:`The following\n                                  error occured: ${msg}. Please try to open the image again through the\n                                  file navigator.` });\n        // TODO correctly clear the plot\n        this.reset();\n      }\n    }\n  }\n\n  private setEvents(plotDiv: string, isGrayscale: boolean, screenHeight: number) {\n    if (this.imageInfo) this.imageInfo.isGrayscale = isGrayscale;\n    this.screenHeight = screenHeight;\n    const plot: any = document.getElementById(plotDiv);\n    if (plot) {\n      // unbind previous event\n      plot.removeEventListener('plotly_relayout', this.onRelayoutEvent);\n      // bind new event\n      plot.on('plotly_relayout', this.onRelayoutEvent);\n\n      // Clicking on a shape activates it but Plotly doesn't fire a dedicated\n      // event — sample _activeShapeIndex on the next microtask so subscribers\n      // (Region Editor) can mirror the selection.\n      plot.removeEventListener('mousedown', this.onPlotMouseDown);\n      this.onPlotMouseDown = () => setTimeout(() => this.maybeEmitActiveShapeIndex(), 0);\n      plot.addEventListener('mousedown', this.onPlotMouseDown);\n    }\n  }\n\n  private relayoutEventHandler(event: any) {\n    if (Object.keys(event).includes('dragmode')) {\n      this.dragMode = event.dragmode;\n    }\n    // when relayout event occurs\n    // update the region selection udpdates\n    const keys = Object.keys(event);\n    let shapesModified = false;\n    keys.forEach((key: any) => {\n      if (typeof key === 'string' && key.startsWith('shapes[')) {\n        const shapeNumber = +key.split('[')[1].split(']')[0];\n        const shapeChange = key.split('.')[1];\n        if (this.shapes && this.shapes[shapeNumber]) {\n          if (shapeChange === 'path') {\n            this.shapes[shapeNumber][shapeChange] = this.plotUtilities.roundPathCoordinates(event[key]);\n          } else {\n            this.shapes[shapeNumber][shapeChange] = Math.round(+event[key]);\n          }\n          shapesModified = true;\n        }\n      }\n    });\n    if (shapesModified) {\n      // Mirror the in-place edit into the shared store (syncs its cache + emits).\n      this.commitShapesToStore();\n    }\n    // manage high def zoom (not if we are showing a stack)\n    if (keys.length === 4 && this.isRealZoom) {\n      const coordinates: any[] = [];\n      keys.forEach(key => {\n        if (key.startsWith('xaxis.range[')) {\n          coordinates.push(event[key]);\n        }\n        if (key.startsWith('yaxis.range[')) {\n          coordinates.push(event[key]);\n        }\n      });\n      this.zoomCoordinates = coordinates;\n      if (!this.imageInfo?.showStack) {\n        this.triggerZoom(coordinates);\n      }\n    }\n    // when shape is created\n    if (keys.length === 1 && 'shapes' in event) {\n      this.shapes = event.shapes as any[];\n      for (let i = 0; i < this.shapes.length; i++) {\n        // A freshly Plotly-drawn shape has no id yet — give it a label object\n        // (when labels are on) before the store mints id + default name.\n        const isNew = this.shapes[i].id == null;\n        this.shapes[i].fileName = this.fileName;\n        this.shapes[i] = this.plotUtilities.snapRegion(this.shapes[i]);\n        if (isNew && this.regionStore.getShowShapeLabel()) {\n          this.shapes[i].label = { text: this.shapes[i].label,\n            texttemplate: this.shapes[i].label,\n            font: { color: this.regionStore.getShapeColor() },\n            textposition: 'top left'\n          };\n        }\n      }\n      // Mint ids/names in the store, write them back onto the dicts, and emit.\n      this.commitShapesToStore();\n      if (this.isRegionSavedOn) {\n        this.previousShapes = this.shapes.slice();\n      }\n    }\n    // if autoscale\n    if (keys.includes('xaxis.autorange') && keys.includes('yaxis.autorange')) {\n      // trigger an autoscale event to reset the selected image mode dropdown\n      this.autoscaleEvent.next('an autoscale has happened');\n      // select display type to trigger a new plotting update with all the necessary plotting parameters set\n      this.tiles.selectDiagramDisplay();\n    }\n    // if showstack or aspectratio event\n    if (event.showstack !== undefined || event.aspectratio !== undefined) {\n      // Set new image info to trigger a plot update\n      this.setImageInfo(event.showstack, event.aspectratio);\n    }\n\n    // Plotly may have updated the active shape index as part of the relayout\n    // (e.g. clicking a shape's edit handle, or finishing a draw) — surface\n    // that change to the Region Editor.\n    this.maybeEmitActiveShapeIndex();\n  }\n\n  public reloadAndPlot() {\n    this.setImageInfo();\n  }\n\n\n  // ── Tool delegations ────────────────────────────────────────────────\n\n  public setWandMode(active: boolean, options: WandOptions = {}) {\n    // Re-bind to ourselves in case the OSD backend last used these singletons.\n    if (active) this.wandTool.bindHost(this.wandHost);\n    this.wandTool.setMode(active, options);\n  }\n\n  public setWandOptions(options: WandOptions) {\n    this.wandTool.setOptions(options);\n  }\n\n  public clearActiveWandRegion() {\n    this.wandTool.clearActiveRegion();\n  }\n\n  public setBrushMode(active: boolean, options: BrushOptions = {}) {\n    // Re-bind to ourselves in case the OSD backend last used this singleton.\n    if (active) this.brushTool.bindHost(this.wandHost);\n    this.brushTool.setMode(active, options);\n  }\n\n  public setBrushOptions(options: BrushOptions) {\n    this.brushTool.setOptions(options);\n  }\n\n  public setVertexEraserMode(active: boolean) {\n    if (active) this.vertexEraserTool.bindHost(this.eraserHost);\n    this.vertexEraserTool.setMode(active);\n  }\n\n  public setVertexEraserRadius(radius: number) {\n    this.vertexEraserTool.setRadius(radius);\n  }\n\n  public setZoomToBoxMode(active: boolean) {\n    // The zoom-to-box tool is a root singleton shared with the OSD backend,\n    // which rebinds it to its own host on activation. Rebind to ours when we\n    // activate so a prior OSD zoom-to-box doesn't leave the singleton pointing\n    // at OSD's coordinate/zoom handlers (which would break box-zoom on heatmaps).\n    if (active) this.bindZoomToBoxHost();\n    this.zoomToBoxTool.setMode(active);\n  }\n\n  /** Bind the shared zoom-to-box tool to this (Plotly) backend's host. */\n  private bindZoomToBoxHost() {\n    this.zoomToBoxTool.bindHost({\n      getPlotDiv: () => this.plotDiv,\n      pixelToData: (px, py) => this.zoomBoxPixelToData(px, py),\n      applyZoomToBox: (coords) => this.applyZoomToBox(coords),\n    });\n  }\n\n  /** Box-prompted SAM: segment the drawn rectangles. The SAM tool reuses the\n   *  wand host (cached frame + coordinate transform + region store). */\n  public segmentRectangles(): Promise<number> {\n    this.samTool.bindHost(this.wandHost);\n    return this.samTool.segmentBoxes();\n  }\n  public segmentRectanglesCellpose(): Promise<number> {\n    if (!this.cellSegmenter) return Promise.resolve(0);\n    this.cellSegmentTool.bindHost(this.wandHost);\n    return this.cellSegmentTool.segmentBoxes(this.cellSegmenter);\n  }\n  public setSamModel(id: string): void {\n    this.samTool.setModel(id);\n    this.samPointTool.setModel(id);\n  }\n  public setSamPointMode(active: boolean): void {\n    if (active) this.samPointTool.bindHost(this.wandHost);\n    this.samPointTool.setMode(active);\n  }\n  public commitSamPoints(): void { this.samPointTool.commit(); }\n  public clearSamPoints(): void { this.samPointTool.clear(); }\n\n  /**\n   * Tool-host callback: apply the zoom-to-box selection. Stack mode does a\n   * pure axis-range relayout; non-stack mode goes through the high-def\n   * triggerZoom pipeline so the image is re-fetched at the new resolution.\n   */\n  /** Overlay-pixel -> Plotly data coords via the axis objects (subtracting the\n   *  plot margin offset). The zoom-to-box tool calls this through its host. */\n  private zoomBoxPixelToData(px: number, py: number): { x: number; y: number } {\n    const gd: any = document.getElementById(this.plotDiv);\n    const xaxis = gd._fullLayout.xaxis;\n    const yaxis = gd._fullLayout.yaxis;\n    return { x: xaxis.p2d(px - xaxis._offset), y: yaxis.p2d(py - yaxis._offset) };\n  }\n\n  private applyZoomToBox(coordinates: number[]) {\n    this.zoomCoordinates = coordinates;\n    if (this.imageInfo?.showStack) {\n      Plotly.relayout(this.plotDiv, {\n        'xaxis.range[0]': coordinates[0],\n        'xaxis.range[1]': coordinates[1],\n        'yaxis.range[0]': coordinates[2],\n        'yaxis.range[1]': coordinates[3],\n      } as any);\n    } else {\n      this.triggerZoom(coordinates);\n    }\n  }\n\n  // ── IViewportHost implementation (for the on-canvas tools) ──────────\n\n  /** The plot element the tool canvas overlays attach to. */\n  public getOverlayContainer(): HTMLElement | null {\n    return this.plotDiv ? document.getElementById(this.plotDiv) : null;\n  }\n\n  /** Plotly coordinate transform (screen <-> data via the axis objects). */\n  public getCoordinateTransform(): ICoordinateTransform {\n    return this.coordinateTransform;\n  }\n\n  // ── WandToolHost implementation ─────────────────────────────────────\n\n  /** Pixel data the wand needs for sampling. null = no image loaded. */\n  private getCachedImageData(): CachedImageData | null {\n    if (!this.cachedImageFrames || this.cachedImageFrames.length === 0) return null;\n    return {\n      frames: this.cachedImageFrames,\n      width: this.cachedImageWidth,\n      height: this.cachedImageHeight,\n      ratios: this.cachedImageRatios,\n      isGrayscale: this.cachedIsGrayscale,\n    };\n  }\n\n  // ── shared-store sync helpers ──────────────────────────────────────────\n  //\n  // `this.shapes` is Plotly's own representation (the dict array Plotly.relayout\n  // consumes). The shared RegionStore is the single source of truth, holding the\n  // neutral Region model. These helpers bridge the two: writes mirror\n  // `this.shapes` INTO the store; image switches/external changes project the\n  // store back OUT to `this.shapes`.\n\n  /** Build Plotly shape dicts from the store's regions (the render projection). */\n  private regionsToShapeDicts(): any[] {\n    const showLabel = this.regionStore.getShowShapeLabel();\n    return this.regionStore.getRegions().map(r => {\n      r.filename = this.fileName;\n      return { ...r.getShape(showLabel) };\n    });\n  }\n\n  /** Rebuild the dict working-set from the store (after an image switch, or when\n   *  regions changed while another backend was rendering). */\n  private syncShapesFromStore(): void {\n    this.shapes = this.regionsToShapeDicts();\n  }\n\n  /**\n   * Make the shared store authoritative for the current dict working-set: convert\n   * `this.shapes` to neutral regions and replace the store's list (the store\n   * mints ids, applies class colours, syncs its per-image cache and emits the\n   * region-update event). Store-minted ids are written back onto the dicts so the\n   * two representations stay aligned. Profile-line ROIs are ordinary regions\n   * (tagged `kind: 'profile'`) and round-trip through here too.\n   */\n  private commitShapesToStore(): void {\n    const regions = this.shapes\n      .map(s => Object.assign(new ShapeSelection(), s).getRegion());\n    this.regionStore.setRegions(regions, this.regionStore.getShowShapeLabel(), true,\n      this.regionStore.getFillColor(), false);\n    const stored = this.regionStore.getRegions();\n    for (let i = 0; i < this.shapes.length && i < stored.length; i++) {\n      if (this.shapes[i].id == null) this.shapes[i].id = stored[i].id;\n      if (this.shapes[i].name == null) this.shapes[i].name = stored[i].name;\n    }\n  }\n\n  /**\n   * Push the current `this.shapes` to Plotly, mirror them into the shared store\n   * (which syncs its cache + emits the region-update event), and refresh the\n   * local previous-shapes buffer. The wand/eraser tools call this after mutating\n   * the shapes array directly.\n   */\n  public applyShapesChange() {\n    if (this.isRegionSavedOn) {\n      this.previousShapes = this.shapes.slice();\n    }\n    this.commitShapesToStore();\n    if (this.plotDiv) {\n      const dictArray = this.shapes.map(s => ({ ...s }));\n      try {\n        Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray) as any);\n      } catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }\n    }\n  }\n\n  /** Active frame index in the cached image stack. */\n  private activeFrameIndex(): number {\n    if (!this.cachedImageFrames || this.cachedImageFrames.length <= 1) return 0;\n    const gd: any = document.getElementById(this.plotDiv);\n    const sliderActive = gd?._fullLayout?.sliders?.[0]?.active;\n    if (typeof sliderActive === 'number') return sliderActive;\n    return this.zIndex.value || 0;\n  }\n\n  /** Capability-gated 3D scene controls (Plotly renders the 3D plot types). */\n  getSurface3dControls() {\n    return {\n      setSurfaceDragMode: (mode: string) => this.setSurfaceDragMode(mode),\n      resetSurfaceCamera: () => this.resetSurfaceCamera(),\n    };\n  }\n\n  public setSurfaceDragMode(mode: string) {\n    if (this.plotDiv) {\n      Plotly.relayout(this.plotDiv, { 'scene.dragmode': mode } as any);\n    }\n  }\n\n  public resetSurfaceCamera() {\n    if (this.plotDiv) {\n      Plotly.relayout(this.plotDiv, { 'scene.camera': {} } as any);\n    }\n  }\n\n  private triggerZoom(coordinates: number[]) {\n    if (coordinates.length === 0 || !this.trueImgSize) return;\n    this.zoomCoordinates = coordinates;\n    const rect = this.plotUtilities.getRectangle(coordinates, this.trueImgSize);\n    if (this.plotUtilities.isZoomSameAsImgSize(rect, this.trueImgSize)) {\n      this.autoscale();\n      return;\n    }\n    // A brief \"Caching image...\" message for uncached files (large files take a\n    // moment to cache); just a spinner otherwise.\n    this.state.setImageLoadingMessage(this.imageCached ? '' : 'Caching image...');\n    const screen = this.plotUtilities.getDomRectangle('diagram');\n    const imageSize: any[] = [];\n    imageSize[0] = rect.x;\n    imageSize[1] = rect.x + rect.width;\n    imageSize[2] = rect.y;\n    imageSize[3] = rect.y + rect.height;\n    // Snapshot the filename so a response that arrives after the user switched\n    // files is dropped (the request carried the file selected at call time).\n    const reqName = this.fileName;\n    this.state.setImageLoading(true);\n    this.state.setZoom(true);\n    this.tiles.zoomOnRegion(rect, screen, this.zIndex.value).subscribe({ next: zoomData => {\n      const uint8Array = new Uint8Array(zoomData);\n      const buffer = Buffer.from(uint8Array);\n      Image.load(buffer).then((image: any) => {\n        const xRatio = rect.width / image.width;\n        const yRatio = rect.height / image.height;\n        if (this.fileName === reqName) {\n          const isGray = this.imageInfo?.isGrayscale;\n          const frame = isGray\n            ? this.plotUtilities.arrayToMatrix(image.grey().data, image.width)\n            : this.plotUtilities.arrayToMatrix(image.getPixelsArray(), image.width);\n          // Also sample the intensity profiles from this high-def crop so the\n          // inset reflects the zoom-level resolution (origin = crop top-left).\n          this.setSamplingFrames([frame], [xRatio, yRatio], [imageSize[0], imageSize[2]]);\n          this.emitProfiles();\n          // Re-render the high-def crop in the SAME plot type the user is\n          // viewing. Without this the zoom re-fetch always fell back to a\n          // heatmap, so zooming in contour (or any registry type) reverted\n          // to heatmap.\n          const impl = PLOTLY_PLOT_TYPE_IMPLS[this.plotType];\n          const renderPromise = impl\n            ? this.plotViaRegistry(this.plotDiv, impl,\n                this.buildTraceInput(this.imageInfo, {\n                  data: [frame], ratios: [xRatio, yRatio],\n                  sizes: [image.width, image.height], filename: reqName,\n                }, imageSize), this.screenHeight)\n            : (isGray\n                ? this.plotHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio],\n                    this.screenHeight)\n                : this.plotRGBHeatmap(this.plotDiv, this.urls, [frame], imageSize, [xRatio, yRatio],\n                    image.width, image.height, this.screenHeight));\n          // plotViaRegistry already applies the type's own layout/range for\n          // non-image layouts (chart/overlay); only re-apply the heatmap\n          // range for the image-aligned paths.\n          const reapplyRange = !impl || impl.layoutKind === '2d-image';\n          renderPromise.then(() => {\n            this.state.setImageCached(true);\n            this.state.setImageLoading(false);\n            image = null;\n            if (reapplyRange) this.relayout(imageSize);\n          });\n        }\n      });\n    }, error: err => {\n      const msg = err?.error?.message || err?.message || err?.statusText || String(err);\n      console.error('Error occured when zooming', err);\n      this.messageService.add({ key: VIZ_ALERT_TOAST_KEY, sticky: true, severity:'error', summary:'An error occured',\n        detail:`The following error occured while zooming: ${msg}.\n                          Please try to open the image again through the file navigator and\n                          zoom on the selected area once more.` });\n      this.state.setLoadingError(true);\n      this.state.setImageLoading(false);\n    }, complete: () => {\n      console.log('zooming complete');\n    } });\n  }\n\n  public setPlotType(plotType: PlotType) {\n    this.plotType = plotType;\n  }\n\n  private setImageInfo(showStack?: boolean, scaleratio?: boolean) {\n    // Nothing plotted yet (a host's first view is an image-less spatial dataset): there is no\n    // image to describe, so nothing to re-plot — stop the spinner rather than throw.\n    if (!this.trueImgSize) {\n      this.state.setImageLoading(false);\n      return;\n    }\n    // Build a partial image descriptor and push it to the host via the port.\n    const imgInfo: Partial<IImageInfo> = {\n      isGrayscale: this.imageInfo?.isGrayscale,\n      trueImageSize: [this.trueImgSize[1], this.trueImgSize[3]],\n      urls: this.urls,\n      isStack: this.urls.length > 1,\n      scaleRatio: scaleratio !== undefined ? scaleratio : this.scaleratio,\n    };\n    if (showStack !== undefined) imgInfo.showStack = showStack;\n    if (this.fileName) imgInfo.fileName = this.fileName;\n    this.state.setImageInfo(imgInfo);\n  }\n\n  public getShapes() {\n    return this.shapes;\n  }\n\n  /**\n   * Framework-neutral view of the current regions — delegates to the shared\n   * RegionStore (the single source of truth). The canonical accessor on the\n   * `IVisualizer` contract; consumers should prefer this over `getShapes()`\n   * (which exposes Plotly-shaped dicts).\n   */\n  public getRegions(): Region[] {\n    return this.regionStore.getRegions();\n  }\n\n  /**\n   * Switch the active image. The shared RegionStore owns the per-image region\n   * cache (snapshot outgoing / restore incoming / clear selection / emit); we\n   * delegate to it, then re-project the store's regions into Plotly's dict\n   * working-set. Re-projecting unconditionally (even when the store no-ops for\n   * the same image) means Plotly also picks up regions another backend (OSD)\n   * added while it was off-screen. Called from `plot()` and from the router\n   * before any backend renders.\n   */\n  public setActiveImage(imageInfo: IImageInfo) {\n    this.regionStore.setActiveImage(imageInfo);\n    this.syncShapesFromStore();\n    this.previousShapes = this.shapes.slice();\n  }\n\n  /** Test/dev hook — drop the entire per-image cache (logout / project switch). */\n  public clearRegionsByImageKey() {\n    this.regionStore.clearRegionsByImageKey();\n  }\n\n  /**\n   * Get all the selected regions as polygons. Open polylines (closed === false)\n   * are excluded — they're annotation-only and cannot be used as filled regions\n   * for image processing. Delegates to the shared store.\n   */\n  public getRegionPolygons(): any[] {\n    return this.regionStore.getRegionPolygons();\n  }\n\n  isRectangle(bnds: any): bnds is Rectangle {\n    return 'x' in bnds && 'y' in bnds && 'width' in bnds && 'height' in bnds;\n  }\n\n  isPolygon(bnds: any): bnds is Polygon {\n    return 'npoints' in bnds && 'xpoints' in bnds && 'ypoints' in bnds;\n  }\n\n  /**\n   * Set plot regions. Delegates the state change to the shared RegionStore\n   * (id/name minting, classification colours, append de-duplication, per-image\n   * cache and the region-update event all live there), then re-projects the\n   * store's regions into Plotly's dict working-set and renders.\n   *\n   * When `isRegionSaveOn` is false the regions are shown transiently — rendered\n   * without altering the stored working-set (preserves the prior behaviour).\n   */\n  public setRegions(regions: Region[], showRegionLabel?: boolean,\n                    isRegionSaveOn?: boolean, fillColor?: string,\n                    append: boolean = false) {\n    const showLabel = showRegionLabel === undefined ? this.regionStore.getShowShapeLabel() : showRegionLabel;\n    const save = isRegionSaveOn === undefined ? this.isRegionSavedOn : isRegionSaveOn;\n\n    this.regionStore.setRegions(regions, showRegionLabel, isRegionSaveOn, fillColor, append);\n    this.isRegionSavedOn = save;\n\n    if (save) {\n      // Re-project the authoritative regions into Plotly's working-set and render.\n      this.syncShapesFromStore();\n      this.renderShapes();\n    } else {\n      // Transient display only — render the passed regions, don't touch the\n      // working-set (and the store didn't store them either).\n      const dicts = regions.map(r => { r.filename = this.fileName; return { ...r.getShape(showLabel) }; });\n      try {\n        Plotly.relayout(this.plotDiv, this.shapesRelayout(dicts) as any);\n      } catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }\n    }\n  }\n\n  /** The shapes-relayout payload: region shapes (profile-line ROIs included, as\n   *  they are ordinary regions) plus the active-shape fill colour. */\n  private shapesRelayout(shapeDicts: any[]): any {\n    return {\n      shapes: shapeDicts,\n      activeshape: { fillcolor: this.regionStore.getFillColor() },\n    };\n  }\n\n  /** Push the current dict working-set to Plotly (no-op when another backend\n   *  owns the div). */\n  private renderShapes(): void {\n    if (!this.plotDiv) return;\n    const dictArray = this.shapes.map(s => ({ ...s }));\n    try {\n      Plotly.relayout(this.plotDiv, this.shapesRelayout(dictArray) as any);\n    } catch { /* div owned by another backend (OSD) — its overlay renders shapes */ }\n  }\n\n  getShowShapeLabel() {\n    return this.regionStore.getShowShapeLabel();\n  }\n\n  /**\n   * Set previous saved shapes\n   */\n  public plotPreviousShapes() {\n    // convert to dict so that plotly recognises the shapes\n    const dictArray = this.previousShapes.map(s => ({ ...s }));\n    try {\n      Plotly.relayout(this.plotDiv, { shapes: dictArray });\n    } catch { /* div owned by another backend (OSD) */ }\n  }\n\n  setPreviousShapes(shapes: ShapeSelection[]) {\n    this.previousShapes = shapes;\n  }\n\n  getPreviousShapes() {\n    return this.previousShapes;\n  }\n\n  // Undo (jit-ui#85): region history lives in the shared RegionStore, so the\n  // active backend's overlay re-renders off its regionUpdate$ on restore.\n  public undo(): void { this.regionStore.undo(); }\n  public redo(): void { this.regionStore.redo(); }\n  public canUndo(): boolean { return this.regionStore.canUndo(); }\n  public canRedo(): boolean { return this.regionStore.canRedo(); }\n  public getCanUndo$(): Observable<boolean> { return this.regionStore.getCanUndo$(); }\n  public getCanRedo$(): Observable<boolean> { return this.regionStore.getCanRedo$(); }\n  public resetUndoHistory(): void { this.regionStore.resetUndoHistory(); }\n\n  // ── Per-slice z-stack regions → RegionStore (jit-ui#93) ──────────────────\n  public enterStackMode(slices: Map<number, Region[]>, initialZ?: number,\n                        saveLayout?: 'combined' | 'per-slice-file'): void {\n    this.regionStore.enterStackMode(slices, initialZ, saveLayout);\n  }\n  public exitStackMode(): void { this.regionStore.exitStackMode(); }\n  public isStackMode(): boolean { return this.regionStore.isStackMode(); }\n  public getStackSaveLayout(): 'combined' | 'per-slice-file' {\n    return this.regionStore.getStackSaveLayout();\n  }\n  public setDisplaySlice(z: number): void { this.regionStore.setDisplaySlice(z); }\n  public getSliceRegions(): Region[] { return this.regionStore.getSliceRegions(); }\n  public getStackSaveSlices(): Map<number, Region[]> { return this.regionStore.getStackSaveSlices(); }\n\n  private getHeatmapLayout(xRange: number[], yRange: number[]): any {\n    return {\n      xaxis: {\n        constrain: 'range',\n        constraintoward: 'center',\n        side: 'top',\n        ticks: '',\n        range: xRange\n      },\n      yaxis: {\n        constrain: 'range',\n        constraintoward: 'center',\n        range: yRange,\n        ticks: '',\n        ticksuffix: '  ',\n\t\t\t\t// set autorange to false so that plotly does not overwrite the range for the y axis\n\t\t\t\tautorange: false,\n        scaleanchor: this.scaleratio ? 'x' : false\n     },\n      margin: { t: 30, b: 5, l: 55, r: 5 },\n      height: this.screenHeight,\n      sliders: [{\n        pad: { t: 50 },\n        currentvalue: {\n          visible: true,\n          prefix: 'Z-plane:',\n          xanchor: 'right',\n        },\n        steps: this.getSteps()\n      }],\n      autosize: true,\n      shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),\n      activeshape: { fillcolor: this.regionStore.getFillColor() },\n      dragmode: this.dragMode ? this.dragMode : false,\n      newshape: { line: { color: this.regionStore.getShapeColor(), width: 3 } }\n    };\n  }\n\n  private shapesToRedraw(showLabel: boolean) {\n    const shapesToRedraw: ShapeSelection[] = [];\n    for (const shape of this.shapes) {\n      if (JSON.stringify(shape.fileName) === JSON.stringify(this.fileName)) {\n        // Set label\n        if (showLabel) {\n          shape.label = {\n            text: `${shape.legend}`,\n            texttemplate: `${shape.legend}`,\n            textposition: 'top left',\n            font: { color: `${shape.line.color}` }\n          };\n        } else {\n          shape.label = {};\n        }\n        shapesToRedraw.push(shape);\n      }\n    }\n    // convert to dict so that plotly recognises the shapes\n    return shapesToRedraw.map(s => ({ ...s }));\n  }\n  /**\n   * Unused (will be used when surface plot is added)\n   * @param xRange\n   * @param yRange\n   * @param zRatio\n   * @private\n   */\n  private getSurfaceLayout(xRange: number[], yRange: number[], zRatio: number): any {\n    return {\n      margin: { t: 0, b: 0, l: 0, r: 0 },\n      scene: {\n        xaxis: {\n          gridcolor: 'rgb(255, 255, 255)',\n          zerolinecolor: 'rgb(255, 255, 255)',\n          showbackground: true,\n          backgroundcolor: 'rgb(230, 230,230)',\n          // range: xRange\n        },\n        yaxis: {\n          gridcolor: 'rgb(255, 255, 255)',\n          zerolinecolor: 'rgb(255, 255, 255)',\n          showbackground: true,\n          backgroundcolor: 'rgb(230, 230, 230)',\n          // autorange: 'reversed',\n          // range: yRange,\n          // scaleanchor: 'x'\n        },\n        zaxis: {\n          gridcolor: 'rgb(255, 255, 255)',\n          zerolinecolor: 'rgb(255, 255, 255)',\n          showbackground: true,\n          backgroundcolor: 'rgb(230, 230,230)'\n        },\n        aspectratio: { x: 1, y: 1, z: zRatio },\n        aspectmode: 'manual',\n        sliders: [{\n          pad: { t: 50 },\n          currentvalue: {\n            visible: true,\n            prefix: 'Z-plane:',\n            xanchor: 'right',\n          },\n          steps: this.getSteps()\n        }],\n      }\n    };\n  }\n\n  private getSteps() {\n    const steps = [];\n    for (let i = 0; i < this.imageLength; i++) {\n      steps.push({\n        label: i + 1,\n        method: 'restyle',\n        args: ['visible', Array(this.imageLength).fill(false).fill(true, i, i + 1)],\n      });\n    }\n    return steps;\n  }\n\n  /**\n   * Fetch an image via Angular HttpClient so that auth interceptors (Bearer token)\n   * are applied, then decode it with image-js. This avoids raw browser fetch()\n   * calls that bypass the interceptor chain and fail behind an OAuth2 proxy.\n   */\n  private async loadImage(url: string): Promise<Image> {\n    const buffer = await firstValueFrom(\n      this.http.get(url, { responseType: 'arraybuffer' })\n    );\n    return Image.load(Buffer.from(buffer));\n  }\n\n  /**\n   * Get the currently displayed image as an image-js Image instance.\n   * Used by the processing pipeline to obtain the input image.\n   */\n  public async getCurrentImage(): Promise<Image | null> {\n    if (!this.imageInfo || !this.imageInfo.urls || this.imageInfo.urls.length === 0) {\n      return null;\n    }\n    const zIdx = this.zIndex.value || 0;\n    const url = this.imageInfo.urls[zIdx] || this.imageInfo.urls[0];\n    return this.loadImage(url);\n  }\n\n  /**\n   * Get the currently displayed plot pixel data as a flat Uint8ClampedArray.\n   * This captures whatever is actually rendered — including zoomed regions.\n   * Returns { width, height, channels, data } or null if no plot is displayed.\n   */\n  public getDisplayedPixelData(): { width: number; height: number; channels: number;\n    data: Uint8ClampedArray } | null {\n    if (!this.plotDiv) return null;\n    const gd: any = document.getElementById(this.plotDiv);\n    if (!gd?.data || gd.data.length === 0) return null;\n\n    // Find the visible trace\n    const frameIdx = this.activeFrameIndex();\n    const trace = gd.data[frameIdx] || gd.data[0];\n    if (!trace || !trace.z) return null;\n\n    const zData: any[][] = trace.z;\n    const height = zData.length;\n    if (height === 0) return null;\n    const width = zData[0].length;\n\n    if (trace.type === 'image') {\n      // RGB image: z[row][col] = [r, g, b] or [r, g, b, a]\n      const sample = zData[0][0];\n      const channels = Array.isArray(sample) ? sample.length : 3;\n      const data = new Uint8ClampedArray(width * height * channels);\n      for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n          const pixel = zData[y][x];\n          const offset = (y * width + x) * channels;\n          for (let c = 0; c < channels; c++) {\n            data[offset + c] = pixel[c];\n          }\n        }\n      }\n      return { width, height, channels, data };\n    } else {\n      // Heatmap (grayscale): z[row][col] = scalar value\n      const data = new Uint8ClampedArray(width * height);\n      for (let y = 0; y < height; y++) {\n        for (let x = 0; x < width; x++) {\n          data[y * width + x] = Math.round(zData[y][x]);\n        }\n      }\n      return { width, height, channels: 1, data };\n    }\n  }\n\n  /**\n   * Region of the original image that the displayed `z` grid covers, in\n   * full-image pixel coords. On a server zoom (`triggerZoom`) the trace `z` is\n   * replaced with the high-def crop and the axes are relaid out to the crop's\n   * original-image bounds (`imageSize`), so the live axis ranges ARE that\n   * rectangle; when the whole image is in view the ranges span `trueImgSize`.\n   * Reading the ranges therefore yields the crop origin + extent without\n   * tracking zoom state separately. Falls back to the full image, then `null`.\n   */\n  public getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    const gd: any = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n    const xr: number[] | undefined = gd?._fullLayout?.xaxis?.range;\n    const yr: number[] | undefined = gd?._fullLayout?.yaxis?.range;\n    if (xr && yr) {\n      const x0 = Math.min(xr[0], xr[1]);\n      const y0 = Math.min(yr[0], yr[1]); // y axis is reversed for image layouts\n      return { x: x0, y: y0, width: Math.abs(xr[1] - xr[0]), height: Math.abs(yr[1] - yr[0]) };\n    }\n    if (!this.trueImgSize) return null;\n    return {\n      x: this.trueImgSize[0],\n      y: this.trueImgSize[2],\n      width: this.trueImgSize[1] - this.trueImgSize[0],\n      height: this.trueImgSize[3] - this.trueImgSize[2],\n    };\n  }\n\n  public reset() {\n    if (this.plotDiv) {\n      Plotly.newPlot(this.plotDiv, [],\n        this.getHeatmapLayout([0, 100], [100, 0]), CONFIG as any);\n    }\n  }\n\n  /**\n   * Fully remove Plotly's DOM from the plot div (axes included). Used when\n   * handing the div to another backend (OpenSeadragon) — unlike `reset()`,\n   * which re-renders an empty plot and would leave the Plotly axes showing.\n   */\n  public purgePlot() {\n    if (this.plotDiv) {\n      Plotly.purge(this.plotDiv);\n    }\n  }\n\n  /** Export the heatmap as a PNG (the rendered plot already reflects the active\n   *  colormap/window). The full-res tile composite is OSD's job. */\n  public exportComposite(): void {\n    this.downloadImage();\n  }\n\n  public downloadImage() {\n    if (this.plotDiv) {\n      (Plotly as any).downloadImage(this.plotDiv, { format: 'png', filename: this.fileName || 'image' });\n    }\n  }\n\n  public resetAxes() {\n    this.zoomCoordinates = [];\n    this.relayout();\n  }\n\n  public setDragMode(mode: string | false) {\n    this.dragMode = mode ? (mode as string) : '';\n    if (!this.plotDiv) return;\n    // Only relayout a LIVE Plotly graph. When another backend (OSD / napari-js) owns the view the\n    // div id is still set but has no Plotly plot attached, and Plotly.relayout throws\n    // (\"can't access property _guiEditing, n is undefined\"). That throw aborted the caller\n    // (deactivateActiveTool → onSelectPlotType) before the re-plot ran, wedging the plot type\n    // (e.g. stuck switching napari volume ↔ isosurface). Guard on `_fullLayout` like the zoom\n    // helpers do so it safely no-ops when Plotly isn't the active renderer.\n    const gd = document.getElementById(this.plotDiv) as unknown as { _fullLayout?: unknown } | null;\n    if (!gd?._fullLayout) return;\n    Plotly.relayout(this.plotDiv, { dragmode: mode } as any);\n  }\n\n  /** {@link IDataRenderer} stub — Plotly has no overview navigator (it's an\n   *  OpenSeadragon feature), so toggling it is a no-op here. */\n  public setNavigatorVisible(_visible: boolean): void {\n    /* no-op: navigator is OpenSeadragon-only */\n  }\n\n  /** {@link IDataRenderer} stub — image smoothing is an OpenSeadragon canvas-drawer\n   *  setting; the Plotly image/heatmap traces don't expose it, so it's a no-op. */\n  public setImageSmoothingEnabled(_enabled: boolean): void {\n    /* no-op: smoothing toggle is OpenSeadragon-only */\n  }\n\n  public zoomIn() {\n    if (!this.plotDiv) return;\n    const gd: any = document.getElementById(this.plotDiv);\n    if (!gd?._fullLayout) return;\n    const xl = gd._fullLayout.xaxis;\n    const yl = gd._fullLayout.yaxis;\n    // 3D scenes have no 2D xaxis/yaxis (they live under `scene`); the step-zoom\n    // is meaningless there and would throw on `xl.range`. Plotly's scene handles\n    // scroll-zoom natively, so just bail.\n    if (!xl?.range || !yl?.range) return;\n    const xc = (xl.range[0] + xl.range[1]) / 2;\n    const yc = (yl.range[0] + yl.range[1]) / 2;\n    const dx = (xl.range[1] - xl.range[0]) / 1.3;\n    const dy = (yl.range[1] - yl.range[0]) / 1.3;\n    const x0 = xc - dx / 2, x1 = xc + dx / 2;\n    const y0 = yc - dy / 2, y1 = yc + dy / 2;\n    this.zoomCoordinates = [x0, x1, y0, y1];\n    Plotly.relayout(this.plotDiv, {\n      'xaxis.range[0]': x0, 'xaxis.range[1]': x1,\n      'yaxis.range[0]': y0, 'yaxis.range[1]': y1\n    } as any);\n  }\n\n  /**\n   * Delete every currently selected shape. Falls back to the single\n   * `_activeShapeIndex` when no multi-selection is active (covers the case\n   * where Plotly clicked a shape without going through the table).\n   */\n  public deleteActiveShape() {\n    // Note: no `plotDiv` guard — when OpenSeadragon is the renderer, Plotly\n    // never plotted (plotDiv is unset), but deletion only needs the shape list\n    // + the current selection; the Plotly relayout below is guarded.\n    const gd: any = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n\n    // Resolve what to delete: the store's selection, else the shape Plotly\n    // tracks as clicked (when the user clicked a shape without going through the\n    // Region Editor table).\n    if (this.regionStore.getSelectedShapeIndices().length === 0) {\n      const activeIndex: number = gd?._fullLayout?._activeShapeIndex;\n      if (activeIndex === undefined || activeIndex < 0) return;\n      this.regionStore.setSelectedShapeIndices([activeIndex]);\n    }\n    // The store removes the selected regions, clears the selection, syncs its\n    // cache and emits the region-update event.\n    this.regionStore.deleteActiveShape();\n\n    // Re-project the remaining regions and render on the Plotly plot (a no-op,\n    // caught, when another backend owns the div — its overlay re-renders via\n    // the store's update event).\n    if (gd?._fullLayout) gd._fullLayout._activeShapeIndex = -1;\n    this.syncShapesFromStore();\n    const dictArray = this.shapes.map(s => ({ ...s }));\n    try {\n      Plotly.relayout(this.plotDiv, { shapes: dictArray } as any).then(() => {\n        if (gd?._fullLayout) (Plotly as any).redraw(gd);\n      }, () => { /* div not a Plotly plot */ });\n    } catch { /* div owned by another backend */ }\n  }\n\n  public zoomOut() {\n    if (!this.plotDiv) return;\n    const gd: any = document.getElementById(this.plotDiv);\n    if (!gd?._fullLayout) return;\n    const xl = gd._fullLayout.xaxis;\n    const yl = gd._fullLayout.yaxis;\n    // 3D scenes have no 2D xaxis/yaxis — see zoomIn().\n    if (!xl?.range || !yl?.range) return;\n    const xc = (xl.range[0] + xl.range[1]) / 2;\n    const yc = (yl.range[0] + yl.range[1]) / 2;\n    const dx = (xl.range[1] - xl.range[0]) * 1.3;\n    const dy = (yl.range[1] - yl.range[0]) * 1.3;\n    const x0 = xc - dx / 2, x1 = xc + dx / 2;\n    const y0 = yc - dy / 2, y1 = yc + dy / 2;\n    this.zoomCoordinates = [x0, x1, y0, y1];\n    Plotly.relayout(this.plotDiv, {\n      'xaxis.range[0]': x0, 'xaxis.range[1]': x1,\n      'yaxis.range[0]': y0, 'yaxis.range[1]': y1\n    } as any);\n  }\n\n  public isStackLoading$(): Observable<boolean> {\n    return this.stackLoading$.asObservable();\n  }\n  public setStackLoading(stackLoading: boolean) {\n    this.stackLoading$.next(stackLoading);\n  }\n  public getStackLoadingProgress$(): Observable<number> {\n    return this.stackLoadingProgress$.asObservable();\n  }\n\n  // Colormap / reverse-scale / image metadata state lives in the shared\n  // VisualizerStore; these delegate, keeping only the Plotly-specific live\n  // restyle as render glue.\n  getColormapOptions() {\n    return this.store.getColormapOptions();\n  }\n  setColormap(colormap: any) {\n    this.store.setColormap(colormap);\n    try {\n      Plotly.restyle(this.plotDiv, { 'colorscale': [colormap.data.value] });\n    } catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }\n  }\n  getColormap() {\n    return this.store.getColormap();\n  }\n\n  setReverseScale(reverscale: any) {\n    this.store.setReverseScale(reverscale);\n    try {\n      Plotly.restyle(this.plotDiv, { 'reversescale': reverscale });\n    } catch { /* div owned by another backend (OSD) — it recolors via the LUT */ }\n  }\n\n  getReverseScale() {\n    return this.store.getReverseScale();\n  }\n\n  setImageMeta(imageMeta: IImageMetadata[]) {\n    this.store.setImageMeta(imageMeta);\n  }\n\n  getImageMeta() {\n    return this.store.getImageMeta();\n  }\n\n  setShowStack(showstack: boolean) {\n    if (!showstack) {\n      this.zIndex.next(0);\n    }\n    if (this.imageInfo) this.imageInfo.showStack = showstack;\n    this.stackLoading$.next(showstack);\n    Plotly.relayout(this.plotDiv, { 'showstack': showstack } as any);\n  }\n\n  getAutoscaleEvent() {\n    return this.autoscaleEvent.asObservable();\n  }\n\n  getRegionUpdateEvent() {\n    return this.regionStore.getRegionUpdateEvent();\n  }\n\n  /**\n   * Stream of the indices of currently selected regions — owned by the shared\n   * RegionStore so the selection is consistent across backends and the Region\n   * Editor table. Empty = nothing selected.\n   */\n  getSelectedShapeIndices$(): Observable<number[]> {\n    return this.regionStore.getSelectedShapeIndices$();\n  }\n\n  /**\n   * Programmatically select regions (or clear with []). The shared store owns\n   * the selection state (validates/dedupes/emits); here we additionally point\n   * Plotly's `_activeShapeIndex` at the last selected shape so it gets the edit\n   * handles. No visual change to non-active shapes — Plotly's own active-shape\n   * rendering is the only highlight.\n   */\n  public setSelectedShapeIndices(indices: number[]) {\n    const valid = (indices || [])\n      .filter(i => Number.isFinite(i) && i >= 0 && i < this.shapes.length);\n    const seen = new Set<number>();\n    const cleaned: number[] = [];\n    for (const i of valid) {\n      if (!seen.has(i)) { seen.add(i); cleaned.push(i); }\n    }\n    if (this.plotDiv) {\n      const gd: any = document.getElementById(this.plotDiv);\n      if (gd?._fullLayout) {\n        gd._fullLayout._activeShapeIndex = cleaned.length > 0 ? cleaned[cleaned.length - 1] : -1;\n        try { (Plotly as any).redraw(gd); } catch { /* noop in tests */ }\n      }\n    }\n    this.regionStore.setSelectedShapeIndices(cleaned);\n  }\n\n  /**\n   * Select a specific region (IRegionStore.selectRegion). Sets the shared store\n   * selection by identity and points Plotly's active-shape at the matching\n   * rendered shape so its edit handles appear.\n   */\n  public selectRegion(region: Region): void {\n    this.regionStore.selectRegion(region);\n    if (this.plotDiv) {\n      const idx = this.shapes.findIndex(s => s.id === region?.id);\n      const gd: any = document.getElementById(this.plotDiv);\n      if (gd?._fullLayout && idx >= 0) {\n        gd._fullLayout._activeShapeIndex = idx;\n        try { (Plotly as any).redraw(gd); } catch { /* noop in tests */ }\n      }\n    }\n  }\n\n  /**\n   * Read Plotly's `_activeShapeIndex` and push it as the selection. Called from\n   * the relayout handler and the post-click tick — Plotly doesn't fire a\n   * dedicated active-shape event for clicks, so we sample. The store no-ops if\n   * the selection is unchanged.\n   */\n  private maybeEmitActiveShapeIndex() {\n    if (!this.plotDiv) return;\n    const gd: any = document.getElementById(this.plotDiv);\n    const raw = gd?._fullLayout?._activeShapeIndex;\n    const idx = (typeof raw === 'number' && raw >= 0 && raw < this.shapes.length) ? raw : -1;\n    this.regionStore.setSelectedShapeIndices(idx >= 0 ? [idx] : []);\n  }\n  setZIndex(zIndex: number) {\n    this.zIndex.next(zIndex);\n  }\n\n  getShapeColor() {\n    return this.regionStore.getShapeColor();\n  }\n  getFillColor() {\n    return this.regionStore.getFillColor();\n  }\n\n  getClassificationColors(): Map<string, string> {\n    return this.store.getClassificationColors();\n  }\n\n  setClassificationColor(label: string, color: string) {\n    this.store.setClassificationColor(label, color);\n  }\n\n  /**\n   * Unsubscribe Subscriptions\n   */\n  unsubscribe() {\n    if (this.imageCachedSubscription) {\n      this.imageCachedSubscription.unsubscribe();\n    }\n    if (this.filenameSubscription) {\n      this.filenameSubscription.unsubscribe();\n    }\n    if (this.regionUpdateSubscription) {\n      this.regionUpdateSubscription.unsubscribe();\n    }\n    if (this.regionLiveEditSubscription) {\n      this.regionLiveEditSubscription.unsubscribe();\n    }\n    if (this.channelSub) {\n      this.channelSub.unsubscribe();\n    }\n  }\n\n  /** Live-apply the channel display window (zmin/zmax) + reverse/invert to the\n   *  heatmap. No-op when no Plotly plot is mounted (OSD owns the div). */\n  private applyChannelDisplay(channels: any[], rev: boolean, inv: boolean): void {\n    if (!this.plotDiv) return;\n    const ch = channels?.[0];\n    const colorscale = this.store.currentColormap()?.data?.value;\n    // reverse-scale and invert each flip the ramp; both together cancel.\n    const update: any = { reversescale: rev !== inv };\n    if (colorscale != null) update.colorscale = colorscale; // live colormap recolor\n    if (ch) {\n      // Surface/isosurface/scatter3d colour-map via cmin/cmax; heatmap/contour via zmin/zmax.\n      const threeD =\n        this.plotType === PlotType.ISOSURFACE ||\n        this.plotType === PlotType.SURFACE ||\n        this.plotType === PlotType.SCATTER3D;\n      if (threeD) {\n        update.cmin = ch.min;\n        update.cmax = ch.max;\n        update.cauto = false;\n      } else {\n        update.zmin = ch.min;\n        update.zmax = ch.max;\n        update.zauto = false;\n      }\n    }\n    try {\n      Plotly.restyle(this.plotDiv, update);\n    } catch {\n      /* not a colour-mapped trace, or OSD owns the div */\n    }\n  }\n\n  /** Binned intensity histogram for a channel from the cached source frames\n   *  (raw, pre-LUT). Grayscale cells are numbers; RGB cells are [r,g,b]. */\n  getHistogram(channelIndex: number, _bins: number): IHistogram | null {\n    const frames = this.cachedImageFrames;\n    if (!frames?.length) return null;\n    const frame = frames[this.activeFrameIndex()] ?? frames[0];\n    if (!frame?.length) return null;\n    const counts = new Array(256).fill(0);\n    for (const row of frame) {\n      if (!row) continue;\n      for (const cell of row) {\n        let v: number;\n        if (Array.isArray(cell)) {\n          v = channelIndex >= 0 && channelIndex < cell.length\n            ? cell[channelIndex]\n            : Math.round(bt601Luminance(cell[0], cell[1], cell[2]));\n        } else {\n          v = cell;\n        }\n        v = v | 0;\n        if (v < 0) v = 0; else if (v > 255) v = 255;\n        counts[v]++;\n      }\n    }\n    return histogram256(counts);\n  }\n\n  /** Async histogram stream — Plotly renders heatmap frame data (already in\n   *  memory, 8-bit luminance), so this just wraps the synchronous 8-bit\n   *  histogram. Native 16-bit histograms only apply to the OSD tile path. */\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return of(this.getHistogram(channelIndex, bins));\n  }\n\n  /** Data export (16-bit TIFF) is an OSD-tile-path feature backed by the server.\n   *  Plotly renders heatmaps from frame data, so there's nothing to export here. */\n  exportData(): void {\n    console.warn('[plotly] 16-bit data export is not available for the heatmap backend.');\n  }\n\n  importRegions(geoJsonStr: string): Region[] {\n    return this.plotUtilities.importROIsFromGeoJson(geoJsonStr);\n  }\n\n  exportRegions(regions: Region[]) {\n    const jsonString = this.plotUtilities.exportROIsToGeoJson(regions);\n    this.plotUtilities.saveToFile(jsonString, this.fileName);\n  }\n\n  getGeoJsonString(regions: Region[]): string {\n    return this.plotUtilities.exportROIsToGeoJson(regions);\n  }\n\n  getStackLoadingProgress() {\n    return this.getStackLoadingProgress$();\n  }\n\n  isStackLoading() {\n    return this.isStackLoading$();\n  }\n\n}\n"]}
+                }] }, { type: i7.VisualizerStore }, { type: i8.RegionStore }, { type: i9.IntensityProfileService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plotly.service.js","sourceRoot":"","sources":["../../../../../src/lib/implementations/plotly/plotly.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, Optional } from '@angular/core';\n\nimport * as Plotly from 'plotly.js-dist-min';\nimport { Image } from 'image-js';\nimport { HttpClient } from '@angular/common/http';\n\nimport { Region } from '../../models/region';\nimport { IImageInfo } from '../../contracts/image.contract';\nimport { TileAccessPort, TILE_ACCESS_PORT } from '../../contracts/ports/tile-access.port';\nimport { ImageStatePort, IMAGE_STATE_PORT } from '../../contracts/ports/image-state.port';\nimport { BehaviorSubject, Observable, Subject, Subscription, combineLatest, of } from 'rxjs';\nimport { MessageService } from 'primeng/api';\nimport { CONFIG, CONFIG_SURFACE } from '../../plot.utilities';\nimport { WandService } from '../../toolbar/wand/wand.service';\nimport { CachedImageData, CanvasToolHost } from '../../toolbar/tool-kit/canvas-tool';\nimport { CanvasToolManager } from '../../toolbar/tool-kit/canvas-tool-manager';\nimport { createCanvasToolManager } from '../../toolbar/canvas-tools';\nimport { SamToolService } from '../../toolbar/segmentation/sam-tool.service';\nimport { SamPointToolService } from '../../toolbar/segmentation/sam-point-tool.service';\nimport { CellSegmentToolService } from '../../toolbar/segmentation/cell-segment-tool.service';\nimport { ICellSegmenter, CELL_SEGMENTER } from '../../contracts/cell-segmenter.contract';\nimport { PlotType, PLOT_TYPE_DESCRIPTORS, PlotTypeDescriptor } from '../../contracts/plot-type';\nimport {\n  PLOTLY_PLOT_TYPE_IMPLS,\n  PlotlyPlotTypeImpl,\n  TraceBuildInput,\n  buildHeatmapTraces,\n  buildRgbImageTraces,\n  buildSurfaceTraces,\n} from './plotly-trace-builders';\nimport {\n  ImageLayoutContext,\n  chartLayout,\n  heatmapLayout,\n  overlayLayout,\n  surfaceLayout,\n  volumeLayout,\n} from './plotly-layouts';\nimport {\n  IViewerBackend,\n  IntensityProfile,\n  IIsosurfaceControls,\n  IIntensityControls,\n  PixelData,\n} from '../../contracts/visualizer.contract';\nimport { IHistogram } from '../../contracts/channel-histogram-api.contract';\nimport { ViewerCapabilities, ViewerFeature, capabilitiesOf } from '../../contracts/capabilities.contract';\nimport { IRegionOverlay } from '../../contracts/region-overlay.contract';\nimport { PlotlyRegionOverlay } from './plotly-region-overlay';\nimport { PlotlyIsosurfaceControls } from './plotly-isosurface-controls';\nimport { PlotlyShapeProjection } from './plotly-shape-projection';\nimport { PlotlyZoomController } from './plotly-zoom-controller';\nimport { PlotlyImageLoader, PlotlyLoaded } from './plotly-image-loader';\nimport {\n  axesSourceRect,\n  channelDisplayRestyle,\n  frameHistogram,\n  planeHistogram,\n  tracePixels,\n} from './plotly-readback';\nimport { PlotlyImageRecolor, recolorKind } from './plotly-image-recolor';\nimport { renderIntensityInset as renderPlotlyIntensityInset } from './plotly-intensity-inset';\nimport { IntensityProfileService } from '../../intensity/intensity-profile.service';\nimport { ICoordinateTransform } from '../../contracts/coordinate-transform.contract';\nimport { PlotlyCoordinateTransform } from './plotly-coordinate-transform';\nimport { VisualizerStore } from '../../store/visualizer-store.service';\nimport { RegionStore } from '../../store/region-store.service';\nimport { BaseStoreVisualizer } from '../base-store-visualizer';\nimport { ColormapNode } from '../../contracts/display-types';\nimport { throwIfAborted } from '../tile-server/transport';\n\n// Re-exported so existing consumers can keep importing PlotType from this\n// module while it physically lives in the backend-neutral contracts/ dir.\n// TODO(plotting-abstraction): once all consumers import from\n// './contracts/plot-type' directly, drop this re-export.\nexport { PlotType } from '../../contracts/plot-type';\n\n/** What a render draws, and where: the plot div, the image's URLs and its frames (one per\n *  z-plane) with their extent (`trueImgSize`, [x0, x1, y0, y1]) and pixel ratios. `inPlace`\n *  updates the existing plot (Plotly.react) instead of purge + newPlot. */\ninterface FramePlot {\n  plotDiv: string;\n  urls: string[];\n  frames: any[];\n  trueImgSize: number[];\n  ratios: number[];\n  screenHeight: number;\n  inPlace?: boolean;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class PlotlyService extends BaseStoreVisualizer implements IViewerBackend {\n  /**\n   * Plotly is the full-featured data backend: it supports every feature,\n   * including 3D scenes, live scalar colormaps, pixel readback and the\n   * server-side high-def zoom re-fetch. (OpenSeadragon, the tiled image\n   * backend, advertises only image display.)\n   */\n  readonly capabilities: ViewerCapabilities = capabilitiesOf([\n    ViewerFeature.ImageDisplay,\n    ViewerFeature.Surface3D,\n    ViewerFeature.ScalarColormap,\n    ViewerFeature.PixelReadback,\n    ViewerFeature.HighDefZoom,\n    ViewerFeature.StackSlider,\n    ViewerFeature.Isosurface,\n  ]);\n\n  /** Plotly's render projection of the shared RegionStore (the shape dicts) and\n   *  the selection ↔ active-shape mapping (see PlotlyShapeProjection). */\n  private readonly shapeProjection = new PlotlyShapeProjection(\n    { plotDiv: () => this.plotDiv, fileName: () => this.fileName },\n    this.regionStore,\n  );\n  /** Step/box zoom, autoscale and the high-def zoom re-fetch (see PlotlyZoomController). */\n  private readonly zoom: PlotlyZoomController;\n  private imageLength!: number;\n  private screenHeight!: number;\n  private plotDiv!: string;\n  private scaleratio = true;\n  private trueImgSize!: number[];\n  private fileName!: string | undefined;\n\n  private dragMode!: string;\n  // Region data lives in the shared RegionStore (`this.regionStore`), Plotly's\n  // shape dicts in `shapeProjection`; colormap, image metadata and\n  // classification colours in the shared VisualizerStore (`this.store`).\n  private urls!: string[];\n  /**\n   * The image currently plotted.\n   *\n   * The `!` is a definite-assignment ASSERTION, not a guarantee: nothing sets this until\n   * an image loads, and a host can clear its image while these paths still run — a\n   * spatial-omics dataset that brings no tissue section does exactly that. So reads here\n   * are optional and assignments guarded; an unguarded one threw\n   * \"can't access property isGrayscale\" and aborted the load.\n   */\n  imageInfo!: IImageInfo;\n  private plotType!: PlotType;\n\n  private onPlotMouseDown: (() => void) | null = null;\n\n  /** Pixel data cached for wand sampling. data[zIndex] is a 2-D matrix. */\n  private cachedImageFrames?: any[];\n  private cachedImageWidth = 0;\n  private cachedImageHeight = 0;\n  private cachedImageRatios: number[] = [1, 1];\n  private cachedIsGrayscale = false;\n  /** A serverless multichannel stack's raw channel planes, per loaded slice: the channels'\n   *  histograms, and what its `image` trace is composited from. */\n  private cachedChannelPlanes?: Uint8Array[][];\n  /** The channel display of a colour image's `image` traces (see PlotlyImageRecolor). */\n  private readonly recolor = new PlotlyImageRecolor({\n    channelStates: () => this.store.currentChannelStates(),\n    invert: () => this.store.currentInvert(),\n  });\n  /** The pending per-frame recolour (requestAnimationFrame handle), if any. */\n  private recolorFrame: number | null = null;\n  /** A recoloured slice is being encoded; `recolorAgain`: an edit came in meanwhile. */\n  private recoloring = false;\n  private recolorAgain = false;\n  /** Recolours the slice a stack's slider brings on screen. */\n  private onSliderChange: (event: { slider?: { active?: unknown } } | undefined) => void;\n  /** Data-space coordinate of the cached frame's pixel (0,0). [0,0] for the full\n   *  image; a crop's top-left after a high-def zoom (so the tools sample the\n   *  zoom-level pixels at the right offset/resolution). */\n  private cachedFrameOrigin: [number, number] = [0, 0];\n  /** events */\n  private onRelayoutEvent: any;\n  /** Bumped by every render of the plot div (plot, a high-def zoom re-render,\n   *  purge, reset). A high-def zoom drops its crop if another render (or the\n   *  hand-over of the div to another backend) happened while it was fetching. */\n  private renderGen = 0;\n  /** Slice fetch + decode, the stack pool and its loading flag/progress. */\n  private readonly loader: PlotlyImageLoader;\n  // current index of image in stack (if stack), 0 if single image\n  private zIndex = new BehaviorSubject<number>(0);\n  private autoscaleEvent = new Subject<any>();\n  /** The ISOSURFACE band, mapped onto the measured volume (see PlotlyIsosurfaceControls). */\n  private readonly iso = new PlotlyIsosurfaceControls(\n    () => this.plotType === PlotType.ISOSURFACE && !!this.plotDiv && !!this.liveGd(),\n    (update) => void Plotly.restyle(this.liveGd(), update as Plotly.Data),\n  );\n  private imageCached = false;\n  private imageCachedSubscription?: Subscription;\n  private filenameSubscription?: Subscription;\n  private channelSub?: Subscription;\n\n  /** What this backend's canvas tools read and write (one host for every tool). */\n  private readonly toolHost: CanvasToolHost;\n  /** This backend's own wand, brush, eraser, zoom-to-box and SAM point tools. */\n  protected readonly canvasTools: CanvasToolManager;\n  /** This backend's region renderer (lazily created in getRegionOverlay). */\n  private regionOverlay?: IRegionOverlay;\n  private readonly coordinateTransform: ICoordinateTransform = new PlotlyCoordinateTransform(\n    () => document.getElementById(this.plotDiv),\n    () => this.getOverlayContainer(),\n  );\n\n  constructor(\n    @Inject(TILE_ACCESS_PORT) private tiles: TileAccessPort,\n    @Inject(IMAGE_STATE_PORT) private state: ImageStatePort,\n    public messageService: MessageService,\n    http: HttpClient,\n    wandService: WandService,\n    private samTool: SamToolService,\n    private samPointTool: SamPointToolService,\n    private cellSegmentTool: CellSegmentToolService,\n    @Optional() @Inject(CELL_SEGMENTER) private cellSegmenter: ICellSegmenter | null,\n    store: VisualizerStore,\n    regionStore: RegionStore,\n    private intensity: IntensityProfileService,\n  ) {\n    super(regionStore, store);\n    this.loader = new PlotlyImageLoader(http);\n    this.zoom = new PlotlyZoomController(\n      {\n        plotDiv: () => this.plotDiv,\n        trueImgSize: () => this.trueImgSize,\n        imageInfo: () => this.imageInfo,\n        fileName: () => this.fileName,\n        imageCached: () => this.imageCached,\n        zIndex: () => this.zIndex.value,\n        nextRenderGen: () => ++this.renderGen,\n        isCurrentRender: (gen) => gen === this.renderGen,\n        heatmapLayout: (x, y) => this.getHeatmapLayout(x, y),\n        setScreenHeight: (h) => {\n          this.screenHeight = h;\n        },\n        cropSampler: () => {\n          const gen = this.intensity.supersede();\n          return (frames, ratios, origin) => {\n            if (!this.intensity.isCurrent(gen)) return;\n            this.setSamplingFrames(frames, ratios, origin);\n            this.intensity.emitProfiles();\n          };\n        },\n        renderCrop: (frame, ratios, size, imageSize, fileName) =>\n          this.renderZoomCrop(frame, ratios, size, imageSize, fileName),\n        reset: () => this.reset(),\n      },\n      state,\n      tiles,\n      messageService,\n    );\n    // relayout event router\n    this.onRelayoutEvent = (event: any) => {\n      this.relayoutEventHandler(event);\n    };\n    this.onSliderChange = (event) => {\n      const active = event?.slider?.active;\n      void this.recolorShownFrame(typeof active === 'number' ? active : this.activeFrameIndex());\n    };\n\n    // The canvas tools read/mutate our state through one host, and this backend\n    // owns its own tool instances (RT-21) — nothing to re-bind on activation.\n    this.toolHost = {\n      getRegions: () => this.regionStore.getRegions(),\n      setRegions: (regions) => this.setRegions(regions),\n      getCachedImageData: () => this.getCachedImageData(),\n      getActiveFrameIndex: () => this.activeFrameIndex(),\n      getOverlayContainer: () => this.getOverlayContainer(),\n      getCoordinateTransform: () => this.getCoordinateTransform(),\n      getFileName: () => this.fileName,\n      getShapeColor: () => this.regionStore.getShapeColor(),\n      pixelToData: (px, py) => this.zoom.pixelToData(px, py),\n      applyZoomToBox: (coords) => this.zoom.applyZoomToBox(coords),\n    };\n    this.canvasTools = createCanvasToolManager(this.toolHost, {\n      wandService,\n      regionStore,\n      samPoint: samPointTool,\n    });\n\n    this.ensureSubscriptions();\n    // Service-lifetime, unlike ensureSubscriptions(): the shapes follow the\n    // store across a view teardown (they no-op while no Plotly graph is live).\n    this.shapeProjection.connect();\n  }\n\n  /**\n   * Subscribe to the shared stores (cached flag, filename, live channel recolor,\n   * profile-inset refresh). Idempotent and self-healing, like OSD's\n   * ensureColormapSubscription: this service is a root singleton, but\n   * `unsubscribe()` (called on VisualizerComponent destroy) tears these down and\n   * the constructor never runs again. So `load()`/`plot()` call this to\n   * re-establish them after a component teardown/recreate.\n   */\n  private ensureSubscriptions(): void {\n    if (this.channelSub) return;\n    this.imageCachedSubscription = this.state.isImageCached$().subscribe((imageCached) => {\n      this.imageCached = imageCached;\n    });\n    this.filenameSubscription = this.state.getFilename$().subscribe((filename) => {\n      this.fileName = filename;\n    });\n    // Live recolor from the Channels & Histogram pane: restyle the display window (zmin/zmax for\n    // a heatmap, cmin/cmax for isosurface/surface), the colorscale (colormap), and reverse/invert\n    // when the channel state OR the colormap changes. A colour (RGB / multichannel) image's\n    // `image` trace has no colour scale: it is recomposited per channel instead (applyChannelDisplay).\n    this.channelSub = combineLatest([\n      this.store.getChannelStates(),\n      this.store.getReverseScale(),\n      this.store.getInvert(),\n      this.store.getColormap(),\n    ]).subscribe(([channels, rev, inv]) => this.applyChannelDisplay(channels, rev, inv));\n  }\n\n  getTrueImageSize(): { width: number; height: number } | null {\n    if (!this.trueImgSize) return null;\n    return {\n      width: this.trueImgSize[1] - this.trueImgSize[0],\n      height: this.trueImgSize[3] - this.trueImgSize[2],\n    };\n  }\n\n  /**\n   * Load slice `zIndex`, or the whole shown stack (see PlotlyImageLoader).\n   * `signal` aborts the requests: the load then rejects with an `AbortError`.\n   */\n  public async load(imageInfo: IImageInfo, zIndex: number, signal?: AbortSignal): Promise<PlotlyLoaded> {\n    throwIfAborted(signal);\n    // Re-establish the store subscriptions if a prior component teardown\n    // (unsubscribe()) tore them down — see ensureSubscriptions().\n    this.ensureSubscriptions();\n    return this.loader.load(\n      imageInfo,\n      zIndex,\n      signal,\n      () => {\n        // [x0, x1, y0, y1]\n        this.trueImgSize = [0, imageInfo.trueImageSize[0], 0, imageInfo.trueImageSize[1]];\n        this.fileName = imageInfo.fileName;\n      },\n      () => this.fileName === imageInfo.fileName,\n    );\n  }\n\n  /**\n   * Plot a loaded image (see {@link load}) as `plotType`. `inPlace` updates the\n   * existing plot via Plotly.react instead of purge + newPlot — the multi-tier\n   * swap (small → large) — so the canvas doesn't briefly blank between phases.\n   */\n  public plot(\n    plotDiv: string,\n    imageLoaded: any,\n    imageInfo: IImageInfo,\n    screenHeight: number,\n    plotType: PlotType,\n    inPlace: boolean = false,\n  ) {\n    this.ensureSubscriptions();\n    // A new image: a stroke or SAM prompt in progress belonged to the old one.\n    if (!inPlace) this.canvasTools.resetAll();\n    this.renderGen++;\n    this.zoom.zoomCoordinates = [];\n    const trueImageSize = [0, imageInfo.trueImageSize[0], 0, imageInfo.trueImageSize[1]]; // [x0, x1, y0, y1]\n    // Save the current image's regions and pull in any cached regions for the\n    // image we're about to display, before Plotly.newPlot reads the shape projection.\n    this.setActiveImage(imageInfo);\n    this.imageInfo = imageInfo;\n    this.plotType = plotType;\n    // Cache pixel matrices so the wand tool can sample them.\n    this.cachedImageFrames = imageLoaded.data;\n    this.cachedImageWidth = imageLoaded.sizes[0];\n    this.cachedImageHeight = imageLoaded.sizes[1];\n    this.cachedImageRatios = imageLoaded.ratios;\n    this.cachedFrameOrigin = [0, 0]; // full image — reset any prior zoom-crop origin\n    this.cachedIsGrayscale = !!imageInfo.isGrayscale;\n    this.cachedChannelPlanes = imageLoaded.channelPlanes;\n    // The profiles sample the image on screen from now on (superseding any\n    // sampling fetch still in flight for the previous one).\n    this.intensity.supersede();\n    this.intensity.setSamplingElement(plotDiv);\n    this.intensity.setFrames(\n      { frames: imageLoaded.data, ratios: imageLoaded.ratios },\n      { imageInfo, extent: trueImageSize, frameIndex: () => this.activeFrameIndex() },\n    );\n\n    // Pluggable plot types (contour, scatter, scatter3d, isosurface) render\n    // through the trace-builder registry. The original HEATMAP/SURFACE/RGB-image\n    // renderers keep their dedicated paths below (also reused by the high-def\n    // zoom re-fetch). Intensity profiles are no longer a plot type — they're\n    // Region-based line ROIs, available in HEATMAP/IMAGE mode.\n    const impl = PLOTLY_PLOT_TYPE_IMPLS[plotType];\n    if (impl) {\n      // Guarded: `imageInfo` is declared with a definite-assignment assertion, so\n      // nothing stops it being unset at runtime — a plot driven while no image is\n      // loaded reached here and threw on the assignment.\n      if (this.imageInfo) this.imageInfo.isGrayscale = !!imageInfo.isGrayscale;\n      return this.plotViaRegistry(\n        plotDiv,\n        impl,\n        this.buildTraceInput(imageInfo, imageLoaded, trueImageSize),\n        screenHeight,\n        inPlace,\n      );\n    }\n\n    const target: FramePlot = {\n      plotDiv,\n      urls: imageInfo.urls,\n      frames: imageLoaded.data,\n      trueImgSize: trueImageSize,\n      ratios: imageLoaded.ratios,\n      screenHeight,\n      inPlace,\n    };\n    if (imageInfo.isGrayscale) {\n      return plotType === PlotType.SURFACE ? this.plotSurface(target) : this.plotHeatmap(target);\n    }\n    return this.plotRGBHeatmap(target, imageLoaded.sizes[0], imageLoaded.sizes[1], imageLoaded.channelPlanes);\n  }\n\n  /** Grayscale heatmap, one trace per z-plane. */\n  private plotHeatmap(target: FramePlot): Promise<boolean> {\n    this.recolor.clear();\n    const { frames, trueImgSize, ratios } = target;\n    const traces = buildHeatmapTraces(\n      frames,\n      trueImgSize,\n      ratios,\n      this.store.currentColormap().data.value,\n      this.store.currentReverseScale(),\n    );\n    const layout = () => this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3], trueImgSize[2]]);\n    return this.renderPlot(target, traces, layout, CONFIG, true);\n  }\n\n  /** Grayscale surface. */\n  private plotSurface(target: FramePlot): Promise<boolean> {\n    this.recolor.clear();\n    const traces = buildSurfaceTraces(\n      target.frames,\n      this.store.currentColormap().data.value,\n      this.store.currentReverseScale(),\n    );\n    return this.renderPlot(target, traces, () => surfaceLayout(0.4), CONFIG_SURFACE, true);\n  }\n\n  /** RGB image (`width` × `height` pixels), one trace per z-plane, in the current channel\n   *  display: `target.frames` are the raw frames, `planes` a serverless multichannel stack's raw\n   *  channel planes per frame. An image that follows the channel states draws a `source` per\n   *  slice (see PlotlyImageRecolor). */\n  private async plotRGBHeatmap(\n    target: FramePlot,\n    width: number,\n    height: number,\n    planes?: Uint8Array[][],\n  ): Promise<boolean> {\n    const { frames, trueImgSize, ratios } = target;\n    const render = this.renderGen;\n    let sources: string[] | null = null;\n    try {\n      sources = await this.recolor.plot(recolorKind(this.imageInfo, !!planes?.length), frames, planes);\n    } catch (err) {\n      console.warn('[plotly] channel display unavailable; drawing the image as it is', err);\n      this.recolor.clear();\n    }\n    // A newer render took the plot over while the slices were encoded: it draws instead.\n    if (render !== this.renderGen) return true;\n    // As autorange is off and the axis not reversed, the y range is set here.\n    const traces = buildRgbImageTraces(frames, trueImgSize, ratios, width, height, sources ?? undefined);\n    const layout = () => this.getHeatmapLayout([trueImgSize[0], trueImgSize[1]], [trueImgSize[3], trueImgSize[2]]);\n    return this.renderPlot(target, traces, layout, CONFIG, false);\n  }\n\n  /**\n   * Render `traces` into the plot div and wire the relayout/click events. In\n   * place (`Plotly.react`) for the multi-tier small → large swap — `Plotly.purge`\n   * + `Plotly.newPlot` blanks the canvas for ~100ms, which looks like a\n   * regression to \"loading\" before the sharper version appears. The layout is\n   * built after the per-plot state (screen height, slice count) is set.\n   */\n  private renderPlot(\n    target: FramePlot,\n    traces: any[],\n    layout: () => any,\n    config: unknown,\n    isGrayscale: boolean,\n  ): Promise<boolean> {\n    const { plotDiv, screenHeight, inPlace } = target;\n    if (!inPlace) Plotly.purge(plotDiv);\n    this.plotDiv = plotDiv;\n    this.imageLength = target.frames.length;\n    this.urls = target.urls;\n    this.screenHeight = screenHeight;\n    const render = inPlace ? Plotly.react : Plotly.newPlot;\n    return (render as any)(plotDiv, traces as any, layout(), config as any).then(() => {\n      // handle the relayout event for zoom / rois and the click event\n      this.setEvents(plotDiv, isGrayscale, screenHeight);\n      return true;\n    });\n  }\n\n  /**\n   * Assemble the normalised input the pluggable trace builders consume.\n   * Pure data only — no Plotly handles — so the builders stay backend-neutral.\n   */\n  private buildTraceInput(imageInfo: IImageInfo, imageLoaded: any, trueImageSize: number[]): TraceBuildInput {\n    // Measure the volume's real intensity range so the iso band can be clamped\n    // into it (the slider is a fixed 0–255 but a stack may occupy only part of\n    // that, which would otherwise leave the surfaces with nothing to cross).\n    if (this.plotType === PlotType.ISOSURFACE) {\n      this.iso.measure(imageLoaded.data, !!imageInfo.isGrayscale);\n    }\n    const [isoMin, isoMax] = this.iso.band();\n    return {\n      frames: imageLoaded.data,\n      width: imageLoaded.sizes[0],\n      height: imageLoaded.sizes[1],\n      ratios: imageLoaded.ratios,\n      trueImageSize,\n      isGrayscale: !!imageInfo.isGrayscale,\n      colorscale: this.store.currentColormap().data.value,\n      reversescale: this.store.currentReverseScale(),\n      regions: this.getRegionPolygons(),\n      shapeColor: this.regionStore.getShapeColor(),\n      isoMin,\n      isoMax,\n    };\n  }\n\n  /** Update the isosurface intensity band (see PlotlyIsosurfaceControls). */\n  public setIsoRange(isoMin: number, isoMax: number): void {\n    this.iso.setIsoRange(isoMin, isoMax);\n  }\n\n  /** Plotly renders isosurfaces, so it exposes the isosurface controls (itself). */\n  public getIsosurfaceControls(): IIsosurfaceControls | null {\n    return this.iso;\n  }\n\n  /**\n   * Render a registry-backed plot type: build its traces from the input, pick\n   * the matching layout, render, and wire the usual relayout/click events.\n   * Mirrors the structure of the dedicated heatmap/surface renderers.\n   */\n  private plotViaRegistry(\n    plotDiv: string,\n    impl: PlotlyPlotTypeImpl,\n    input: TraceBuildInput,\n    screenHeight: number,\n    inPlace: boolean = false,\n  ): Promise<boolean> {\n    this.recolor.clear();\n    const [x0, x1, y0, y1] = input.trueImageSize;\n    const layout = (): any => {\n      switch (impl.layoutKind) {\n        case '3d-volume':\n          return volumeLayout(this.screenHeight);\n        case '2d-chart':\n          return chartLayout(this.screenHeight);\n        case '2d-overlay':\n          return overlayLayout(this.layoutContext(), [x0, x1], [y1, y0]); // reversed y\n        default:\n          return this.getHeatmapLayout([x0, x1], [y1, y0]); // '2d-image'\n      }\n    };\n    return this.renderPlot(\n      {\n        plotDiv,\n        urls: this.imageInfo?.urls ?? this.urls,\n        frames: input.frames,\n        trueImgSize: input.trueImageSize,\n        ratios: input.ratios,\n        screenHeight,\n        inPlace,\n      },\n      impl.buildTraces(input),\n      layout,\n      impl.threeD ? CONFIG_SURFACE : CONFIG,\n      input.isGrayscale,\n    );\n  }\n\n  /** Plot types this backend advertises (drives the UI selector). */\n  public getPlotTypeDescriptors(): PlotTypeDescriptor[] {\n    return Object.values(PLOT_TYPE_DESCRIPTORS).filter((d): d is PlotTypeDescriptor => !!d);\n  }\n\n  /** This backend's region renderer. Plotly draws shapes natively, so the\n   *  overlay is a thin adapter over this service's drag modes. */\n  public getRegionOverlay(): IRegionOverlay {\n    if (!this.regionOverlay) this.regionOverlay = new PlotlyRegionOverlay(this);\n    return this.regionOverlay;\n  }\n\n  // ── Intensity profile (Region-based line ROIs) ──────────────────────\n\n  /** Plotly renders the line ROIs + inset, so it exposes the intensity controls. */\n  public getIntensityControls(): IIntensityControls | null {\n    return this;\n  }\n\n  /** Render the floating intensity-profile inset (see plotly-intensity-inset.ts),\n   *  so the consumer never touches Plotly directly. */\n  public renderIntensityInset(divId: string, profiles: IntensityProfile[]): void {\n    renderPlotlyIntensityInset(divId, profiles);\n  }\n\n  /** Region shapes for the image on screen (profile lines included: they are\n   *  ordinary store regions). */\n  private currentRenderShapes(showLabel = this.regionStore.getShowShapeLabel()): any[] {\n    return this.shapeProjection.shapesToRedraw(showLabel);\n  }\n\n  /**\n   * IIntensityControls: add another profile line (see IntensityProfileService).\n   * It is a store region, so a Plotly plot on screen draws it from the store's\n   * region-update event, like the OSD/napari overlays.\n   */\n  public addProfileLine(): Region | null {\n    return this.intensity.addProfileLine();\n  }\n\n  /**\n   * Point the pixel tools at these frames (e.g. a high-def zoom crop whose pixel\n   * (0,0) sits at image `origin`), and sample the intensity profiles from them.\n   */\n  public setSamplingFrames(frames: any[], ratios: number[], origin: [number, number] = [0, 0]): void {\n    this.cachedImageFrames = frames;\n    if (ratios) this.cachedImageRatios = ratios;\n    this.cachedFrameOrigin = origin;\n    // The wand/brush bounds-check against these, so they must describe THESE\n    // frames (e.g. a zoom crop), not the image cached before.\n    const frame = frames?.[0];\n    if (frame?.length) {\n      this.cachedImageHeight = frame.length;\n      this.cachedImageWidth = frame[0]?.length ?? 0;\n    }\n    this.intensity.setFrames({ frames, ratios: this.cachedImageRatios, origin });\n  }\n\n  /** No viewport signal: Plotly's own high-def zoom re-samples the profiles inline. */\n  public getIntensitySampling(): null {\n    return null;\n  }\n\n  /** No navigator and no smoothing toggle (OpenSeadragon/napari-js view options). */\n  public getOsdViewOptions(): null {\n    return null;\n  }\n\n  /** Plotly renders no decimated volumes (napari-js's Resolution control). */\n  public getVolumeResolution(): null {\n    return null;\n  }\n\n  /** Autoscale the plot (see PlotlyZoomController). */\n  public autoscale() {\n    this.zoom.autoscale();\n  }\n\n  /** Re-apply the image layout at the current height, over the zoom box if any. */\n  public relayout(trueImageSize?: number[]) {\n    this.zoom.relayout(trueImageSize);\n  }\n\n  private setEvents(plotDiv: string, isGrayscale: boolean, screenHeight: number) {\n    if (this.imageInfo) this.imageInfo.isGrayscale = isGrayscale;\n    this.screenHeight = screenHeight;\n    const plot: any = document.getElementById(plotDiv);\n    if (plot) {\n      // Rebind the relayout handler. gd.on() registers on Plotly's own\n      // EventEmitter, so it must be unbound with removeListener — the DOM's\n      // removeEventListener is a no-op for it, and every in-place render\n      // (Plotly.react keeps the emitter) used to add another handler.\n      plot.removeListener?.('plotly_relayout', this.onRelayoutEvent);\n      plot.on('plotly_relayout', this.onRelayoutEvent);\n      plot.removeListener?.('plotly_sliderchange', this.onSliderChange);\n      plot.on('plotly_sliderchange', this.onSliderChange);\n\n      // Clicking on a shape activates it but Plotly doesn't fire a dedicated\n      // event — sample _activeShapeIndex on the next microtask so subscribers\n      // (Region Editor) can mirror the selection.\n      plot.removeEventListener('mousedown', this.onPlotMouseDown);\n      this.onPlotMouseDown = () => setTimeout(() => this.shapeProjection.syncSelectionFromPlot(), 0);\n      plot.addEventListener('mousedown', this.onPlotMouseDown);\n    }\n  }\n\n  private relayoutEventHandler(event: any) {\n    if (Object.keys(event).includes('dragmode')) {\n      this.dragMode = event.dragmode;\n    }\n    const keys = Object.keys(event);\n    // In-place shape edits and natively drawn shapes, mirrored into the store.\n    this.shapeProjection.applyRelayout(event);\n    // Drag-zoom: remember the box and re-fetch it at high definition.\n    this.zoom.onRelayout(event);\n    // if autoscale\n    if (keys.includes('xaxis.autorange') && keys.includes('yaxis.autorange')) {\n      // trigger an autoscale event to reset the selected image mode dropdown\n      this.autoscaleEvent.next('an autoscale has happened');\n      // select display type to trigger a new plotting update with all the necessary plotting parameters set\n      this.tiles.selectDiagramDisplay();\n    }\n    // if showstack or aspectratio event\n    if (event.showstack !== undefined || event.aspectratio !== undefined) {\n      // Set new image info to trigger a plot update\n      this.setImageInfo(event.showstack, event.aspectratio);\n    }\n\n    // Plotly may have updated the active shape index as part of the relayout\n    // (e.g. clicking a shape's edit handle, or finishing a draw) — surface\n    // that change to the Region Editor.\n    this.shapeProjection.syncSelectionFromPlot();\n  }\n\n  public reloadAndPlot() {\n    this.setImageInfo();\n  }\n\n  // ── Tool delegations ────────────────────────────────────────────────\n  // The canvas tools (setActiveTool and the per-tool setters) are run by\n  // BaseStoreVisualizer over this.canvasTools; Plotly needs no pointer gating.\n\n  /** Box-prompted SAM: segment the drawn rectangles against our tool host\n   *  (cached frame + coordinate transform + region store). */\n  public segmentRectangles(): Promise<number> {\n    return this.samTool.segmentBoxes(this.toolHost);\n  }\n  public segmentRectanglesCellpose(): Promise<number> {\n    if (!this.cellSegmenter) return Promise.resolve(0);\n    return this.cellSegmentTool.segmentBoxes(this.toolHost, this.cellSegmenter);\n  }\n  public setSamModel(id: string): void {\n    this.samTool.setModel(id);\n    this.samPointTool.setModel(id);\n  }\n\n  // ── IViewportHost implementation (for the on-canvas tools) ──────────\n\n  /** The plot element the tool canvas overlays attach to. */\n  public getOverlayContainer(): HTMLElement | null {\n    return this.plotDiv ? document.getElementById(this.plotDiv) : null;\n  }\n\n  /** Plotly coordinate transform (screen <-> data via the axis objects). */\n  public getCoordinateTransform(): ICoordinateTransform {\n    return this.coordinateTransform;\n  }\n\n  // ── Canvas tool host ────────────────────────────────────────────────\n\n  /**\n   * Pixel data the wand needs for sampling. null = no image loaded.\n   *\n   * The traces draw cell (i, j) over `origin + [i, i + 1)·ratio` (see `firstCellCentre`), as OSD\n   * and napari draw their pixels, so the frame starts at the cached origin: a click anywhere on a\n   * cell floors to that cell, and traced outlines run along the cells' edges.\n   */\n  private getCachedImageData(): CachedImageData | null {\n    if (!this.cachedImageFrames || this.cachedImageFrames.length === 0) return null;\n    return {\n      frames: this.cachedImageFrames,\n      width: this.cachedImageWidth,\n      height: this.cachedImageHeight,\n      ratios: this.cachedImageRatios,\n      isGrayscale: this.cachedIsGrayscale,\n      // A high-def zoom caches the crop, whose pixel (0,0) is not image (0,0).\n      originX: this.cachedFrameOrigin[0],\n      originY: this.cachedFrameOrigin[1],\n    };\n  }\n\n  /** Active frame index in the cached image stack. */\n  private activeFrameIndex(): number {\n    if (!this.cachedImageFrames || this.cachedImageFrames.length <= 1) return 0;\n    const gd: any = document.getElementById(this.plotDiv);\n    const sliderActive = gd?._fullLayout?.sliders?.[0]?.active;\n    if (typeof sliderActive === 'number') return sliderActive;\n    return this.zIndex.value || 0;\n  }\n\n  /** Capability-gated 3D scene controls (Plotly renders the 3D plot types). */\n  getSurface3dControls() {\n    return {\n      setSurfaceDragMode: (mode: string) => this.setSurfaceDragMode(mode),\n      resetSurfaceCamera: () => this.resetSurfaceCamera(),\n    };\n  }\n\n  public setSurfaceDragMode(mode: string) {\n    if (this.plotDiv) {\n      Plotly.relayout(this.plotDiv, { 'scene.dragmode': mode } as any);\n    }\n  }\n\n  public resetSurfaceCamera() {\n    if (this.plotDiv) {\n      Plotly.relayout(this.plotDiv, { 'scene.camera': {} } as any);\n    }\n  }\n\n  /** Re-render a high-def zoom crop in the plot type on screen. Without this the\n   *  re-fetch always fell back to a heatmap, so zooming in contour (or any\n   *  registry type) reverted to heatmap. */\n  private renderZoomCrop(\n    frame: any[],\n    ratios: number[],\n    size: [number, number],\n    imageSize: number[],\n    fileName?: string,\n  ): { rendered: Promise<unknown>; reapplyRange: boolean } {\n    const impl = PLOTLY_PLOT_TYPE_IMPLS[this.plotType];\n    const target: FramePlot = {\n      plotDiv: this.plotDiv,\n      urls: this.urls,\n      frames: [frame],\n      trueImgSize: imageSize,\n      ratios,\n      screenHeight: this.screenHeight,\n    };\n    const rendered = impl\n      ? this.plotViaRegistry(\n          this.plotDiv,\n          impl,\n          this.buildTraceInput(\n            this.imageInfo,\n            {\n              data: [frame],\n              ratios,\n              sizes: size,\n              filename: fileName,\n            },\n            imageSize,\n          ),\n          this.screenHeight,\n        )\n      : this.imageInfo?.isGrayscale\n        ? this.plotHeatmap(target)\n        : this.plotRGBHeatmap(target, size[0], size[1]);\n    // plotViaRegistry already applies the type's own layout/range for non-image\n    // layouts (chart/overlay); only the image-aligned paths re-apply the range.\n    return { rendered, reapplyRange: !impl || impl.layoutKind === '2d-image' };\n  }\n\n  public setPlotType(plotType: PlotType) {\n    this.plotType = plotType;\n  }\n\n  private setImageInfo(showStack?: boolean, scaleratio?: boolean) {\n    // Nothing plotted yet (a host's first view is an image-less spatial dataset): there is no\n    // image to describe, so nothing to re-plot — stop the spinner rather than throw.\n    if (!this.trueImgSize) {\n      this.state.setImageLoading(false);\n      return;\n    }\n    // Build a partial image descriptor and push it to the host via the port.\n    const imgInfo: Partial<IImageInfo> = {\n      isGrayscale: this.imageInfo?.isGrayscale,\n      trueImageSize: [this.trueImgSize[1], this.trueImgSize[3]],\n      urls: this.urls,\n      isStack: this.urls.length > 1,\n      scaleRatio: scaleratio !== undefined ? scaleratio : this.scaleratio,\n    };\n    if (showStack !== undefined) imgInfo.showStack = showStack;\n    if (this.fileName) imgInfo.fileName = this.fileName;\n    this.state.setImageInfo(imgInfo);\n  }\n\n  /**\n   * Switch the active image. The shared RegionStore owns the per-image region\n   * cache (snapshot outgoing / restore incoming / clear selection / emit); we\n   * delegate to it, then re-project the store's regions into Plotly's dict\n   * working-set. Re-projecting unconditionally (even when the store no-ops for\n   * the same image) means Plotly also picks up regions another backend (OSD)\n   * added while it was off-screen. The switch is not redrawn onto the plot on\n   * screen — that still shows the outgoing image, and the next plot draws the\n   * incoming one's shapes. Called from `plot()` and from the router before any\n   * backend renders.\n   */\n  public setActiveImage(imageInfo: IImageInfo) {\n    this.shapeProjection.quietly(() => this.regionStore.setActiveImage(imageInfo));\n    this.shapeProjection.syncFromStore();\n  }\n\n  /** The plot div while it hosts a live Plotly graph, else null. `plotDiv`\n   *  stays set after purgePlot() hands the div to another backend (OSD,\n   *  napari-js), and Plotly.relayout/restyle throw on a non-Plotly div. */\n  private liveGd(): any | null {\n    const gd: any = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n    return gd?._fullLayout ? gd : null;\n  }\n\n  /** The live state an image-aligned layout is built from. */\n  private layoutContext(): ImageLayoutContext {\n    return {\n      screenHeight: this.screenHeight,\n      scaleratio: this.scaleratio,\n      dragMode: this.dragMode,\n      shapes: this.currentRenderShapes(this.regionStore.getShowShapeLabel()),\n      fillColor: this.regionStore.getFillColor(),\n      shapeColor: this.regionStore.getShapeColor(),\n    };\n  }\n\n  private getHeatmapLayout(xRange: number[], yRange: number[]): any {\n    return heatmapLayout(this.layoutContext(), xRange, yRange, this.imageLength);\n  }\n\n  /**\n   * Get the currently displayed image as an image-js Image instance.\n   * Used by the processing pipeline to obtain the input image.\n   */\n  public async getCurrentImage(): Promise<Image | null> {\n    if (!this.imageInfo || !this.imageInfo.urls || this.imageInfo.urls.length === 0) {\n      return null;\n    }\n    const zIdx = this.zIndex.value || 0;\n    const url = this.imageInfo.urls[zIdx] || this.imageInfo.urls[0];\n    return this.loader.loadImage(url);\n  }\n\n  /**\n   * Get the currently displayed plot pixel data as a flat Uint8ClampedArray.\n   * This captures whatever is actually rendered — including zoomed regions.\n   * Returns { width, height, channels, data } or null if no plot is displayed.\n   */\n  public getDisplayedPixelData(): PixelData | null {\n    const gd: any = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n    if (!gd?.data || gd.data.length === 0) return null;\n    const index = gd.data[this.activeFrameIndex()] ? this.activeFrameIndex() : 0;\n    // A trace drawn from a `source` has no `z`: its pixels are the channel display's.\n    return tracePixels(gd.data[index]) ?? this.recolor.displayedPixels(index);\n  }\n\n  /** The image rect the displayed `z` grid covers, in full-image pixel coords —\n   *  read off the live axis ranges (a high-def zoom relays them out to the crop),\n   *  else the whole image (see axesSourceRect). */\n  public getDisplayedSourceRect(): { x: number; y: number; width: number; height: number } | null {\n    const gd: any = this.plotDiv ? document.getElementById(this.plotDiv) : null;\n    return axesSourceRect(gd?._fullLayout?.xaxis?.range, gd?._fullLayout?.yaxis?.range, this.trueImgSize);\n  }\n\n  public reset() {\n    this.renderGen++;\n    this.recolor.clear();\n    this.intensity.supersede();\n    if (this.plotDiv) {\n      Plotly.newPlot(this.plotDiv, [], this.getHeatmapLayout([0, 100], [100, 0]), CONFIG as any);\n    }\n  }\n\n  /**\n   * Fully remove Plotly's DOM from the plot div (axes included). Used when\n   * handing the div to another backend (OpenSeadragon) — unlike `reset()`,\n   * which re-renders an empty plot and would leave the Plotly axes showing.\n   */\n  public purgePlot() {\n    this.renderGen++;\n    this.recolor.clear();\n    if (this.plotDiv) {\n      Plotly.purge(this.plotDiv);\n    }\n  }\n\n  /** Export the heatmap as a PNG (the rendered plot already reflects the active\n   *  colormap/window). The full-res tile composite is OSD's job. */\n  public exportComposite(): void {\n    this.downloadImage();\n  }\n\n  public downloadImage() {\n    if (this.plotDiv) {\n      void Plotly.downloadImage(this.plotDiv, { format: 'png', filename: this.fileName || 'image' });\n    }\n  }\n\n  public resetAxes() {\n    this.zoom.resetAxes();\n  }\n\n  public setDragMode(mode: string | false) {\n    this.dragMode = mode ? (mode as string) : '';\n    if (!this.plotDiv) return;\n    // Only relayout a LIVE Plotly graph. When another backend (OSD / napari-js) owns the view the\n    // div id is still set but has no Plotly plot attached, and Plotly.relayout throws\n    // (\"can't access property _guiEditing, n is undefined\"). That throw aborted the caller\n    // (deactivateActiveTool → onSelectPlotType) before the re-plot ran, wedging the plot type\n    // (e.g. stuck switching napari volume ↔ isosurface). Guard on `_fullLayout` like the zoom\n    // helpers do so it safely no-ops when Plotly isn't the active renderer.\n    const gd = document.getElementById(this.plotDiv) as unknown as { _fullLayout?: unknown } | null;\n    if (!gd?._fullLayout) return;\n    Plotly.relayout(this.plotDiv, { dragmode: mode } as any);\n  }\n\n  public zoomIn() {\n    this.zoom.zoomIn();\n  }\n\n  public zoomOut() {\n    this.zoom.zoomOut();\n  }\n\n  public isStackLoading$(): Observable<boolean> {\n    return this.loader.stackLoading$.asObservable();\n  }\n  public setStackLoading(stackLoading: boolean) {\n    this.loader.stackLoading$.next(stackLoading);\n  }\n  public getStackLoadingProgress$(): Observable<number> {\n    return this.loader.stackLoadingProgress$.asObservable();\n  }\n\n  // Colormap / reverse-scale state lives in the shared VisualizerStore (the\n  // base class forwards the getters); these setters add the Plotly-specific\n  // live restyle as render glue.\n  override setColormap(colormap: ColormapNode) {\n    super.setColormap(colormap);\n    const gd = this.liveGd(); // OSD/napari recolor via their own LUT\n    const scale = colormap.data?.value;\n    if (gd && scale != null) void Plotly.restyle(gd, { colorscale: [scale] } as Plotly.Data);\n  }\n\n  override setReverseScale(reverscale: boolean) {\n    super.setReverseScale(reverscale);\n    const gd = this.liveGd(); // OSD/napari recolor via their own LUT\n    if (gd) void Plotly.restyle(gd, { reversescale: reverscale });\n  }\n\n  setShowStack(showstack: boolean) {\n    if (!showstack) {\n      this.zIndex.next(0);\n    }\n    if (this.imageInfo) this.imageInfo.showStack = showstack;\n    this.loader.stackLoading$.next(showstack);\n    Plotly.relayout(this.plotDiv, { showstack: showstack } as any);\n  }\n\n  getAutoscaleEvent() {\n    return this.autoscaleEvent.asObservable();\n  }\n\n  setZIndex(zIndex: number) {\n    this.zIndex.next(zIndex);\n  }\n\n  /**\n   * Unsubscribe Subscriptions\n   */\n  unsubscribe() {\n    this.imageCachedSubscription?.unsubscribe();\n    this.imageCachedSubscription = undefined;\n    this.filenameSubscription?.unsubscribe();\n    this.filenameSubscription = undefined;\n    this.channelSub?.unsubscribe();\n    this.channelSub = undefined;\n    if (this.recolorFrame != null) cancelAnimationFrame(this.recolorFrame);\n    this.recolorFrame = null;\n  }\n\n  /** Live-apply the channel display window (zmin/zmax) + reverse/invert to the\n   *  heatmap — or, for a colour image's `image` trace, recomposite it per channel\n   *  (PlotlyImageRecolor). No-op when no Plotly plot is mounted (OSD owns the div). */\n  private applyChannelDisplay(channels: any[], rev: boolean, inv: boolean): void {\n    const gd = this.liveGd();\n    if (!gd) return;\n    if (this.recolor.active) {\n      this.scheduleRecolor();\n      return;\n    }\n    void Plotly.restyle(\n      gd,\n      channelDisplayRestyle(\n        channels,\n        rev,\n        inv,\n        this.store.currentColormap()?.data?.value,\n        this.plotType,\n      ) as Plotly.Data,\n    );\n  }\n\n  /**\n   * Recolour the slice on screen on the next frame: a slider drag in the dialog\n   * emits per step, and coalescing them keeps one recomposite per frame — and\n   * none while the previous one is still encoding (see recolorShownFrame).\n   */\n  private scheduleRecolor(): void {\n    if (this.recolorFrame != null) return;\n    this.recolorFrame = requestAnimationFrame(() => {\n      this.recolorFrame = null;\n      void this.recolorShownFrame(this.activeFrameIndex());\n    });\n  }\n\n  /** Restyle trace `index`'s `source` into the current channel display, unless it shows it\n   *  already. One picture at a time: an edit made while one encodes is drawn after it, in the\n   *  state current by then. */\n  private async recolorShownFrame(index: number): Promise<void> {\n    if (this.recoloring) {\n      this.recolorAgain = true;\n      return;\n    }\n    this.recoloring = true;\n    try {\n      const source = await this.recolor.frame(index);\n      const gd = this.liveGd();\n      if (source && gd) await Plotly.restyle(gd, { source: [source] } as Plotly.Data, [index]);\n    } catch (err) {\n      console.warn('[plotly] channel display update failed', err);\n    } finally {\n      this.recoloring = false;\n    }\n    if (this.recolorAgain) {\n      this.recolorAgain = false;\n      void this.recolorShownFrame(this.activeFrameIndex());\n    }\n  }\n\n  /** Binned intensity histogram for a channel from the cached source frames\n   *  (raw, pre-LUT). Grayscale cells are numbers; RGB cells are [r,g,b]; a\n   *  serverless multichannel stack bins the channel's own raw plane. */\n  getHistogram(channelIndex: number, _bins: number): IHistogram | null {\n    const frames = this.cachedImageFrames;\n    if (!frames?.length) return null;\n    const plane = this.cachedChannelPlanes?.[this.activeFrameIndex()]?.[channelIndex];\n    if (plane) return planeHistogram(plane);\n    const frame = frames[this.activeFrameIndex()] ?? frames[0];\n    if (!frame?.length) return null;\n    return frameHistogram(frame, channelIndex);\n  }\n\n  /** Async histogram stream — Plotly renders heatmap frame data (already in\n   *  memory, 8-bit luminance), so this just wraps the synchronous 8-bit\n   *  histogram. Native 16-bit histograms only apply to the OSD tile path. */\n  getHistogram$(channelIndex: number, bins: number): Observable<IHistogram | null> {\n    return of(this.getHistogram(channelIndex, bins));\n  }\n\n  /** Data export (16-bit TIFF) is an OSD-tile-path feature backed by the server.\n   *  Plotly renders heatmaps from frame data, so there's nothing to export here. */\n  exportData(): void {\n    console.warn('[plotly] 16-bit data export is not available for the heatmap backend.');\n  }\n\n  /** As the base class, but the file is named after the image on screen. */\n  override exportRegions(regions: Region[]) {\n    this.regionStore.exportRegions(regions, this.fileName);\n  }\n\n  getStackLoadingProgress() {\n    return this.getStackLoadingProgress$();\n  }\n\n  isStackLoading() {\n    return this.isStackLoading$();\n  }\n}\n"]}