@ggts-sh/svelte 0.43.0

package/dist/surface/brush-finish.js

@@ -0,0 +1,44 @@
+import { evaluatePointerBrushEnd, } from "./area-brush.js";
+/**
+ * Pure routing after brush-end evaluation for pointer finish-brush and
+ * keyboard complete-area.
+ *
+ * Takes the full ended discriminant so actions carry rect/corners payloads —
+ * host must not re-narrow `ended.kind` for emit/apply.
+ *
+ * Priority:
+ *   1. keep-second-corner — too-small (wins for any tool); carries corners
+ *   2. select-end — commit + select-area; carries rect
+ *   3. zoom-end — commit + zoom-area; carries rect
+ *   4. end-area — commit + any other tool (clear draft + cancel-area, no emit)
+ *
+ * Host on keep-second-corner: brushRect = action.corners, announce, no cancel-area.
+ * Host on select-end/zoom-end/end-area: brushRect=null, cancel-area; emit/apply
+ * using action.rect when present.
+ *
+ * Keyboard complete-area always supplies `kind: "commit"` (no free-corner
+ * too-small evaluation); pointer uses `resolvePointerFinishBrushAction`.
+ */
+export function resolveFinishBrushAction(input) {
+    if (input.ended.kind === "too-small") {
+        return { type: "keep-second-corner", corners: input.ended.corners };
+    }
+    if (input.activeTool === "select-area") {
+        return { type: "select-end", rect: input.ended.rect };
+    }
+    if (input.activeTool === "zoom-area") {
+        return { type: "zoom-end", rect: input.ended.rect };
+    }
+    return { type: "end-area" };
+}
+/**
+ * Compose free-corner evaluation + finish routing for pointer finish-brush.
+ * Host supplies draft corners and the up event plot point; pure owns too-small
+ * vs commit and select/zoom/end payloads.
+ */
+export function resolvePointerFinishBrushAction(input) {
+    return resolveFinishBrushAction({
+        ended: evaluatePointerBrushEnd(input.brushCorners, input.endPoint),
+        activeTool: input.activeTool,
+    });
+}

package/dist/surface/keyboard.d.ts

@@ -0,0 +1,97 @@
+import { type InteractionTool } from "../interaction/interaction.js";
+import { type BrushCorners, type PlotPoint } from "./area-brush.js";
+import { type PanelBounds } from "../scene/geometry.js";
+import { type FinishBrushAction } from "./brush-finish.js";
+/**
+ * Capture-surface keyboard decision input.
+ *
+ * `brushCorners` is the sole draft source of truth (host: `brushRect`).
+ * Distinct from reducer `brushing`, which can diverge when the draft corners
+ * and area machine are out of sync. Null means no draft — no separate
+ * `hasBrushDraft` boolean so illegal combos are unrepresentable.
+ */
+export type SurfaceKeyboardInput = {
+    readonly key: string;
+    readonly shiftKey: boolean;
+    readonly activeTool: InteractionTool;
+    /**
+     * Host: `brushRect`. Non-null when a draft free corner exists.
+     * Gates nudge-brush, complete-area, and Escape returnToInspect.
+     */
+    readonly brushCorners: BrushCorners | null;
+    readonly hasInspection: boolean;
+    readonly pinEnabled: boolean;
+    /**
+     * Inspection focus key when `hasInspection` (host: `inspection?.focus.key ?? null`).
+     * Meaningful only for `toggle-point-keys`; unused on other actions.
+     */
+    readonly focusKey: PropertyKey | null;
+    /**
+     * Inspection sourceKeys when `hasInspection` (host: `inspection?.focus.sourceKeys ?? []`).
+     * Meaningful only for `toggle-point-keys`; unused on other actions.
+     */
+    readonly sourceKeys: readonly PropertyKey[];
+    /**
+     * Host: `inspection?.focus.anchor ?? null`.
+     * Meaningful for `begin-area` (preferred over firstPanel center).
+     */
+    readonly inspectionAnchor: PlotPoint | null;
+    /**
+     * Host: panel containing inspection focus anchor, or null.
+     * Preferred clamp panel for nudge-brush over `firstPanel`.
+     */
+    readonly inspectionPanel: PanelBounds | null;
+    /**
+     * Host: first semantic-viewport panel bounds (`panelBoundsFrom(viewport.panels[0].bounds)`).
+     * Panel-center fallback for `begin-area` when no inspection anchor; also
+     * nudge clamp fallback after inspectionPanel (#1038).
+     */
+    readonly firstPanel: PanelBounds | undefined;
+};
+type SurfaceKeyAction = {
+    readonly type: "nudge-brush";
+    /** Clamped draft after free-corner nudge; host assigns brushRect. */
+    readonly corners: BrushCorners;
+} | {
+    readonly type: "begin-area";
+    /** Inspection anchor if present, else panel center (or {0,0}). */
+    readonly anchor: PlotPoint;
+} | {
+    /**
+     * Pure table owns normalize + select/zoom/end routing (shared finish
+     * owner with pointer). Keyboard always commits the current draft
+     * (`kind: "commit"`) — no free-corner too-small evaluation.
+     */
+    readonly type: "complete-area";
+    readonly finish: FinishBrushAction;
+} | {
+    readonly type: "cycle-coincident";
+    readonly delta: 1 | -1;
+} | {
+    readonly type: "navigate-direction";
+    readonly dx: number;
+    readonly dy: number;
+} | {
+    readonly type: "toggle-point-keys";
+    /** Keys to toggle: `[focusKey]` when non-null, else `sourceKeys`. */
+    readonly keys: readonly PropertyKey[];
+} | {
+    readonly type: "toggle-pin";
+} | {
+    readonly type: "escape";
+    readonly returnToInspect: boolean;
+} | {
+    readonly type: "none";
+};
+type SurfaceKeyResolution = {
+    readonly action: SurfaceKeyAction;
+    readonly preventDefault: boolean;
+};
+/**
+ * Pure decision table for the plot capture-surface `keydown` handler.
+ * Preserves existing priority: area draft arrows → area Enter/Space →
+ * coincident cycle → inspect arrows → point toggle → pin → Escape.
+ * Callers own side effects (brush mutation, inspection, tool changes).
+ */
+export declare function resolveSurfaceKeyAction(input: SurfaceKeyboardInput): SurfaceKeyResolution;
+export {};

