@ue-too/board 0.9.5 → 0.10.0

package/input-interpretation/input-state-machine/kmt-input-state-machine.d.ts

@@ -1,36 +1,60 @@
-import { EventReactions, EventGuards, Guard, TemplateState, TemplateStateMachine, EventArgs, EventHandledResult, CreateStateType } from "@ue-too/being";
+import { EventReactions, EventGuards, Guard, TemplateState, TemplateStateMachine, EventArgs, EventResult, CreateStateType } from "@ue-too/being";
 import type { Point } from "@ue-too/math";
-import { Canvas, KmtInputContext } from "./kmt-input-context";
+import { CursorStyle, KmtInputContext } from "./kmt-input-context";
 declare const KMT_INPUT_STATES: readonly ["IDLE", "READY_TO_PAN_VIA_SPACEBAR", "READY_TO_PAN_VIA_SCROLL_WHEEL", "PAN", "INITIAL_PAN", "PAN_VIA_SCROLL_WHEEL", "DISABLED"];
 /**
- * @description The possible states of the keyboard mouse and trackpad input state machine.
+ * Possible states of the Keyboard/Mouse/Trackpad input state machine.
  *
- * @category Input State Machine
+ * @remarks
+ * State transitions:
+ * - **IDLE**: Default state, waiting for user input
+ * - **READY_TO_PAN_VIA_SPACEBAR**: Spacebar pressed, ready to pan with left-click drag
+ * - **INITIAL_PAN**: First frame of pan via spacebar (detects accidental clicks)
+ * - **PAN**: Active panning via spacebar + left-click drag
+ * - **READY_TO_PAN_VIA_SCROLL_WHEEL**: Middle mouse button pressed, ready to pan
+ * - **PAN_VIA_SCROLL_WHEEL**: Active panning via middle-click drag
+ * - **DISABLED**: Input temporarily disabled (e.g., during UI interactions)
+ *
+ * @category Input State Machine - KMT
  */
 export type KmtInputStates = CreateStateType<typeof KMT_INPUT_STATES>;
 /**
- * @description The payload for the pointer event.
+ * Payload for pointer events (mouse button press/release/move).
  *
- * @category Input State Machine
+ * @property x - X coordinate in window space
+ * @property y - Y coordinate in window space
+ *
+ * @category Input State Machine - KMT
  */
 export type PointerEventPayload = {
     x: number;
     y: number;
 };
