@ggts-sh/svelte 0.43.0

package/dist/interaction/normalize-interaction-config.js

@@ -0,0 +1,112 @@
+import { INTERACTION_DIAGNOSTIC_CATALOG, } from "./interaction-diagnostics.js";
+function resolveInspect(input, diagnostics) {
+    if (input === undefined || input === false)
+        return null;
+    const value = input === true ? {} : input;
+    const maxDistance = value.maxDistance ?? 24;
+    if (!Number.isFinite(maxDistance) || maxDistance < 0) {
+        diagnostics.push({
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_INVALID_MAX_DISTANCE,
+            actual: maxDistance,
+        });
+        return null;
+    }
+    return Object.freeze({
+        mode: value.mode ?? "auto",
+        pin: value.pin ?? true,
+        maxDistance,
+        contentMode: value.contentMode ?? "informational",
+        muteSiblings: value.muteSiblings ?? false,
+        tooltipTotal: value.tooltipTotal ?? "auto",
+        ...(value.content !== undefined && { content: value.content }),
+    });
+}
+function resolveSelect(input, hasKey, diagnostics) {
+    if (input === undefined || input === false)
+        return null;
+    const value = typeof input === "string" ? { type: input } : input;
+    const select = Object.freeze({
+        type: value.type,
+        mode: value.mode ?? "xy",
+        multiple: value.multiple ?? false,
+        persistent: value.persistent ?? true,
+        preset: value.preset ?? "independent",
+    });
+    if (value.type === "point" && hasKey === false) {
+        diagnostics.push({
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_POINT_REQUIRES_KEY,
+        });
+    }
+    if (value.type === "interval" && select.preset !== "independent" && hasKey === false) {
+        diagnostics.push({
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_INTERVAL_PRESET_REQUIRES_KEY,
+        });
+    }
+    return select;
+}
+function availableInteractionTools(inspect, select, zoom) {
+    const tools = [];
+    if (inspect !== null || select?.type === "interval" || zoom !== null)
+        tools.push("inspect");
+    if (select?.type === "point")
+        tools.push("point");
+    if (select?.type === "interval")
+        tools.push("select-area");
+    if (zoom !== null)
+        tools.push("zoom-area");
+    return tools;
+}
+function resolveZoom(input) {
+    if (input === undefined || input === false)
+        return null;
+    const value = input === true ? {} : input;
+    return Object.freeze({
+        mode: value.mode ?? "xy",
+        trigger: value.trigger ?? "brush",
+    });
+}
+function resolveLegendFocus(input, hasKey, diagnostics) {
+    if (input === undefined || input === false)
+        return null;
+    if (hasKey === false) {
+        diagnostics.push({
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_LEGEND_REQUIRES_KEY,
+        });
+        return null;
+    }
+    const value = input === true ? {} : input;
+    return Object.freeze({ preview: value.preview ?? true });
+}
+export function normalizeInteractionConfig(input, context = {}) {
+    const diagnostics = [];
+    const inspect = resolveInspect(input.inspect, diagnostics);
+    const select = resolveSelect(input.select, context.hasKey, diagnostics);
+    let zoom = resolveZoom(input.zoom);
+    const legendFocus = resolveLegendFocus(input.legendFocus, context.hasKey, diagnostics);
+    if (context.faceted === true && zoom !== null) {
+        diagnostics.push({
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_INTERVAL_FACET_UNSUPPORTED,
+        });
+        zoom = null;
+    }
+    const availableTools = availableInteractionTools(inspect, select, zoom);
+    const fallbackTool = select?.type === "point" && inspect === null ? "point" : "inspect";
+    const requestedTool = input.tool ?? fallbackTool;
+    const initialTool = availableTools.includes(requestedTool) ? requestedTool : fallbackTool;
+    if (input.tool !== undefined && !availableTools.includes(input.tool)) {
+        diagnostics.push({
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_TOOL_UNAVAILABLE,
+            actual: input.tool,
+        });
+    }
+    return Object.freeze({
+        interactive: availableTools.length > 0 || legendFocus !== null,
+        inspect,
+        select,
+        zoom,
+        legendFocus,
+        initialTool,
+        availableTools: Object.freeze(availableTools),
+        diagnostics: Object.freeze(diagnostics),
+    });
+}

package/dist/interaction/reducer.d.ts