package/dist/surface/keyboard.js

@@ -0,0 +1,105 @@
+import { isAreaTool } from "../interaction/interaction.js";
+import { nudgeBrushEnd, panelCenterAnchor, } from "./area-brush.js";
+import { normalizedRect } from "../scene/geometry.js";
+import { resolveFinishBrushAction } from "./brush-finish.js";
+function arrowDelta(key, step) {
+    const horizontal = key === "ArrowLeft" ? -step : key === "ArrowRight" ? step : 0;
+    const vertical = key === "ArrowUp" ? -step : key === "ArrowDown" ? step : 0;
+    return { x: horizontal, y: vertical };
+}
+function resolveAreaArrow(input) {
+    const panel = input.inspectionPanel ?? input.firstPanel;
+    if (panel === undefined || input.brushCorners === null) {
+        return { preventDefault: true, action: { type: "none" } };
+    }
+    const { x: dx, y: dy } = arrowDelta(input.key, input.shiftKey ? 10 : 1);
+    return {
+        preventDefault: true,
+        action: {
+            type: "nudge-brush",
+            corners: nudgeBrushEnd(input.brushCorners, dx, dy, panel),
+        },
+    };
+}
+function resolveAreaCommit(input) {
+    const action = input.brushCorners === null
+        ? {
+            type: "begin-area",
+            anchor: input.inspectionAnchor ?? panelCenterAnchor(input.firstPanel),
+        }
+        : {
+            type: "complete-area",
+            finish: resolveFinishBrushAction({
+                ended: { kind: "commit", rect: normalizedRect(input.brushCorners) },
+                activeTool: input.activeTool,
+            }),
+        };
+    return { preventDefault: true, action };
+}
+function resolveInspectionActivation(input) {
+    if (input.activeTool === "point" && input.hasInspection) {
+        return {
+            preventDefault: true,
+            action: {
+                type: "toggle-point-keys",
+                keys: input.focusKey === null ? input.sourceKeys : [input.focusKey],
+            },
+        };
+    }
+    if (input.hasInspection && input.pinEnabled) {
+        return { preventDefault: true, action: { type: "toggle-pin" } };
+    }
+    return null;
+}
+/**
+ * Pure decision table for the plot capture-surface `keydown` handler.
+ * Preserves existing priority: area draft arrows → area Enter/Space →
+ * coincident cycle → inspect arrows → point toggle → pin → Escape.
+ * Callers own side effects (brush mutation, inspection, tool changes).
+ */
+export function resolveSurfaceKeyAction(input) {
+    const { key, activeTool, brushCorners } = input;
+    const area = isAreaTool(activeTool);
+    const hasDraft = brushCorners !== null;
+    if (area && key.startsWith("Arrow") && hasDraft) {
+        return resolveAreaArrow(input);
+    }
+    if (area && (key === "Enter" || key === " ")) {
+        return resolveAreaCommit(input);
+    }
+    if (key === "]" || key === "[") {
+        return {
+            preventDefault: true,
+            action: {
+                type: "cycle-coincident",
+                delta: key === "]" ? 1 : -1,
+            },
+        };
+    }
+    if (key.startsWith("Arrow")) {
+        const { x: dx, y: dy } = arrowDelta(key, 1);
+        return {
+            preventDefault: true,
+            action: {
+                type: "navigate-direction",
+                dx,
+                dy,
+            },
+        };
+    }
+    if (key === "Enter" || key === " ") {
+        const activation = resolveInspectionActivation(input);
+        if (activation !== null)
+            return activation;
+    }
+    if (key === "Escape") {
+        return {
+            preventDefault: true,
+            action: {
+                type: "escape",
+                returnToInspect: !hasDraft && area,
+            },
+        };
+    }
+    return { preventDefault: false, action: { type: "none" } };
+}