+/**
+ * @internal
+ */
 type EmptyPayload = {};
 /**
- * @description The payload for the scroll event.
+ * Payload for scroll wheel events.
  *
- * @category Input State Machine
+ * @property deltaX - Horizontal scroll delta
+ * @property deltaY - Vertical scroll delta
+ *
+ * @category Input State Machine - KMT
  */
 export type ScrollEventPayload = {
     deltaX: number;
     deltaY: number;
 };
 /**
- * @description The payload for the scroll with ctrl event.
+ * Payload for scroll events combined with ctrl key (zoom gesture).
  *
- * @category Input State Machine
+ * @property deltaX - Horizontal scroll delta
+ * @property deltaY - Vertical scroll delta
+ * @property x - Cursor X coordinate in window space (zoom anchor point)
+ * @property y - Cursor Y coordinate in window space (zoom anchor point)
+ *
+ * @category Input State Machine - KMT
  */
 export type ScrollWithCtrlEventPayload = {
     deltaX: number;
@@ -39,9 +63,21 @@ export type ScrollWithCtrlEventPayload = {
     y: number;
 };
 /**
- * @description The payload mapping for the events of the keyboard mouse and trackpad input state machine.
+ * Event mapping for the KMT input state machine.
  *
- * @category Input State Machine
+ * @remarks
+ * Maps event names to their payload types. Used by the state machine framework
+ * to provide type-safe event handling.
+ *
+ * Key events:
+ * - **leftPointerDown/Up/Move**: Left mouse button interactions
+ * - **middlePointerDown/Up/Move**: Middle mouse button interactions (pan)
+ * - **spacebarDown/Up**: Spacebar for pan mode
+ * - **scroll**: Regular scroll (pan or zoom depending on device)
+ * - **scrollWithCtrl**: Ctrl + scroll (always zoom)
+ * - **disable/enable**: Temporarily disable/enable input processing
+ *
+ * @category Input State Machine - KMT
  */
 export type KmtInputEventMapping = {
     leftPointerDown: PointerEventPayload;
@@ -51,7 +87,7 @@ export type KmtInputEventMapping = {
     spacebarUp: EmptyPayload;
     stayIdle: EmptyPayload;
     cursorOnElement: EmptyPayload;
-    scroll: ScrollEventPayload;
+    scroll: ScrollWithCtrlEventPayload;
     scrollWithCtrl: ScrollWithCtrlEventPayload;
     middlePointerDown: PointerEventPayload;
     middlePointerUp: PointerEventPayload;
@@ -61,82 +97,116 @@ export type KmtInputEventMapping = {
     pointerMove: PointerEventPayload;
 };
 /**
- * @description Converts the point from window coordinates(browser) to view port coordinates.
+ * Output events produced by the KMT state machine for the orchestrator.
  *
- * @category Input State Machine
+ * @remarks
+ * These high-level gesture events are the result of recognizing patterns in raw DOM events.
+ * The orchestrator receives these events and coordinates camera control and observer notification.
+ *
+ * **Event Types**:
+ * - **pan**: Camera translation with delta in viewport coordinates
+ * - **zoom**: Camera scale change with anchor point in viewport coordinates
+ * - **rotate**: Camera rotation change (currently unused in KMT)
+ * - **cursor**: Cursor style change request (handled by state uponEnter/beforeExit)
+ * - **none**: No action required
+ *
+ * **Coordinate Spaces**:
+ * - Pan delta is in viewport pixels
+ * - Zoom anchor point is in viewport coordinates (origin at viewport center)
+ *
+ * @category Input State Machine - KMT
  */
-export declare function convertFromWindow2ViewPort(point: Point, canvas: HTMLCanvasElement): Point;
-export declare function convertFromWindow2ViewPortWithCanvasOperator(point: Point, canvasOperator: Canvas): Point;
-export declare function convertFromWindow2ViewPortCanvasOperator(point: Point, canvasOperator: Canvas): Point;
+export type KmtOutputEvent = {
+    type: "pan";
+    delta: Point;
+} | {
+    type: "zoom";
+    delta: number;
+    anchorPointInViewPort: Point;
+} | {
+    type: "rotate";
+    deltaRotation: number;
+} | {
+    type: "cursor";
+    style: CursorStyle;
+} | {
+    type: "none";
+};
 /**
- * @description The possible target states of the idle state.
+ * Mapping of events to their output types.
  *
- * @category Input State Machine
+ * @remarks
+ * Defines which events produce outputs. Not all events produce outputs - some only
+ * cause state transitions. This mapping is used by the state machine framework for
+ * type-safe output handling.
+ *
+ * @category Input State Machine - KMT
+ */
+export type KmtInputEventOutputMapping = {
+    spacebarDown: number;
+    middlePointerMove: KmtOutputEvent;
+    scroll: KmtOutputEvent;
+    scrollWithCtrl: KmtOutputEvent;
+    leftPointerMove: KmtOutputEvent;
+};
+/**
+ * @internal
  */
 export type KmtIdleStatePossibleTargetStates = "IDLE" | "READY_TO_PAN_VIA_SPACEBAR" | "READY_TO_PAN_VIA_SCROLL_WHEEL" | "DISABLED";
 /**
- * @description The idle state of the keyboard mouse and trackpad input state machine.
+ * IDLE state - default state waiting for user input.
  *
- * @category Input State Machine
+ * @remarks
+ * This is the default state of the KMT input state machine. It handles scroll events
+ * for panning and zooming, and transitions to pan-ready states when the user presses
+ * spacebar or middle-click.
+ *
+ * **Responsibilities**:
+ * - Process scroll events (pan or zoom depending on device and modifiers)
+ * - Detect spacebar press to enter pan mode
+ * - Detect middle-click to enter pan mode
+ * - Distinguish between mouse and trackpad input modalities
+ *
+ * **Scroll Behavior**:
+ * - Ctrl + Scroll: Always zoom (both mouse and trackpad)
+ * - Scroll (no Ctrl): Pan (trackpad) or Zoom (mouse, determined by modality detection)
+ *
+ * **Input Modality Detection**:
+ * The state tracks horizontal scroll deltas to distinguish trackpads (which produce deltaX)
+ * from mice (which typically only produce deltaY). This affects zoom behavior.
+ *
+ * @category Input State Machine - KMT
  */
-export declare class KmtIdleState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class KmtIdleState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     constructor();
     protected _guards: Guard<KmtInputContext, "isIdle">;
     protected _eventGuards: Partial<EventGuards<KmtInputEventMapping, KmtInputStates, KmtInputContext, Guard<KmtInputContext>>>;
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
-    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    scrollPan: (context: KmtInputContext, payload: ScrollEventPayload) => KmtOutputEvent;
+    scrollZoom: (context: KmtInputContext, payload: ScrollWithCtrlEventPayload) => KmtOutputEvent;
+    scrollHandler: (context: KmtInputContext, payload: ScrollWithCtrlEventPayload) => KmtOutputEvent;
+    scrollWithCtrlHandler: (context: KmtInputContext, payload: ScrollWithCtrlEventPayload) => KmtOutputEvent;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
     uponEnter(context: KmtInputContext): void;
-    scrollHandler(context: KmtInputContext, payload: ScrollEventPayload): void;
-    scrollWithCtrlHandler(context: KmtInputContext, payload: ScrollWithCtrlEventPayload): void;
-    spacebarDownHandler(context: KmtInputContext, payload: EmptyPayload): void;
+    spacebarDownHandler(context: KmtInputContext, payload: EmptyPayload): number;
     middlePointerDownHandler(context: KmtInputContext, payload: PointerEventPayload): void;
-    pointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
 }
-/**
- * @description The possible target states of the ready to select state.
- *
- * @category Input State Machine
- */
-export type ReadyToSelectStatePossibleTargetStates = "IDLE" | "SELECTING" | "DISABLED";
-/**
- * @description The context for the ready to select state.
- *
- * @category Input State Machine
- */
-export type SelectionContext = {
-    setSelectionEndPoint: (point: Point) => void;
-    toggleSelectionBox: (show: boolean) => void;
-    cleanup: () => void;
-    setup: () => void;
-    canvas: HTMLCanvasElement;
-};
-/**
- * @description The ready to select state of the keyboard mouse and trackpad input state machine.
- *
- * @category Input State Machine
- */
-export declare class ReadyToSelectState extends TemplateState<KmtInputEventMapping, SelectionContext, ReadyToSelectStatePossibleTargetStates> {
-    constructor();
-    leftPointerMove: (context: SelectionContext, payload: PointerEventPayload) => void;
-    protected _eventReactions: EventReactions<KmtInputEventMapping, SelectionContext, ReadyToSelectStatePossibleTargetStates>;
-    get eventReactions(): EventReactions<KmtInputEventMapping, SelectionContext, ReadyToSelectStatePossibleTargetStates>;
-}
-export declare class DisabledState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class DisabledState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     constructor();
     uponEnter(context: KmtInputContext): void;
     beforeExit(context: KmtInputContext): void;
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
 }
 /**
  * @description The ready to pan via space bar state of the keyboard mouse and trackpad input state machine.
  *
  * @category Input State Machine
  */
-export declare class ReadyToPanViaSpaceBarState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class ReadyToPanViaSpaceBarState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     constructor();
-    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
     uponEnter(context: KmtInputContext): void;
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
     leftPointerDownHandler(context: KmtInputContext, payload: PointerEventPayload): void;
 }
 /**
@@ -144,22 +214,22 @@ export declare class ReadyToPanViaSpaceBarState extends TemplateState<KmtInputEv
  *
  * @category Input State Machine
  */