@@ -0,0 +1,97 @@
+import type { InteractionSource, InteractionTool } from "./interaction.js";
+/** Candidate identity carried on inspect pointer-frame payloads (not reducer state). */
+export interface InteractionCandidateRef {
+    readonly epoch: number;
+    readonly id: number;
+    readonly panelId: string | null;
+    readonly x: number;
+    readonly y: number;
+}
+type AreaState = Readonly<{
+    kind: "idle";
+}> | Readonly<{
+    kind: "first-corner" | "dragging";
+    tool: "select-area" | "zoom-area";
+    panelId: string | null;
+    start: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    current: Readonly<{
+        x: number;
+        y: number;
+    }>;
+}>;
+/**
+ * Reducer owns tool + area brush + frame epoch/revision.
+ * Inspection lifecycle lives solely in InspectionState (single authority).
+ */
+export interface InteractionReducerState {
+    readonly revision: number;
+    readonly epoch: number;
+    readonly tool: InteractionTool;
+    readonly area: AreaState;
+}
+/**
+ * Actions. `inspect` is a **pointer-frame payload only** — delivered to
+ * `onPointerFrame` and never stored on reducer state.
+ */
+export type InteractionAction = {
+    type: "inspect";
+    candidate: InteractionCandidateRef | null;
+    source: InteractionSource;
+} | {
+    type: "escape";
+    source: InteractionSource;
+} | {
+    type: "set-tool";
+    tool: InteractionTool;
+} | {
+    type: "begin-area";
+    point: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    panelId: string | null;
+} | {
+    type: "move-area";
+    point: Readonly<{
+        x: number;
+        y: number;
+    }>;
+} | {
+    type: "cancel-area";
+} | {
+    type: "invalidate";
+    reason: "resize" | "data" | "scene" | "dispose";
+};
+export interface InteractionFrameToken {
+    readonly epoch: number;
+    readonly revision: number;
+}
+export type PointerScheduleKind = "inspect" | "move-area";
+export declare function createInteractionReducer(options?: {
+    initialTool?: InteractionTool;
+    onChange?: (state: InteractionReducerState) => void;
+    /**
+     * Continuous pointer-frame sink.
+     * - inspect: InspectionState only (never reducer-dispatched)
+     * - move-area: may return false to skip dispatch (unused today)
+     */
+    onPointerFrame?: (action: Extract<InteractionAction, {
+        type: "inspect" | "move-area";
+    }>) => boolean | void;
+    scheduleFrame?: (callback: () => void) => unknown;
+    cancelFrame?: (handle: unknown) => void;
+}): {
+    readonly state: InteractionReducerState;
+    dispatch: (action: InteractionAction) => void;
+    /** Coalesce continuous pointer coordinates to the latest action per frame. */
+    queuePointer(action: Extract<InteractionAction, {
+        type: "inspect" | "move-area";
+    }>): void;
+    cancelScheduledPointer: (kind?: PointerScheduleKind) => void;
+    frameToken(): InteractionFrameToken;
+    accepts(token: InteractionFrameToken): boolean;
+};
+export {};

package/dist/interaction/reducer.js