package/dist/surface/pointer.d.ts

@@ -0,0 +1,241 @@
+import { type InteractionTool } from "../interaction/interaction.js";
+import { type BrushCorners, type PlotPoint } from "./area-brush.js";
+import { type FinishBrushAction } from "./brush-finish.js";
+/**
+ * Capture-surface pointer decision input for pointerdown.
+ *
+ * `brushCorners` is the sole draft source of truth (host: `brushRect`).
+ * Distinct from reducer `areaAwaitingSecond` — both must hold to extend.
+ * `point` is the down-event plot point (host always computes it).
+ */
+export type SurfacePointerDownInput = {
+    readonly pointerType: string;
+    readonly button: number;
+    readonly activeTool: InteractionTool;
+    /** Reducer "awaiting second corner" flag. */
+    readonly areaAwaitingSecond: boolean;
+    /**
+     * Host: `brushRect`. Non-null when a draft free corner exists.
+     * Extend only when combined with `areaAwaitingSecond`.
+     */
+    readonly brushCorners: BrushCorners | null;
+    /** Host: `plotPoint(event)` — always available on pointerdown. */
+    readonly point: PlotPoint;
+};
+export type SurfacePointerDownAction = {
+    readonly type: "touch-inspect-start";
+} | {
+    readonly type: "begin-area";
+    /**
+     * Pure-owned draft corners (fresh degenerate or extended free corner).
+     * Host assigns `brushRect = action.corners` without re-deriving policy.
+     */
+    readonly corners: BrushCorners;
+    /** Emit select-area start event (not zoom; not second-corner await). */
+    readonly emitSelectStart: boolean;
+    /** Interaction source for setInspection clear + select-start emission. */
+    readonly source: "touch" | "pointer";
+} | {
+    readonly type: "none";
+};
+/**
+ * Pure decision for the plot capture-surface `pointerdown` handler.
+ * Priority: touch-inspect start (before button/tool checks) → primary-button
+ * area begin/extend → none. Owns extend-vs-fresh corner policy via
+ * `initialBrushRect`. Callers own queued-inspection cancel, draft mutation,
+ * reducer dispatch, selection start emission, and capture.
+ */
+export declare function resolvePointerDownAction(input: SurfacePointerDownInput): SurfacePointerDownAction;
+/**
+ * Domain inspect snapshot for pointer move/up (host: resolved
+ * `interactionConfig.inspect`). Pass the domain object, not a pre-derived
+ * `inspectEnabled` boolean — matches inspection-state domain convention.
+ */
+type SurfaceInspectConfig = {
+    readonly mode: "auto" | "exact" | "x" | "y" | "xy";
+    readonly maxDistance: number;
+    readonly pin: boolean;
+} | null;
+/**
+ * Capture-surface pointerup decision input.
+ * Touch-inspect fields only matter when tool is inspect + pointer is touch.
+ *
+ * `brushCorners` is the sole draft source of truth for finish-brush (host:
+ * `brushRect`). Distinct from reducer `brushing`, which can diverge.
+ * `endPoint` is always the up-event plot point (host always computes it).
+ */
+export type SurfacePointerUpInput = {
+    readonly pointerType: string;
+    readonly activeTool: InteractionTool;
+    /** Host: resolved `interactionConfig.inspect`. */
+    readonly inspect: SurfaceInspectConfig;
+    readonly hasTouchInspectStart: boolean;
+    readonly touchInspectMoved: boolean;
+    /** Reducer brushing flag — can diverge from draft. */
+    readonly brushing: boolean;
+    /**
+     * Host: `brushRect`. Non-null when a draft free corner exists.
+     * Finish-brush requires both brushing and non-null corners.
+     */
+    readonly brushCorners: BrushCorners | null;
+    /** Host: `plotPoint(event)` — always available on pointerup. */
+    readonly endPoint: PlotPoint;
+};
+export type SurfacePointerUpAction = {
+    readonly type: "touch-inspect-tap";
+    /** Inspection state for setInspection (from inspect.pin). */
+    readonly state: "pinned" | "transient";
+    /** Nearest-query params from inspect snapshot at decision time. */
+    readonly mode: "auto" | "exact" | "x" | "y" | "xy";
+    readonly maxDistance: number;
+} | {
+    readonly type: "touch-inspect-drag-ignore";
+} | {
+    readonly type: "finish-brush";
+    /** Interaction source for selection/zoom emission. */
+    readonly source: "touch" | "pointer";
+    /**
+     * Pure-owned too-small/commit + select/zoom/end routing (shared with
+     * keyboard complete-area via surface/brush-finish).
+     */
+    readonly finish: FinishBrushAction;
+} | {
+    readonly type: "none";
+};
+/**
+ * Pure decision for the plot capture-surface `pointerup` handler.
+ * Priority: touch-inspect tap/drag → finish-brush (both brushing and draft)
+ * → none. Finish-brush carries the complete finish payload (too-small vs
+ * commit, select/zoom/end). Host cancels scheduled pointer then
+ * `applyFinishBrush(action.finish, action.source)`. Host always clears
+ * touch-inspect start state for both touch-inspect actions.
+ */
+export declare function resolvePointerUpAction(input: SurfacePointerUpInput): SurfacePointerUpAction;
+export type SurfaceClickInput = {
+    /** True when `performance.now() < suppressClickUntil`. */
+    readonly suppressClick: boolean;
+    readonly activeTool: InteractionTool;
+    /** True when interval/point select is configured as point. */
+    readonly pointSelectEnabled: boolean;
+    readonly inspectEnabled: boolean;
+    readonly pinEnabled: boolean;
+    readonly hasInspection: boolean;
+};
+export type SurfaceClickAction = {
+    readonly type: "suppress";
+} | {
+    readonly type: "toggle-point";
+} | {
+    readonly type: "toggle-pin";
+} | {
+    readonly type: "none";
+};
+/**
+ * Pure decision for the capture-surface click handler.
+ * Priority: suppress → point toggle → inspect pin toggle → none.
+ * Host clears the suppress timestamp when action is `suppress`.
+ */
+export declare function resolveCaptureClickAction(input: SurfaceClickInput): SurfaceClickAction;
+/** Pixel threshold for sticky touch-inspect drag (plotPoint coordinates). */
+export declare const TOUCH_INSPECT_MOVE_PX = 4;
+/**
+ * Suppress synthetic click after a successful touch-inspect tap (ms).
+ * Host: `suppressClickUntil = performance.now() + TOUCH_INSPECT_CLICK_SUPPRESS_MS`.
+ */
+export declare const TOUCH_INSPECT_CLICK_SUPPRESS_MS = 500;
+/**
+ * Nearest-candidate radius (plot px) for capture-surface point-tool click.
+ * Owned by `interaction/target` (#1080); re-exported here for existing
+ * surface-pointer unit tests and callers that import the constant from
+ * the pointer decision-table module.
+ */
+export { POINT_SELECT_NEAREST_MAX_DISTANCE_PX } from "../interaction/target.js";
+/**
+ * Sticky OR of touch-inspect drag past threshold in plotPoint coordinates.
+ * Exactly `TOUCH_INSPECT_MOVE_PX` counts as moved (`>=`).
+ * Host calls only when `pointerType === "touch" && touchInspectStart !== null`.
+ */
+export declare function advanceTouchInspectMoved(alreadyMoved: boolean, start: Readonly<{
+    x: number;
+    y: number;
+}>, point: Readonly<{
+    x: number;
+    y: number;
+}>): boolean;
+export type SurfacePointerMoveInput = {
+    readonly pointerType: string;
+    readonly activeTool: InteractionTool;
+    /** Host sticky flag after `advanceTouchInspectMoved` (or false if no touch start). */
+    readonly touchInspectMoved: boolean;
+    /** True when `touchInspectStart !== null`. */
+    readonly hasTouchInspectStart: boolean;
+    /** Reducer brushing flag — can diverge from draft. */
+    readonly brushing: boolean;
+    /** True when `brushRect !== null`. */
+    readonly hasBrushDraft: boolean;
+    /** Host: resolved `interactionConfig.inspect` (domain object, not a boolean). */
+    readonly inspect: SurfaceInspectConfig;
+};
+export type SurfacePointerMoveAction = {
+    readonly type: "touch-inspect-drag-cancel";
+} | {
+    readonly type: "queue-area-move";
+    readonly source: "touch" | "pointer";
+} | {
+    readonly type: "queue-inspect";
+    readonly source: "touch" | "pointer";
+    /** Nearest-query params from inspect snapshot at decision time. */
+    readonly mode: "auto" | "exact" | "x" | "y" | "xy";
+    readonly maxDistance: number;
+} | {
+    readonly type: "none";
+};
+/** Map a PointerEvent.pointerType string to InteractionSource surface values. */
+export declare function interactionSourceFromPointerType(pointerType: string): "touch" | "pointer";
+/**
+ * Pure decision for the plot capture-surface `pointermove` handler.
+ * Priority: touch-inspect drag cancel → queue area move → queue inspect → none.
+ *
+ * Cancel requires `pointerType === "touch"` (mouse/pen with residual start must
+ * not cancel). Cancel does **not** require inspect config — only the inspect
+ * tool, matching the current host.
+ *
+ * Host advances `touchInspectMoved` separately on touch+start before calling.
+ * Host on cancel: clear `queuedPointerInspection`, cancel scheduled pointer
+ * (`queuedPointerToken` left untouched). Host on queue-inspect: nearest with
+ * action.mode / action.maxDistance (no config re-read).
+ */
+export declare function resolvePointerMoveAction(input: SurfacePointerMoveInput): SurfacePointerMoveAction;
+/**
+ * Whether pointerleave should clear inspection after its microtask flush.
+ * Host must call this **inside** `queueMicrotask` so `brushing` and
+ * `tooltipHovered` reflect post-flush state (not leave-time snapshots).
+ */
+export declare function shouldClearInspectionOnPointerLeave(input: {
+    readonly brushing: boolean;
+    readonly tooltipHovered: boolean;
+}): boolean;
+/** Reducer area.kind values that the host may observe on lostpointercapture. */
+export type AreaKind = "idle" | "first-corner" | "dragging";
+/** True while an area brush session is active (not idle). */
+export declare function isAreaBrushing(areaKind: AreaKind): boolean;
+/** True while waiting for the second brush corner (keyboard / too-small path). */
+export declare function isAreaAwaitingSecond(areaKind: AreaKind): boolean;
+export type LostPointerCaptureAction = {
+    readonly type: "ignore";
+} | {
+    readonly type: "cancel-keep-draft";
+} | {
+    readonly type: "cancel-clear-draft";
+};
+/**
+ * Pure routing for capture-surface `lostpointercapture`.
+ *
+ * Takes reducer `area.kind` (not derived booleans) so illegal combos like
+ * `!brushing && areaAwaitingSecond` are unrepresentable.
+ *
+ *   idle         → ignore (no cancel-area)
+ *   first-corner → cancel-keep-draft (dispatch cancel-area; retain brushRect)
+ *   dragging     → cancel-clear-draft (clear brushRect + dispatch cancel-area)
+ */
+export declare function resolveLostPointerCaptureAction(areaKind: AreaKind): LostPointerCaptureAction;