-export declare class InitialPanState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class InitialPanState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     constructor();
-    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
     uponEnter(context: KmtInputContext): void;
-    leftPointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+    leftPointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): KmtOutputEvent;
 }
 /**
  * @description The ready to pan via scroll wheel state of the keyboard mouse and trackpad input state machine.
  *
  * @category Input State Machine
  */
-export declare class ReadyToPanViaScrollWheelState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class ReadyToPanViaScrollWheelState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     constructor();
-    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
     uponEnter(context: KmtInputContext): void;
 }
 /**
@@ -167,39 +237,85 @@ export declare class ReadyToPanViaScrollWheelState extends TemplateState<KmtInpu
  *
  * @category Input State Machine
  */
-export declare class PanState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class PanState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     constructor();
-    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
     uponEnter(context: KmtInputContext): void;
     beforeExit(context: KmtInputContext): void;
-    leftPointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+    leftPointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): KmtOutputEvent;
 }
 /**
  * @description The pan via scroll wheel state of the keyboard mouse and trackpad input state machine.
  *
  * @category Input State Machine
  */
-export declare class PanViaScrollWheelState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
-    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
-    middlePointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): void;
+export declare class PanViaScrollWheelState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
+    protected _eventReactions: EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
+    middlePointerMoveHandler(context: KmtInputContext, payload: PointerEventPayload): KmtOutputEvent;
     uponEnter(context: KmtInputContext): void;
 }