@@ -0,0 +1,117 @@
+export function createInteractionReducer(options = {}) {
+    let state = {
+        revision: 0,
+        epoch: 0,
+        tool: options.initialTool ?? "inspect",
+        area: { kind: "idle" },
+    };
+    let scheduledPointerAction = null;
+    let frameHandle = null;
+    /**
+     * Cancel the coalesced pointer schedule. With `kind`, cancel only when the
+     * queued action matches (inspect cancel must not kill move-area).
+     */
+    const cancelScheduledPointer = (kind) => {
+        if (kind !== undefined &&
+            (scheduledPointerAction === null || scheduledPointerAction.type !== kind))
+            return;
+        if (frameHandle !== null)
+            options.cancelFrame?.(frameHandle);
+        frameHandle = null;
+        scheduledPointerAction = null;
+    };
+    const commit = (patch) => {
+        state = Object.freeze({ ...state, ...patch, revision: state.revision + 1 });
+        options.onChange?.(state);
+    };
+    const dispatch = (action) => {
+        // Discrete boundaries always win over queued pointer coordinates.
+        if (action.type === "escape" ||
+            action.type === "set-tool" ||
+            action.type === "cancel-area" ||
+            action.type === "invalidate")
+            cancelScheduledPointer();
+        switch (action.type) {
+            case "inspect":
+                // Inspect payloads are frame-only; never mutate reducer state.
+                return;
+            case "escape":
+                // Area cancel + epoch only. Inspection dismiss is InspectionState-owned.
+                if (state.area.kind === "idle") {
+                    commit({ epoch: state.epoch + 1 });
+                }
+                else {
+                    commit({ area: { kind: "idle" }, epoch: state.epoch + 1 });
+                }
+                return;
+            case "set-tool":
+                if (state.tool !== action.tool || state.area.kind !== "idle") {
+                    commit({ tool: action.tool, area: { kind: "idle" }, epoch: state.epoch + 1 });
+                }
+                return;
+            case "begin-area":
+                if (state.tool !== "select-area" && state.tool !== "zoom-area")
+                    return;
+                commit({
+                    area: {
+                        kind: "first-corner",
+                        tool: state.tool,
+                        panelId: action.panelId,
+                        start: action.point,
+                        current: action.point,
+                    },
+                });
+                return;
+            case "move-area":
+                if (state.area.kind === "idle")
+                    return;
+                commit({ area: { ...state.area, kind: "dragging", current: action.point } });
+                return;
+            case "cancel-area":
+                if (state.area.kind !== "idle")
+                    commit({ area: { kind: "idle" }, epoch: state.epoch + 1 });
+                return;
+            case "invalidate":
+                commit({ area: { kind: "idle" }, epoch: state.epoch + 1 });
+        }
+    };
+    return {
+        get state() {
+            return state;
+        },
+        dispatch,
+        /** Coalesce continuous pointer coordinates to the latest action per frame. */
+        queuePointer(action) {
+            scheduledPointerAction = action;
+            if (frameHandle !== null)
+                return;
+            const schedule = options.scheduleFrame ??
+                ((callback) => {
+                    queueMicrotask(callback);
+                    return 1;
+                });
+            frameHandle = schedule(() => {
+                frameHandle = null;
+                const latest = scheduledPointerAction;
+                scheduledPointerAction = null;
+                if (latest === null)
+                    return;
+                // Inspect frames are owned by InspectionState — never reducer-dispatched.
+                if (latest.type === "inspect") {
+                    options.onPointerFrame?.(latest);
+                    return;
+                }
+                const shouldDispatch = options.onPointerFrame?.(latest);
+                if (shouldDispatch !== false)
+                    dispatch(latest);
+            });
+        },
+        cancelScheduledPointer,
+        frameToken() {
+            return { epoch: state.epoch, revision: state.revision };
+        },
+        accepts(token) {
+            return token.epoch === state.epoch && token.revision === state.revision;
+        },
+    };
+}

package/dist/interaction/resolve-inspect-capability.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Resolve host inspect capability from the GGPlot prop and registered
+ * capability children (declaration-only `<Inspect>`). Pure — no registry I/O.
+ *
+ * Child presence enables inspect; empty child bag ≡ `inspect={true}`.
+ * When any child is registered, the last child's options replace the prop
+ * whole (no deep-merge). Multiple children set `multiChild` for diagnostics.
+ */
+import type { DatumKey } from "../runtime/resolve-datum-key.js";
+import type { InspectInput, InspectOptions } from "./interaction.js";
+import { type InteractionDiagnostic } from "./interaction-diagnostics.js";
+/** Options bag registered by one `<Inspect>` (empty object = defaults). */
+export type InspectCapabilityChild = InspectOptions;
+export type ResolveInspectCapabilityInput = {
+    readonly prop?: InspectInput | undefined;
+    readonly children?: readonly InspectCapabilityChild[] | undefined;
+};
+export type ResolveInspectCapabilityResult = {
+    /** Value for normalizeInteractionConfig / resolveCapabilities override. */
+    readonly input: InspectInput;
+    /** True when more than one inspect capability child is registered. */
+    readonly multiChild: boolean;
+    /** Row identity the winning source asks for; undefined means "use the default". */
+    readonly identity: DatumKey | undefined;
+    /** True when the prop named an identity that the winning child replaced away. */
+    readonly droppedPropIdentity: boolean;
+};
+/**
+ * Prefer the last capability child over the prop. No children → prop ?? false.
+ *
+ * Resolving `identity` here (rather than leaving callers to re-read it off
+ * `input`) is what makes the REPLACE rule visible: an `<Inspect>` child that
+ * names no identity drops one the prop asked for, and `droppedPropIdentity`
+ * says so instead of the identity vanishing into a row-index default.
+ */
+export declare function resolveInspectCapability(input: ResolveInspectCapabilityInput): ResolveInspectCapabilityResult;
+/** Zero or one multi-Inspect advisory from a resolve result. */
+export declare function duplicateInspectCapabilityDiagnostics(multiChild: boolean): InteractionDiagnostic[];
+/** Zero or one advisory for a prop identity a child replaced away. */
+export declare function droppedInspectIdentityDiagnostics(droppedPropIdentity: boolean): InteractionDiagnostic[];