package/dist/surface/pointer.js

@@ -0,0 +1,179 @@
+import { isAreaTool } from "../interaction/interaction.js";
+import { initialBrushRect } from "./area-brush.js";
+import { resolvePointerFinishBrushAction } from "./brush-finish.js";
+/**
+ * Pure decision for the plot capture-surface `pointerdown` handler.
+ * Priority: touch-inspect start (before button/tool checks) → primary-button
+ * area begin/extend → none. Owns extend-vs-fresh corner policy via
+ * `initialBrushRect`. Callers own queued-inspection cancel, draft mutation,
+ * reducer dispatch, selection start emission, and capture.
+ */
+export function resolvePointerDownAction(input) {
+    const { pointerType, button, activeTool, areaAwaitingSecond, brushCorners, point } = input;
+    if (activeTool === "inspect" && pointerType === "touch")
+        return { type: "touch-inspect-start" };
+    if (button !== 0)
+        return { type: "none" };
+    if (!isAreaTool(activeTool))
+        return { type: "none" };
+    return {
+        type: "begin-area",
+        corners: initialBrushRect({
+            areaAwaitingSecond,
+            existing: brushCorners,
+            point,
+        }),
+        emitSelectStart: activeTool === "select-area" && !areaAwaitingSecond,
+        source: interactionSourceFromPointerType(pointerType),
+    };
+}
+/**
+ * Pure decision for the plot capture-surface `pointerup` handler.
+ * Priority: touch-inspect tap/drag → finish-brush (both brushing and draft)
+ * → none. Finish-brush carries the complete finish payload (too-small vs
+ * commit, select/zoom/end). Host cancels scheduled pointer then
+ * `applyFinishBrush(action.finish, action.source)`. Host always clears
+ * touch-inspect start state for both touch-inspect actions.
+ */
+export function resolvePointerUpAction(input) {
+    const { pointerType, activeTool, inspect, hasTouchInspectStart, touchInspectMoved, brushing, brushCorners, endPoint, } = input;
+    if (activeTool === "inspect" &&
+        pointerType === "touch" &&
+        inspect !== null &&
+        hasTouchInspectStart) {
+        if (touchInspectMoved)
+            return { type: "touch-inspect-drag-ignore" };
+        return {
+            type: "touch-inspect-tap",
+            state: inspect.pin ? "pinned" : "transient",
+            mode: inspect.mode,
+            maxDistance: inspect.maxDistance,
+        };
+    }
+    if (!brushing || brushCorners === null)
+        return { type: "none" };
+    return {
+        type: "finish-brush",
+        source: interactionSourceFromPointerType(pointerType),
+        finish: resolvePointerFinishBrushAction({
+            brushCorners,
+            endPoint,
+            activeTool,
+        }),
+    };
+}
+/**
+ * Pure decision for the capture-surface click handler.
+ * Priority: suppress → point toggle → inspect pin toggle → none.
+ * Host clears the suppress timestamp when action is `suppress`.
+ */
+export function resolveCaptureClickAction(input) {
+    if (input.suppressClick)
+        return { type: "suppress" };
+    if (input.activeTool === "point" && input.pointSelectEnabled)
+        return { type: "toggle-point" };
+    if (input.activeTool === "inspect" &&
+        input.inspectEnabled &&
+        input.hasInspection &&
+        input.pinEnabled)
+        return { type: "toggle-pin" };
+    return { type: "none" };
+}
+// ---- pointer move ----
+/** Pixel threshold for sticky touch-inspect drag (plotPoint coordinates). */
+export const TOUCH_INSPECT_MOVE_PX = 4;
+/**
+ * Suppress synthetic click after a successful touch-inspect tap (ms).
+ * Host: `suppressClickUntil = performance.now() + TOUCH_INSPECT_CLICK_SUPPRESS_MS`.
+ */
+export const TOUCH_INSPECT_CLICK_SUPPRESS_MS = 500;
+/**
+ * Nearest-candidate radius (plot px) for capture-surface point-tool click.
+ * Owned by `interaction/target` (#1080); re-exported here for existing
+ * surface-pointer unit tests and callers that import the constant from
+ * the pointer decision-table module.
+ */
+export { POINT_SELECT_NEAREST_MAX_DISTANCE_PX } from "../interaction/target.js";
+/**
+ * Sticky OR of touch-inspect drag past threshold in plotPoint coordinates.
+ * Exactly `TOUCH_INSPECT_MOVE_PX` counts as moved (`>=`).
+ * Host calls only when `pointerType === "touch" && touchInspectStart !== null`.
+ */
+export function advanceTouchInspectMoved(alreadyMoved, start, point) {
+    if (alreadyMoved)
+        return true;
+    return Math.hypot(point.x - start.x, point.y - start.y) >= TOUCH_INSPECT_MOVE_PX;
+}
+/** Map a PointerEvent.pointerType string to InteractionSource surface values. */
+export function interactionSourceFromPointerType(pointerType) {
+    return pointerType === "touch" ? "touch" : "pointer";
+}
+const pointerSource = (pointerType) => interactionSourceFromPointerType(pointerType);
+/**
+ * Pure decision for the plot capture-surface `pointermove` handler.
+ * Priority: touch-inspect drag cancel → queue area move → queue inspect → none.
+ *
+ * Cancel requires `pointerType === "touch"` (mouse/pen with residual start must
+ * not cancel). Cancel does **not** require inspect config — only the inspect
+ * tool, matching the current host.
+ *
+ * Host advances `touchInspectMoved` separately on touch+start before calling.
+ * Host on cancel: clear `queuedPointerInspection`, cancel scheduled pointer
+ * (`queuedPointerToken` left untouched). Host on queue-inspect: nearest with
+ * action.mode / action.maxDistance (no config re-read).
+ */
+export function resolvePointerMoveAction(input) {
+    const { pointerType, activeTool, touchInspectMoved, hasTouchInspectStart, brushing, hasBrushDraft, inspect, } = input;
+    if (pointerType === "touch" &&
+        hasTouchInspectStart &&
+        touchInspectMoved &&
+        activeTool === "inspect") {
+        return { type: "touch-inspect-drag-cancel" };
+    }
+    if (brushing && hasBrushDraft) {
+        return { type: "queue-area-move", source: pointerSource(pointerType) };
+    }
+    if (activeTool === "inspect" && inspect !== null) {
+        return {
+            type: "queue-inspect",
+            source: pointerSource(pointerType),
+            mode: inspect.mode,
+            maxDistance: inspect.maxDistance,
+        };
+    }
+    return { type: "none" };
+}
+// ---- pointer leave / finish-brush ----
+/**
+ * Whether pointerleave should clear inspection after its microtask flush.
+ * Host must call this **inside** `queueMicrotask` so `brushing` and
+ * `tooltipHovered` reflect post-flush state (not leave-time snapshots).
+ */
+export function shouldClearInspectionOnPointerLeave(input) {
+    return !input.brushing && !input.tooltipHovered;
+}
+/** True while an area brush session is active (not idle). */
+export function isAreaBrushing(areaKind) {
+    return areaKind !== "idle";
+}
+/** True while waiting for the second brush corner (keyboard / too-small path). */
+export function isAreaAwaitingSecond(areaKind) {
+    return areaKind === "first-corner";
+}
+/**
+ * Pure routing for capture-surface `lostpointercapture`.
+ *
+ * Takes reducer `area.kind` (not derived booleans) so illegal combos like
+ * `!brushing && areaAwaitingSecond` are unrepresentable.
+ *
+ *   idle         → ignore (no cancel-area)
+ *   first-corner → cancel-keep-draft (dispatch cancel-area; retain brushRect)
+ *   dragging     → cancel-clear-draft (clear brushRect + dispatch cancel-area)
+ */
+export function resolveLostPointerCaptureAction(areaKind) {
+    if (areaKind === "idle")
+        return { type: "ignore" };
+    if (areaKind === "first-corner")
+        return { type: "cancel-keep-draft" };
+    return { type: "cancel-clear-draft" };
+}

package/dist/surface/surface-description.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pure a11y description strings for the capture surface live region.
+ * Host reads these into a construction-time `$derived` keyed on active tool.
+ *
+ * Callers must pass `inspectPinEnabled` only when `activeTool === "inspect"`
+ * (or compute it lazily) so Svelte dependency tracking does not subscribe to
+ * inspect config while another tool is active.
+ */
+import type { InteractionTool } from "../interaction/interaction.js";
+export declare function buildSurfaceDescription(activeTool: InteractionTool, inspectPinEnabled: boolean): string;