-export declare class KmtEmptyState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class KmtEmptyState extends TemplateState<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     constructor();
-    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
+    get eventReactions(): EventReactions<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
 }
-export type KmtInputStateMachine = TemplateStateMachine<KmtInputEventMapping, KmtInputContext, KmtInputStates>;
 /**
- * @description Creates the keyboard mouse and trackpad input state machine.
+ * Type alias for the KMT input state machine.
  *
- * @category Input State Machine
+ * @category Input State Machine - KMT
+ */
+export type KmtInputStateMachine = TemplateStateMachine<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping>;
+/**
+ * Creates a new KMT (Keyboard/Mouse/Trackpad) input state machine.
+ *
+ * @param context - The context providing state and canvas access for the state machine
+ * @returns A configured state machine ready to process KMT input events
+ *
+ * @remarks
+ * This factory function creates a fully configured state machine with all KMT gesture
+ * recognition states. The state machine processes raw input events and produces
+ * high-level gesture outputs (pan, zoom, rotate).
+ *
+ * **State Flow**:
+ * ```
+ * IDLE → (spacebar) → READY_TO_PAN_VIA_SPACEBAR → (click) → INITIAL_PAN → PAN
+ * IDLE → (middle-click) → READY_TO_PAN_VIA_SCROLL_WHEEL → PAN_VIA_SCROLL_WHEEL
+ * IDLE → (scroll) → [produces pan or zoom output, stays in IDLE]
+ * ```
+ *
+ * **Gesture Recognition**:
+ * - **Pan via spacebar**: Spacebar + left-click drag
+ * - **Pan via middle-click**: Middle-click drag
+ * - **Zoom**: Ctrl + scroll (mouse) or scroll (trackpad, auto-detected)
+ * - **Pan via scroll**: Scroll (trackpad) or scroll without Ctrl (varies by device)
+ *
+ * @category Input State Machine - KMT
+ *
+ * @example
+ * ```typescript
+ * const canvasProxy = new CanvasProxy(canvasElement);
+ * const context = new ObservableInputTracker(canvasProxy);
+ * const stateMachine = createKmtInputStateMachine(context);
+ *
+ * // Process an event
+ * const result = stateMachine.happens("scroll", {
+ *   deltaX: 0,
+ *   deltaY: 10,
+ *   x: 500,
+ *   y: 300
+ * });
+ *
+ * // Check for output
+ * if (result.output) {
+ *   console.log("Gesture recognized:", result.output.type);
+ * }
+ * ```
  */
 export declare function createKmtInputStateMachine(context: KmtInputContext): KmtInputStateMachine;