package/dist/interaction/resolve-inspect-capability.js

@@ -0,0 +1,50 @@
+import { INTERACTION_DIAGNOSTIC_CATALOG, } from "./interaction-diagnostics.js";
+function childToInput(child) {
+    return Object.keys(child).length === 0 ? true : child;
+}
+/** Read `identity` off an inspect input; boolean forms carry none. */
+function identityOf(input) {
+    if (input === undefined || input === true || input === false)
+        return undefined;
+    return input.identity;
+}
+/**
+ * Prefer the last capability child over the prop. No children → prop ?? false.
+ *
+ * Resolving `identity` here (rather than leaving callers to re-read it off
+ * `input`) is what makes the REPLACE rule visible: an `<Inspect>` child that
+ * names no identity drops one the prop asked for, and `droppedPropIdentity`
+ * says so instead of the identity vanishing into a row-index default.
+ */
+export function resolveInspectCapability(input) {
+    const children = input.children ?? [];
+    if (children.length === 0) {
+        return {
+            input: input.prop ?? false,
+            multiChild: false,
+            identity: identityOf(input.prop),
+            droppedPropIdentity: false,
+        };
+    }
+    const last = children.at(-1);
+    const resolved = childToInput(last);
+    const identity = identityOf(resolved);
+    return {
+        input: resolved,
+        multiChild: children.length > 1,
+        identity,
+        droppedPropIdentity: identity === undefined && identityOf(input.prop) !== undefined,
+    };
+}
+/** Zero or one multi-Inspect advisory from a resolve result. */
+export function duplicateInspectCapabilityDiagnostics(multiChild) {
+    if (!multiChild)
+        return [];
+    return [{ ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_DUPLICATE_INSPECT_CAPABILITY }];
+}
+/** Zero or one advisory for a prop identity a child replaced away. */
+export function droppedInspectIdentityDiagnostics(droppedPropIdentity) {
+    if (!droppedPropIdentity)
+        return [];
+    return [{ ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_INSPECT_IDENTITY_DROPPED }];
+}

