copper3d 3.0.0 → 3.0.2

package/dist/types/Utils/segmentation/coreTools/coreType.d.ts

@@ -1,3 +1,25 @@
+/** Tool mode types for segmentation tools */
+type ToolMode = "pencil" | "brush" | "eraser" | "sphere" | "calculator";
+/** Metadata for a GUI slider/control — used by Vue components to configure slider UI */
+interface IGuiMeta {
+    min: number;
+    max: number;
+    step: number;
+    value: number;
+}
+/** Callbacks for external notification of annotation data changes */
+interface IAnnotationCallbacks {
+    onMaskChanged(sliceData: Uint8Array, layerId: string, channelId: number, sliceIndex: number, axis: "x" | "y" | "z", width: number, height: number, clearFlag: boolean): void;
+    onSphereChanged(sphereOrigin: number[], sphereRadius: number): void;
+    onCalculatorPositionsChanged(tumour: ICommXYZ | null, skin: ICommXYZ | null, rib: ICommXYZ | null, nipple: ICommXYZ | null, axis: "x" | "y" | "z"): void;
+    onLayerVolumeCleared(layerId: string): void;
+    onChannelColorChanged(layerId: string, channel: number, color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }): void;
+}
 interface ICommXYZ {
     x: any;
     y: any;
@@ -12,14 +34,14 @@ interface ISkipSlicesDictType {
 }
 interface IDownloadImageConfig {
     axis: "x" | "y" | "z";
-    currentIndex: number;
+    currentSliceIndex: number;
     drawingCanvas: HTMLCanvasElement;
     originWidth: number;
     originHeight: number;
 }
 interface IConvertObjType {
-    currentIndex: number;
-    oldIndex: number;
+    currentNewSliceIndex: number;
+    preSliceIndex: number;
     convertCursorNumX: number;
     convertCursorNumY: number;
 }
@@ -99,12 +121,9 @@ interface IProtected {
     skipSlicesDic: ISkipSlicesDictType;
     currentShowingSlice: any;
     mainPreSlices: any;
-    Is_Shift_Pressed: boolean;
-    Is_Ctrl_Pressed: boolean;
-    Is_Draw: boolean;
+    isDrawing: boolean;
     axis: "x" | "y" | "z";
     maskData: IMaskData;
-    previousDrawingImage?: ImageData;
     /** Dynamic per-layer canvas+ctx pairs. Replaces hardcoded LayerOne/Two/Three fields. */
     layerTargets: Map<string, ILayerRenderTarget>;
     canvases: {
@@ -123,31 +142,34 @@ interface IProtected {
         drawingLayerMasterCtx: CanvasRenderingContext2D;
     };
 }
-interface IGUIStates {
-    mainAreaSize: number;
-    dragSensitivity: number;
-    Eraser: boolean;
+/** Tool mode flags — which tool is currently active */
+interface IToolModeState {
+    pencil: boolean;
+    eraser: boolean;
+    sphere: boolean;
+    activeSphereType: "tumour" | "skin" | "nipple" | "ribcage";
+}
+/** Drawing configuration — brush/pencil appearance and behavior */
+interface IDrawingConfig {
     globalAlpha: number;
     lineWidth: number;
     color: string;
-    pencil: boolean;
     fillColor: string;
     brushColor: string;
     brushAndEraserSize: number;
+}
+/** View configuration — UI layout and interaction parameters */
+interface IViewConfig {
+    mainAreaSize: number;
+    dragSensitivity: number;
     cursor: string;
-    layer: string;
-    cal_distance: "tumour" | "skin" | "nipple" | "ribcage";
-    sphere: boolean;
-    calculator: boolean;
-    readyToUpdate: boolean;
     defaultPaintCursor: string;
     max_sensitive: number;
-    clear: () => void;
-    clearAll: () => void;
-    undo: () => void;
-    redo: () => void;
-    downloadCurrentMask: () => void;
-    resetZoom: () => void;
+    readyToUpdate: boolean;
+}
+/** Layer/channel state — active layer, channel, and visibility */
+interface ILayerChannelState {
+    layer: string;
     /** Currently active channel (1-8). Channel 0 is transparent/erased. */
     activeChannel: number;
     /** Layer visibility state: { layer1: true, layer2: true, layer3: true } */
@@ -155,15 +177,19 @@ interface IGUIStates {
     /** Per-layer channel visibility: { layer1: { 1: true, ..., 8: true }, ... } */
     channelVisibility: Record<string, Record<number, boolean>>;
 }
+interface IGUIStates extends IToolModeState, IDrawingConfig, IViewConfig, ILayerChannelState {
+}
 interface IKeyBoardSettings {
     draw: string;
     undo: string;
     redo: string;
     contrast: string[];
     crosshair: string;
+    sphere: string;
     mouseWheel: "Scroll:Zoom" | "Scroll:Slice";
 }
-interface INrrdStates {
+/** Image metadata — set once during NRRD loading, read-only at runtime */
+interface IImageMetadata {
     originWidth: number;
     originHeight: number;
     nrrd_x_mm: number;
@@ -172,56 +198,57 @@ interface INrrdStates {
     nrrd_x_pixel: number;
     nrrd_y_pixel: number;
     nrrd_z_pixel: number;
+    dimensions: number[];
+    voxelSpacing: number[];
+    spaceOrigin: number[];
+    RSARatio: number;
+    ratios: ICommXYZ;
+    layers: string[];
+}
+/** View state — runtime display/navigation state */
+interface IViewState {
     changedWidth: number;
     changedHeight: number;
-    oldIndex: number;
-    currentIndex: number;
+    currentSliceIndex: number;
+    preSliceIndex: number;
     maxIndex: number;
     minIndex: number;
-    RSARatio: number;
-    voxelSpacing: number[];
-    spaceOrigin: number[];
-    dimensions: number[];
-    loadMaskJson: boolean;
-    ratios: ICommXYZ;
     contrastNum: number;
+    sizeFactor: number;
     showContrast: boolean;
-    enableCursorChoose: boolean;
-    isCursorSelect: boolean;
+    switchSliceFlag: boolean;
+    previousPanelL: number;
+    previousPanelT: number;
+}
+/** Interaction state — mouse/cursor tracking */
+interface IInteractionState {
+    mouseOverX: number;
+    mouseOverY: number;
+    mouseOver: boolean;
     cursorPageX: number;
     cursorPageY: number;
+    isCursorSelect: boolean;
+    drawStartPos: ICommXY;
+}
+/** Sphere state — SphereTool-specific data */
+interface ISphereState {
     sphereOrigin: ICommXYZ;
     tumourSphereOrigin: ICommXYZ | null;
     skinSphereOrigin: ICommXYZ | null;
     ribSphereOrigin: ICommXYZ | null;
     nippleSphereOrigin: ICommXYZ | null;
-    tumourColor: "#00ff00";
-    skinColor: "#FFEB3B";
-    ribcageColor: "#2196F3";
-    nippleColor: "#E91E63";
-    spherePlanB: boolean;
+    /** Dedicated MaskVolume for SphereTool 3D sphere data. Type is `any` to avoid circular deps. */
+    sphereMaskVolume: any;
     sphereRadius: number;
-    Mouse_Over_x: number;
-    Mouse_Over_y: number;
-    Mouse_Over: boolean;
+}
+/** Internal flags — transient operational flags */
+interface IInternalFlags {
     stepClear: number;
-    sizeFoctor: number;
     clearAllFlag: boolean;
-    previousPanelL: number;
-    previousPanelT: number;
-    switchSliceFlag: boolean;
-    layers: string[];
-    getMask: (sliceData: Uint8Array, layerId: string, channelId: number, sliceIndex: number, axis: "x" | "y" | "z", width: number, height: number, clearFlag: boolean) => void;
-    onClearLayerVolume: (layerId: string) => void;
-    onChannelColorChanged: (layerId: string, channel: number, color: {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-    }) => void;
-    getSphere: (sphereOrigin: number[], sphereRadius: number) => void;
-    getCalculateSpherePositions: (tumourSphereOrigin: ICommXYZ | null, skinSphereOrigin: ICommXYZ | null, ribSphereOrigin: ICommXYZ | null, nippleSphereOrigin: ICommXYZ | null, aixs: "x" | "y" | "z") => void;
-    drawStartPos: ICommXY;
+    loadingMaskData: boolean;
+}
+/** Legacy flat interface — kept for backward compatibility during migration */
+interface INrrdStates extends IImageMetadata, IViewState, IInteractionState, ISphereState, IInternalFlags {
 }
 interface IDragOpts {
     showNumber?: boolean;
@@ -275,15 +302,11 @@ interface IGuiParameterSettings {
         step: number;
         onChange: () => void;
     };
-    Eraser: {
+    eraser: {
         name: "Eraser";
         onChange: () => void;
     };
-    calculator: {
-        name: "Calculator";
-        onChange: () => void;
-    };
-    cal_distance: {
+    activeSphereType: {
         name: "CalculatorDistance";
         onChange: (val: "tumour" | "skin" | "ribcage" | "nipple") => void;
     };
@@ -363,4 +386,4 @@ interface IGuiParameterSettings {
         };
     };
 }
-export { ICommXYZ, ICommXY, IDownloadImageConfig, IConvertObjType, IDragPrameters, IDrawingEvents, IContrastEvents, IProtected, IGUIStates, IDragOpts, IDrawOpts, INrrdStates, IPaintImage, IPaintImages, ISkipSlicesDictType, IMaskData, INewMaskData, ILayerRenderTarget, ICursorPage, IGuiParameterSettings, IKeyBoardSettings };
+export { ToolMode, IGuiMeta, IAnnotationCallbacks, ICommXYZ, ICommXY, IDownloadImageConfig, IConvertObjType, IDragPrameters, IDrawingEvents, IContrastEvents, IProtected, IGUIStates, IToolModeState, IDrawingConfig, IViewConfig, ILayerChannelState, IDragOpts, IDrawOpts, INrrdStates, IImageMetadata, IViewState, IInteractionState, ISphereState, IInternalFlags, IPaintImage, IPaintImages, ISkipSlicesDictType, IMaskData, INewMaskData, ILayerRenderTarget, ICursorPage, IGuiParameterSettings, IKeyBoardSettings };

package/dist/types/Utils/segmentation/coreTools/gui.d.ts

@@ -1,11 +1,13 @@
 import { GUI } from "dat.gui";
-import { IDrawingEvents, IGUIStates, IProtected, INrrdStates, IPaintImages, IPaintImage, IGuiParameterSettings } from "./coreType";
+import { IDrawingEvents, IProtected, IGuiParameterSettings } from "./coreType";
+import type { GuiState } from "./GuiState";
+import { NrrdState } from "./NrrdState";
 import { DragOperator } from "../DragOperator";
 interface IConfigGUI {
     modeFolder: GUI;
     dragOperator: DragOperator;
-    nrrd_states: INrrdStates;
-    gui_states: IGUIStates;
+    nrrd_states: NrrdState;
+    gui_states: GuiState;
     drawingCanvas: HTMLCanvasElement;
     drawingPrameters: IDrawingEvents;
     protectedData: IProtected;
@@ -15,8 +17,8 @@ interface IConfigGUI {
     mainPreSlices: any;
     removeDragMode: () => void;
     configDragMode: () => void;
-    clearPaint: () => void;
-    clearStoreImages: () => void;
+    clearActiveSlice: () => void;
+    clearActiveLayer: () => void;
     updateSlicesContrast: (value: number, flag: string) => void;
     setMainAreaSize: (factor: number) => void;
     resetPaintAreaUIPosition: () => void;
@@ -26,14 +28,15 @@ interface IConfigGUI {
     resetLayerCanvas: () => void;
     redrawDisplayCanvas: () => void;
     flipDisplayImageByAxis: () => void;
-    filterDrawedImage: (axis: "x" | "y" | "z", sliceIndex: number) => IPaintImage | undefined;
     setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
-    storeAllImages: (index: number, layer: string) => void;
+    syncLayerSliceData: (index: number, layer: string) => void;
     drawImageOnEmptyImage: (canvas: HTMLCanvasElement) => void;
-    storeEachLayerImage: (index: number, layer: string) => void;
-    storeImageToLayer: (index: number, canvas: HTMLCanvasElement, paintedImages: IPaintImages) => ImageData;
     getRestLayer: () => string[];
     setIsDrawFalse: (target: number) => void;
+    undoLastPainting: () => void;
+    redoLastPainting: () => void;
+    resetZoom: () => void;
+    downloadCurrentMask: () => void;
 }
 declare function setupGui(configs: IConfigGUI): IGuiParameterSettings;
 declare function removeGuiFolderChilden(modeFolder: GUI): void;

package/dist/types/Utils/segmentation/eventRouter/EventRouter.d.ts

@@ -72,6 +72,8 @@ export declare class EventRouter {
     setGuiTool(tool: GuiTool): void;
     /**
      * Toggle crosshair mode.
+     * Allowed in drawing tools AND sphere mode.
+     * Blocked when draw or contrast mode is active, or left button is held (mutual exclusion).
      */
     toggleCrosshair(): void;
     /**

package/dist/types/Utils/segmentation/eventRouter/types.d.ts

@@ -12,14 +12,13 @@
  * - `contrast`: Ctrl held, left-drag adjusts window/level
  * - `crosshair`: Crosshair mode enabled (C key toggle)
  * - `sphere`: Sphere placement tool active
- * - `calculator`: Distance calculator tool active
  * - `pan`: Right-drag panning the canvas
  */
-export type InteractionMode = 'idle' | 'draw' | 'drag' | 'contrast' | 'crosshair' | 'sphere' | 'calculator' | 'pan';
+export type InteractionMode = 'idle' | 'draw' | 'drag' | 'contrast' | 'crosshair' | 'sphere' | 'pan';
 /**
  * GUI tool selection (set from UI buttons)
  */
-export type GuiTool = 'pencil' | 'brush' | 'eraser' | 'sphere' | 'calculator';
+export type GuiTool = 'pencil' | 'brush' | 'eraser' | 'sphere';
 /**
  * Keyboard event handler type
  */
@@ -56,6 +55,7 @@ export interface KeyboardSettings {
     redo: string;
     contrast: string[];
     crosshair: string;
+    sphere: string;
     mouseWheel: 'Scroll:Zoom' | 'Scroll:Slice';
 }
 /**

package/dist/types/Utils/segmentation/tools/BaseTool.d.ts

@@ -1,22 +1,28 @@
 /**
  * BaseTool - Abstract base for extracted DrawToolCore tools
  *
- * Provides shared access to the legacy state objects (nrrd_states,
- * gui_states, protectedData) via a ToolContext interface.
+ * Provides shared access to state objects via a ToolContext interface.
  *
  * NOTE: This is for the OLD DrawToolCore system.
  * The new SegmentationManager system has its own tools in manager/tools/.
  */
-import type { INrrdStates, IGUIStates, IProtected, ICursorPage } from "../coreTools/coreType";
+import type { IProtected, ICursorPage, IAnnotationCallbacks } from "../coreTools/coreType";
+import type { NrrdState } from "../coreTools/NrrdState";
+import type { GuiState } from "../coreTools/GuiState";
+import type { EventRouter } from "../eventRouter/EventRouter";
 /**
  * Shared context injected into every legacy tool.
  * References are shared (not copied), so tools see the same state.
  */
 export interface ToolContext {
-    nrrd_states: INrrdStates;
-    gui_states: IGUIStates;
+    nrrd_states: NrrdState;
+    gui_states: GuiState;
     protectedData: IProtected;
     cursorPage: ICursorPage;
+    /** External annotation callbacks (Phase 2) */
+    callbacks: IAnnotationCallbacks;
+    /** EventRouter reference for mode/state queries. Set after initDrawToolCore(). */
+    eventRouter?: EventRouter;
 }
 export declare abstract class BaseTool {
     protected ctx: ToolContext;

package/dist/types/Utils/segmentation/tools/DragSliceTool.d.ts

@@ -18,6 +18,8 @@ export interface DragSliceCallbacks {
     setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
     getOrCreateSliceBuffer: (axis: "x" | "y" | "z") => ImageData | null;
     renderSliceToCanvas: (layer: string, axis: "x" | "y" | "z", sliceIndex: number, buffer: ImageData, targetCtx: CanvasRenderingContext2D, scaledWidth: number, scaledHeight: number) => void;
+    /** Refresh sphere overlay from sphereMaskVolume after slice change. */
+    refreshSphereOverlay?: () => void;
 }
 interface IDragEffectCanvases {
     drawingCanvasLayerMaster: HTMLCanvasElement;

package/dist/types/Utils/segmentation/tools/DrawingTool.d.ts

@@ -0,0 +1,93 @@
+/**
+ * DrawingTool - Pencil/Brush/Eraser drawing on canvas layers
+ *
+ * Extracted from DrawToolCore.paintOnCanvas() closure (Phase 3).
+ * Handles left-click drawing operations: pencil stroke + fill, brush strokes,
+ * eraser, and undo snapshot capture/push.
+ */
+import { BaseTool } from "./BaseTool";
+import type { ToolContext } from "./BaseTool";
+import type { MaskDelta } from "../core";
+/**
+ * Callbacks DrawingTool needs from its host (DrawToolCore).
+ */
+export interface DrawingCallbacks {
+    /** Get current layer's canvas and 2D context */
+    setCurrentLayer: () => {
+        ctx: CanvasRenderingContext2D;
+        canvas: HTMLCanvasElement;
+    };
+    /** Composite all layers to master canvas */
+    compositeAllLayers: () => void;
+    /** Sync layer slice data to MaskVolume */
+    syncLayerSliceData: (index: number, layer: string) => void;
+    /** Get stored image data for previous image redraw */
+    filterDrawedImage: (axis: "x" | "y" | "z", index: number) => {
+        image: ImageData;
+    } | undefined;
+    /** Get MaskVolume for a layer (undo snapshots) */
+    getVolumeForLayer: (layer: string) => any;
+    /** Push delta to UndoManager */
+    pushUndoDelta: (delta: MaskDelta) => void;
+    /** Get eraser icon URLs */
+    getEraserUrls: () => string[];
+}
+export declare class DrawingTool extends BaseTool {
+    /** Left mouse button currently held (draw mode) */
+    private leftClicked;
+    /** True while actively painting (between pointerdown and pointerup) */
+    private isPainting;
+    /** Accumulated pencil stroke points for fill-on-release */
+    private drawingLines;
+    /** Eraser arc function, assigned once per paintOnCanvas() call */
+    private clearArcFn;
+    /** Snapshot of the active layer's slice captured on mouse-down (before drawing) */
+    private preDrawSlice;
+    private preDrawAxis;
+    private preDrawSliceIndex;
+    private callbacks;
+    constructor(ctx: ToolContext, callbacks: DrawingCallbacks);
+    /** Whether a draw operation is currently active */
+    get isActive(): boolean;
+    /** Whether paint strokes are being recorded */
+    get painting(): boolean;
+    /**
+     * Reset drawing state. Called at start of each paintOnCanvas() cycle.
+     * @param clearArcFn - Eraser function for this paint cycle
+     */
+    reset(clearArcFn: (x: number, y: number, size: number) => void): void;
+    /**
+     * Called on left-click pointerdown in draw mode.
+     * Sets up drawing state, cursor, undo snapshot, and start position.
+     */
+    onPointerDown(e: MouseEvent): void;
+    /**
+     * Called on pointermove during an active drawing operation.
+     * Handles eraser clearing or brush/pencil stroke accumulation.
+     */
+    onPointerMove(e: MouseEvent): void;
+    /**
+     * Called on pointerup in draw mode.
+     * Completes stroke, fills pencil path, syncs volume, pushes undo delta.
+     */
+    onPointerUp(_e: MouseEvent): void;
+    /**
+     * Called on pointerleave during drawing.
+     * Resets painting state and cleans up leftClicked.
+     * @returns true if drawing was in progress when leave occurred
+     */
+    onPointerLeave(): boolean;
+    /** Capture pre-draw slice snapshot for undo */
+    private capturePreDrawSnapshot;
+    /** Push delta to UndoManager after drawing completes */
+    private pushUndoDelta;
+    /**
+     * Redraws persisted layer data onto ctx before new pencil fill.
+     * Extracted from DrawToolCore.
+     */
+    private redrawPreviousImageToLayerCtx;
+    /** Draw a line segment on a layer canvas */
+    private drawLinesOnLayer;
+    /** Paint a segment on the current layer canvas and composite to master */
+    private paintOnCanvasLayer;
+}

package/dist/types/Utils/segmentation/tools/ImageStoreHelper.d.ts

@@ -2,14 +2,12 @@
  * ImageStoreHelper - Cross-axis image storage
  *
  * Extracted from DrawToolCore.ts:
- * - storeAllImages / storeImageToAxis / storeImageToLayer / storeEachLayerImage
+ * - syncLayerSliceData
  *
- * Phase 2 Day 7: Updated to write/read MaskVolume alongside legacy IPaintImages.
- * Volume is the primary storage; IPaintImages kept for backward compatibility.
+ * Phase 3: MaskVolume is the sole storage backend. All IPaintImages params removed.
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
-import type { IPaintImage, IPaintImages } from "../coreTools/coreType";
 export interface ImageStoreCallbacks {
     setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
     drawImageOnEmptyImage: (canvas: HTMLCanvasElement) => void;
@@ -25,41 +23,23 @@ export declare class ImageStoreHelper extends BaseTool {
      * @returns MaskVolume for the given layer, or layer1 as fallback
      */
     private getVolumeForLayer;
-    /**
-     * Get MaskVolume for the currently active layer.
-     */
-    private getCurrentVolume;
     /**
      * Get the canvas element for a specific layer.
      */
     private getCanvasForLayer;
     /**
-     * Phase 3: Simplified to be a no-op.
-     * MaskVolume storage happens in storeAllImages via setSliceFromImageData.
-     * This method kept for backward compatibility with existing call sites.
-     */
-    storeImageToAxis(_index: number, _paintedImages: IPaintImages, _imageData: ImageData, _axis?: "x" | "y" | "z"): void;
-    /**
-     * Retrieve the drawn image for a given axis and slice.
+     * Vertically flip an ImageData buffer in-place (swap rows top↔bottom).
      *
-     * Phase 3: Reads exclusively from MaskVolume (no legacy fallback).
-     */
-    filterDrawedImage(axis: "x" | "y" | "z", sliceIndex: number, _paintedImages: IPaintImages): IPaintImage | undefined;
-    /**
-     * Store all layer images for the current slice (cross-axis sync).
-     *
-     * Phase 2: Also writes into the current layer's MaskVolume.
-     */
-    storeAllImages(index: number, layer: string): void;
-    /**
-     * Store a single layer's canvas data to its MaskVolume.
-     * Reads from the individual layer canvas (not master) and uses RGB→channel reverse lookup.
+     * Used to compensate for the Z-axis direction reversal between sagittal
+     * and coronal views. On coronal, Z runs along the canvas j-axis (vertical),
+     * and the display flip (scale(1,-1)) reverses Z relative to sagittal's
+     * horizontal Z mapping. This row-swap aligns the Z ordering so that
+     * MaskVolume stores data in a consistent coordinate system.
      */
-    storeEachLayerImage(index: number, layer: string): void;
+    private flipImageDataVertically;
     /**
-     * Phase 3: Simplified - extracts ImageData from canvas but no longer stores to paintImages.
-     * Kept for backward compatibility with existing call sites.
+     * Sync the current layer canvas to its MaskVolume slice and notify the parent
+     * via getMask. This is the primary write path after any draw/erase operation.
      */
-    storeImageToLayer(_index: number, canvas: HTMLCanvasElement, _paintedImages: IPaintImages): ImageData;
-    private hasNonZeroPixels;
+    syncLayerSliceData(index: number, layer: string): void;
 }

package/dist/types/Utils/segmentation/tools/PanTool.d.ts

@@ -0,0 +1,53 @@
+/**
+ * PanTool - Right-click pan/drag navigation
+ *
+ * Extracted from DrawToolCore.paintOnCanvas() closure.
+ * Handles right-click drag to reposition the canvas view.
+ */
+import { BaseTool } from "./BaseTool";
+import type { ToolContext } from "./BaseTool";
+/**
+ * Callbacks PanTool needs from its host (DrawToolCore).
+ */
+export interface PanCallbacks {
+    /** Re-enable zoom wheel after pan ends in sphere mode */
+    zoomActionAfterDrawSphere: () => void;
+}
+export declare class PanTool extends BaseTool {
+    /** Right mouse button currently held */
+    private rightClicked;
+    /** Pan drag offset X (clientX − canvas.offsetLeft at drag start) */
+    private panMoveInnerX;
+    /** Pan drag offset Y (clientY − canvas.offsetTop at drag start) */
+    private panMoveInnerY;
+    private callbacks;
+    /**
+     * Bound handler reference for pointermove so we can add/remove it.
+     * Arrow function preserves `this` binding.
+     */
+    private readonly boundPointerMove;
+    constructor(ctx: ToolContext, callbacks: PanCallbacks);
+    /** Whether a pan drag is currently active */
+    get isActive(): boolean;
+    /**
+     * Called on right-click pointerdown.
+     * Captures initial offsets and registers pointermove listener.
+     */
+    onPointerDown(e: MouseEvent): void;
+    /**
+     * Called on pointerup (button === 2).
+     * Cleans up listeners and restores cursor.
+     */
+    onPointerUp(e: MouseEvent, defaultCursor: string): void;
+    /**
+     * Called on pointerleave while pan is active.
+     * Resets state and removes listener.
+     */
+    onPointerLeave(): void;
+    /** Reset pan state (called when paintOnCanvas re-initializes) */
+    reset(): void;
+    /**
+     * Pointermove handler — updates canvas position during drag.
+     */
+    private handlePointerMove;
+}