-export declare class KmtInputStateMachineWebWorkerProxy extends TemplateStateMachine<KmtInputEventMapping, KmtInputContext, KmtInputStates> {
+export declare class KmtInputStateMachineWebWorkerProxy extends TemplateStateMachine<KmtInputEventMapping, KmtInputContext, KmtInputStates, KmtInputEventOutputMapping> {
     private _webworker;
     constructor(webworker: Worker);
-    happens(...args: EventArgs<KmtInputEventMapping, keyof KmtInputEventMapping | string>): EventHandledResult<KmtInputStates>;
+    happens(...args: EventArgs<KmtInputEventMapping, keyof KmtInputEventMapping | string>): EventResult<KmtInputStates>;
 }
 export {};

package/input-interpretation/input-state-machine/touch-input-context.d.ts

@@ -1,41 +1,107 @@
-import type { Point } from "@ue-too/math";
-import { RawUserInputPublisher } from "../raw-input-publisher";
 import { BaseContext } from "@ue-too/being";
 import { Canvas } from "./kmt-input-context";
 /**
- * @description The touch points.
+ * Represents a single touch point in window coordinates.
  *
- * @category Input State Machine
+ * @property ident - The unique identifier for this touch point (from TouchEvent.identifier)
+ * @property x - X coordinate in window space
+ * @property y - Y coordinate in window space
+ *
+ * @remarks
+ * Touch points are tracked by their identifiers to maintain consistency across touch events.
+ * Each finger/contact point maintains its identifier for the duration of the touch interaction.
+ *
+ * @category Input State Machine - Touch
  */
 export type TouchPoints = {
     ident: number;
     x: number;
     y: number;
 };
+/**
+ * Context interface for the touch input state machine.
+ *
+ * @remarks
+ * This context manages the state required for multi-touch gesture recognition:
+ *
+ * **Touch Point Tracking**:
+ * - Maintains a map of active touch points by identifier
+ * - Stores initial positions to calculate deltas for pan gestures
+ * - Stores initial distances to calculate zoom factors
+ *
+ * **Gesture Recognition**:
+ * - Single-finger: Not handled (reserved for UI interactions)
+ * - Two-finger: Pan and pinch-to-zoom gestures
+ * - Three+ fingers: Currently not handled
+ *
+ * **Coordinate System**:
+ * Similar to KMT, the `alignCoordinateSystem` flag controls Y-axis orientation.
+ *
+ * This interface extends BaseContext from the @ue-too/being state machine library.
+ *
+ * @category Input State Machine - Touch
+ */
 export interface TouchContext extends BaseContext {
+    /** Adds new touch points to tracking */
     addTouchPoints: (points: TouchPoints[]) => void;
+    /** Removes touch points from tracking by identifier */
     removeTouchPoints: (idents: number[]) => void;
+    /** Returns the current number of active touch points */
     getCurrentTouchPointsCount: () => number;
+    /** Retrieves the initial positions of specific touch points */
     getInitialTouchPointsPositions: (idents: number[]) => TouchPoints[];
+    /** Updates the current positions of touch points */
     updateTouchPoints: (pointsMoved: TouchPoints[]) => void;
-    notifyOnPan: (delta: Point) => void;
-    notifyOnZoom: (zoomAmount: number, anchorPoint: Point) => void;
+    /** Whether to use standard screen coordinate system (vs inverted Y-axis) */
     alignCoordinateSystem: boolean;
+    /** Canvas accessor for dimensions and coordinate transformations */
     canvas: Canvas;
 }
+/**
+ * Production implementation of TouchContext that tracks multi-touch state.
+ *
+ * @remarks
+ * This class maintains a map of active touch points, storing their initial positions
+ * to enable gesture recognition. The state machine uses this context to:
+ *
+ * - Calculate pan deltas (difference between initial and current midpoint)
+ * - Calculate zoom factors (change in distance between two touch points)
+ * - Determine gesture type (pan vs zoom based on relative magnitudes)
+ *
+ * **Touch Point Lifecycle**:
+ * 1. `addTouchPoints`: Called on touchstart to register new touches
+ * 2. `updateTouchPoints`: Called on touchmove to update current positions
+ * 3. `removeTouchPoints`: Called on touchend/touchcancel to unregister touches
+ *
+ * The initial positions are preserved until the touch ends, allowing continuous
+ * calculation of deltas throughout the gesture.
+ *
+ * @category Input State Machine - Touch
+ *
+ * @example
+ * ```typescript
+ * const canvasProxy = new CanvasProxy(canvasElement);
+ * const context = new TouchInputTracker(canvasProxy);
+ * const stateMachine = createTouchInputStateMachine(context);
+ *
+ * // When a two-finger touch starts
+ * context.addTouchPoints([
+ *   {ident: 0, x: 100, y: 200},
+ *   {ident: 1, x: 300, y: 200}
+ * ]);
+ * console.log(context.getCurrentTouchPointsCount()); // 2
+ * ```
+ */
 export declare class TouchInputTracker implements TouchContext {
-    private _inputPublisher;
     private _touchPointsMap;
     private _canvas;
     private _alignCoordinateSystem;
-    constructor(canvas: Canvas, inputPublisher: RawUserInputPublisher);
+    constructor(canvas: Canvas);
     addTouchPoints(points: TouchPoints[]): void;
     removeTouchPoints(identifiers: number[]): void;
     getCurrentTouchPointsCount(): number;
     getInitialTouchPointsPositions(idents: number[]): TouchPoints[];
     updateTouchPoints(pointsMoved: TouchPoints[]): void;
-    notifyOnPan(delta: Point): void;
-    notifyOnZoom(zoomAmount: number, anchorPoint: Point): void;
     get alignCoordinateSystem(): boolean;
     set alignCoordinateSystem(value: boolean);
     get canvas(): Canvas;