package/dist/interaction/scoped-store.svelte.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Channel state that lives either in the shared interaction controller or
+ * locally in this plot. Callers never learn which. Subscribes to the
+ * controller revision internally (#1079).
+ */
+import type { PlotInteractionController } from "./controller.svelte.js";
+import type { InteractionSource, PlotInteractionInterval, PlotInteractionScope } from "./interaction.js";
+/**
+ * Successful write result. Wrapped so a committed `null` (e.g. cleared zoom)
+ * is not confused with a no-op rejection.
+ */
+type ScopedStoreWrite<T> = {
+    readonly value: T;
+};
+export interface ScopedStore<T> {
+    readonly value: T;
+    /**
+     * Replace the value. Returns `{ value }` on commit, or `null` when the write
+     * was a no-op (same local value, or controller rejected the transition).
+     */
+    set(next: T, source: InteractionSource): ScopedStoreWrite<T> | null;
+    /**
+     * Clear to the store's empty value. Returns `false` when already empty
+     * (or the controller rejected a no-op clear).
+     */
+    clear(source: InteractionSource): boolean;
+}
+export type CreateScopedStoreInput<T> = {
+    readonly initial: T;
+    readonly controller: () => PlotInteractionController | undefined;
+    readonly scope: () => PlotInteractionScope;
+    /** Read channel state from a live controller. */
+    readonly read: (controller: PlotInteractionController, scope: PlotInteractionScope) => T;
+    /**
+     * Write channel state to a live controller. Return `{ value }` on commit, or
+     * `null` when the controller treated the write as a no-op.
+     */
+    readonly write: (controller: PlotInteractionController, next: T, scope: PlotInteractionScope, source: InteractionSource) => ScopedStoreWrite<T> | null;
+    /**
+     * Clear channel state on a live controller. Return `false` when the clear
+     * was a no-op.
+     */
+    readonly clearShared: (controller: PlotInteractionController, scope: PlotInteractionScope, source: InteractionSource) => boolean;
+    /** Equality for local no-op detection. Defaults to `Object.is`. */
+    readonly same?: (a: T, b: T) => boolean;
+    /**
+     * Value after `clear` in local mode. Defaults to `initial`.
+     * (e.g. zoom uses `null`; key lists use `[]`.)
+     */
+    readonly empty?: T;
+};
+/**
+ * Create a scoped store. Construction registers a `$derived` that tracks the
+ * controller revision when shared mode is active.
+ */
+export declare function createScopedStore<T>(input: CreateScopedStoreInput<T>): ScopedStore<T>;
+/**
+ * Interval channel store. The controller exposes upsert/remove/clear-all
+ * rather than whole-array replace, so this surface mirrors those ops while
+ * still hiding local vs shared storage.
+ */
+export interface IntervalScopedStore {
+    readonly value: readonly PlotInteractionInterval<PropertyKey>[];
+    upsert(record: PlotInteractionInterval<PropertyKey>, source: InteractionSource): void;
+    remove(panelId: string, source: InteractionSource): boolean;
+    clear(source: InteractionSource): boolean;
+}
+export type CreateIntervalScopedStoreInput = {
+    readonly controller: () => PlotInteractionController | undefined;
+    readonly scope: () => PlotInteractionScope;
+};
+export declare function createIntervalScopedStore(input: CreateIntervalScopedStoreInput): IntervalScopedStore;
+export {};

package/dist/interaction/scoped-store.svelte.js

@@ -0,0 +1,93 @@
+import { nextLocalIntervalRecords } from "../interval/consumption.js";
+/**
+ * Create a scoped store. Construction registers a `$derived` that tracks the
+ * controller revision when shared mode is active.
+ */
+export function createScopedStore(input) {
+    let local = $state.raw(input.initial);
+    const same = input.same ?? ((a, b) => Object.is(a, b));
+    // `empty` may be null (zoom); hasOwn keeps null distinct from "not provided".
+    const empty = Object.hasOwn(input, "empty") ? input.empty : input.initial;
+    const value = $derived.by(() => {
+        const controller = input.controller();
+        if (controller === undefined)
+            return local;
+        // Subscribe to revision so external controller writes invalidate readers.
+        void controller.revision;
+        return input.read(controller, input.scope());
+    });
+    function set(next, source) {
+        const controller = input.controller();
+        if (controller === undefined) {
+            if (same(local, next))
+                return null;
+            local = next;
+            return { value: local };
+        }
+        return input.write(controller, next, input.scope(), source);
+    }
+    function clear(source) {
+        const controller = input.controller();
+        if (controller === undefined) {
+            if (same(local, empty))
+                return false;
+            local = empty;
+            return true;
+        }
+        return input.clearShared(controller, input.scope(), source);
+    }
+    return {
+        get value() {
+            return value;
+        },
+        set,
+        clear,
+    };
+}
+export function createIntervalScopedStore(input) {
+    let local = $state.raw([]);
+    const value = $derived.by(() => {
+        const controller = input.controller();
+        if (controller === undefined)
+            return local;
+        void controller.revision;
+        return controller.intervals(input.scope());
+    });
+    function upsert(record, source) {
+        const controller = input.controller();
+        if (controller === undefined) {
+            local = [...nextLocalIntervalRecords(local, record)];
+            return;
+        }
+        controller.setInterval(record, { scope: input.scope(), source });
+    }
+    function remove(panelId, source) {
+        const controller = input.controller();
+        if (controller === undefined) {
+            const next = local.filter((interval) => interval.panelId !== panelId);
+            if (next.length === local.length)
+                return false;
+            local = next;
+            return true;
+        }
+        return controller.clearInterval(panelId, { scope: input.scope(), source }) !== null;
+    }
+    function clear(source) {
+        const controller = input.controller();
+        if (controller === undefined) {
+            if (local.length === 0)
+                return false;
+            local = [];
+            return true;
+        }
+        return controller.clearIntervals({ scope: input.scope(), source }) !== null;
+    }
+    return {
+        get value() {
+            return value;
+        },
+        upsert,
+        remove,
+        clear,
+    };
+}

package/dist/interaction/target.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Resolved target ownership (#1080).
+ *
+ * One module owns panel-scoped nearest (#787), the per-intent distance policy,
+ * and the candidate match that hover / tap / point-select all need. Callers
+ * stop each carrying their own `panelAtOrOnly().nearest()` and maxDistance.
+ *
+ * Does not own hit geometry (core) or the inspect pin lifecycle. Semantic
+ * keys stay on the host (`candidateSemanticKeys`). Reducer inspect payloads
+ * are built from CandidateMatch / CandidateFacts in inspection/frame.ts.
+ */
+import type { CandidateInspectMode, CandidateMatch, RenderModel, ResolvedCandidateInspectMode } from "@ggts-sh/core";
+import { type PanelBounds } from "../scene/geometry.js";
+import type { PlotPoint } from "../surface/area-brush.js";
+/**
+ * Why we are resolving. Selects the distance policy so callers stop each
+ * carrying their own maxDistance.
+ */
+export type TargetIntent = "hover" | "tap" | "point-select";
+/**
+ * Inspect fields that feed hover/tap distance policy.
+ * Host: resolved `interactionConfig.inspect` (mode + maxDistance), or the
+ * pure-table snapshot already taken for the gesture.
+ */
+export type TargetInspectPolicy = {
+    readonly mode: CandidateInspectMode;
+    readonly maxDistance: number;
+} | null;
+/**
+ * Nearest-candidate radius (plot px) for point-tool click.
+ * Deliberate constant — distinct from inspect.maxDistance (default also 24,
+ * but hover/tap read config; point-select does not).
+ */
+export declare const POINT_SELECT_NEAREST_MAX_DISTANCE_PX = 24;
+/** Resolved nearest-search params for one intent. */
+export type TargetSearch = {
+    readonly mode: CandidateInspectMode;
+    readonly maxDistance: number;
+};
+/**
+ * Intent → nearest search params.
+ *
+ * | intent       | mode              | maxDistance                          |
+ * |--------------|-------------------|--------------------------------------|
+ * | hover        | inspect.mode      | inspect.maxDistance                  |
+ * | tap          | inspect.mode      | inspect.maxDistance                  |
+ * | point-select | always `"xy"`     | `POINT_SELECT_NEAREST_MAX_DISTANCE_PX` |
+ *
+ * Returns null when hover/tap has no inspect snapshot (nothing to resolve).
+ */
+export declare function targetSearch(intent: TargetIntent, inspect: TargetInspectPolicy): TargetSearch | null;
+/**
+ * The one representation of "the thing under the pointer" at resolve time.
+ * `match` is the full CandidateMatch so setInspection / semantic-keys keep
+ * working without a second store lookup. Panel bounds come from the same
+ * viewport panel that scoped the nearest call.
+ */
+export type ResolvedTarget = {
+    readonly epoch: number;
+    readonly candidateId: number;
+    readonly panelId: string;
+    readonly point: PlotPoint;
+    readonly mode: ResolvedCandidateInspectMode;
+    readonly distance: number;
+    readonly match: CandidateMatch;
+    readonly panel: PanelBounds & {
+        readonly id: string;
+    };
+};
+export type ResolveTargetInput = {
+    readonly model: RenderModel;
+    readonly point: PlotPoint;
+    readonly intent: TargetIntent;
+    /**
+     * Inspect policy for hover/tap. Ignored for point-select (uses the table).
+     * Pass the pure-table snapshot when the gesture already captured mode /
+     * maxDistance so callers do not re-read live config.
+     */
+    readonly inspect: TargetInspectPolicy;
+    /**
+     * Optional explicit search override. When set, skips `targetSearch` and
+     * uses these params — for callers that already snapshotted mode/maxDistance
+     * onto a pure action payload.
+     */
+    readonly search?: TargetSearch;
+};
+/**
+ * Panel-scoped nearest for one intent. Sole call site of
+ * `panelAtOrOnly().nearest()` for hover / tap / point-select.
+ */
+export declare function resolveTarget(input: ResolveTargetInput): ResolvedTarget | null;