@ggts-sh/svelte 0.43.0

package/dist/inspection/pointer-inspect.js

@@ -0,0 +1,158 @@
+/**
+ * Pointer-inspect queue ownership for InspectionState.
+ *
+ * Owns queued payload + frame token + pending-pin stash, nearest schedule,
+ * typed cancel, and onInspectPointerFrame routing. Pure frame tables stay in
+ * frame.ts; the host owns $state inspection snapshot, setInspection, dismiss,
+ * and scene-reconcile orchestration.
+ *
+ * Construction must not invoke deps.model / deps.reducer / deps.setInspection
+ * (armed-getter construction discipline on the host factory).
+ *
+ * onFrame may re-enter the host via setInspection (apply-pending). Snapshot
+ * then clear queue fields before pure routing so re-entrant cancel sees empty
+ * queue fields — load-bearing for touch-tap override of a pending rAF.
+ */
+import { resolveTarget } from "../interaction/target.js";
+import { buildQueuedInspectFrame, resolveQueuedInspectFrameAction, } from "./frame.js";
+/**
+ * hitTest resurrection when nearest misses.
+ *
+ * nearest under axis modes measures distance to the **anchor**, not painted
+ * geometry. hitTest finds whatever mark is under the pointer:
+ * - **rects** (bars/tiles): containment of the bar body — keep rescuing so
+ *   wide columns under mode x still tooltips when the pointer is on the fill
+ *   but farther than maxDistance from the centre anchor.
+ * - **paths/segments** (lines, areas, qq_line): stroke/fill can hit far from
+ *   vertex anchors; on a two-vertex path that teleports between ends
+ *   mid-stroke. Drop those under axis modes (and auto→axis autoMode).
+ *
+ * Exact always keeps geometric hits. Auto→exact marks (points, default bars)
+ * keep full hitTest. Flip-safe: no re-implementation of nearest's axis swap.
+ */
+function hitTestFallback(model, input) {
+    const hit = model.candidates.hitTest(input.point.x, input.point.y);
+    if (hit === null)
+        return null;
+    if (input.mode === "exact")
+        return hit;
+    const resolved = input.mode === "auto" ? (hit.autoMode ?? "exact") : input.mode;
+    if (resolved === "exact")
+        return hit;
+    // Axis mode (explicit or auto→x/y): rect containment only.
+    return hit.kind === "rects" ? hit : null;
+}
+/**
+ * Create the pointer-inspect queue. Does not invoke deps at construction.
+ */
+export function createPointerInspectQueue(deps) {
+    let queuedPointerToken = null;
+    let queuedPointerInspection = null;
+    let pendingPinnedPointer = null;
+    function schedule(input) {
+        const model = deps.model();
+        // Resolved target owns panel-scoped nearest + hover distance policy (#1080 / #787).
+        // panelAtOrOnly keeps single-panel axis-margin hover working.
+        const target = model === null
+            ? null
+            : resolveTarget({
+                model,
+                point: input.point,
+                intent: "hover",
+                inspect: { mode: input.mode, maxDistance: input.maxDistance },
+            });
+        const match = target?.match ?? null;
+        const frame = buildQueuedInspectFrame({
+            match,
+            source: input.source,
+            epoch: model?.runId ?? 0,
+            fallbackCandidate: () => (model === null ? null : hitTestFallback(model, input)),
+        });
+        const reducer = deps.reducer();
+        queuedPointerInspection = frame.queued;
+        queuedPointerToken = reducer.frameToken();
+        try {
+            reducer.queuePointer({
+                type: "inspect",
+                candidate: frame.candidate,
+                source: input.source,
+            });
+        }
+        catch (error) {
+            // No orphan payload if scheduling throws.
+            queuedPointerInspection = null;
+            queuedPointerToken = null;
+            throw error;
+        }
+    }
+    function cancel(policy) {
+        queuedPointerInspection = null;
+        if (policy.pendingPinned === "discard")
+            pendingPinnedPointer = null;
+        deps.reducer().cancelScheduledPointer("inspect");
+    }
+    /**
+     * Inspect branch of onPointerFrame.
+     *
+     * Snapshot then clear before pure routing — re-entrant setInspection cancel
+     * must observe empty queue fields.
+     *
+     * Boolean return is retained for symmetry with move-area's onPointerFrame
+     * contract. For `type === "inspect"` the reducer never dispatches the frame
+     * payload (inspection is single-authority in InspectionState); callers that
+     * gate on false still get the pure-table "drop" signal for stale tokens.
+     */
+    function onFrame(action) {
+        const pending = queuedPointerInspection;
+        const token = queuedPointerToken;
+        queuedPointerInspection = null;
+        queuedPointerToken = null;
+        // Short-circuit tokenAccepted when no pending so accepts() is not
+        // called for empty frames.
+        const frameAction = resolveQueuedInspectFrameAction({
+            hasPending: pending !== null,
+            tokenAccepted: pending === null || token === null || deps.reducer().accepts(token),
+            currentState: deps.inspectionState(),
+            candidateEpochMismatch: action.candidate !== null && action.candidate.epoch !== deps.model()?.runId,
+        });
+        switch (frameAction.type) {
+            case "none":
+                // Empty frame (payload already cleared; scheduled inspect still flushed).
+                return true;
+            case "drop":
+                // Stale token / epoch mismatch — pure-table drop signal.
+                return false;
+            case "stash-pending":
+                if (pending !== null)
+                    pendingPinnedPointer = pending;
+                return true;
+            case "apply-pending":
+                if (pending !== null) {
+                    deps.setInspection(pending.candidate, pending.source, "transient", pending.concreteMode);
+                }
+                return true;
+        }
+        return true;
+    }
+    function peekPendingPinned() {
+        return pendingPinnedPointer;
+    }
+    function takePendingPinned() {
+        const pending = pendingPinnedPointer;
+        pendingPinnedPointer = null;
+        return pending;
+    }
+    function clearForSceneInvalidate() {
+        queuedPointerInspection = null;
+        pendingPinnedPointer = null;
+        queuedPointerToken = null;
+    }
+    return {
+        schedule,
+        cancel,
+        onFrame,
+        peekPendingPinned,
+        takePendingPinned,
+        clearForSceneInvalidate,
+    };
+}

package/dist/inspection/resolver.d.ts

@@ -0,0 +1,3 @@
+export { type ResolveInspectionInput, type InspectionSnapshotCompleteness, TRANSIENT_MEMBER_LIMIT, selectTransientMembers, resolvedTarget, resolveInspection, materializeInspection, } from "@ggts-sh/core/interaction";
+export { clearInspectionFingerprint } from "./coordinator.js";
+export { createInspectionCoordinator } from "./coordinator.js";

package/dist/inspection/resolver.js

@@ -0,0 +1,4 @@
+// Shared pure behavior used by React and Svelte.
+export { TRANSIENT_MEMBER_LIMIT, selectTransientMembers, resolvedTarget, resolveInspection, materializeInspection, } from "@ggts-sh/core/interaction";
+export { clearInspectionFingerprint } from "./coordinator.js";
+export { createInspectionCoordinator } from "./coordinator.js";

package/dist/inspection/teardown.d.ts

@@ -0,0 +1,199 @@
+/**
+ * Decision tables and scene-reconcile apply for capture-surface inspection
+ * *teardown* policy: blur/outside dismiss, scene-run reconcile (plan + bag
+ * apply), emit fingerprint, escape/close plan.
+ *
+ * Plan helpers are pure. `applySceneInspectReconcile` only calls the host bag
+ * (reducer, coordinator, queue, field writes) — no $effect registration.
+ */
+import type { CandidateFacts, CellValue, RenderModel } from "@ggts-sh/core";
+import type { InteractionSource, PlotInspectionChange } from "../interaction/interaction.js";
+import type { InspectionHostState } from "./frame.js";
+type InspectionChangeSnapshot = PlotInspectionChange<Record<string, CellValue>, PropertyKey>;
+export type SurfaceBlurAction = {
+    readonly type: "ignore";
+} | {
+    readonly type: "blur-keep-pinned";
+} | {
+    readonly type: "blur-clear-inspection";
+};
+/**
+ * Pure decision for capture-surface `blur`.
+ *
+ * Host on non-ignore (ordering is load-bearing):
+ *   1. activeTraversalIndex = -1
+ *   2. reducer.dispatch set-active null
+ *   3. only blur-clear-inspection → setInspection(null, "keyboard")
+ *
+ * Host must pass `relatedTargetInsideRoot: root?.contains(related) === true`.
+ * `"none"` and `"transient"` both clear inspection; `"pinned"` keeps it.
+ */
+export declare function resolveSurfaceBlurAction(input: {
+    readonly relatedTargetInsideRoot: boolean;
+    /** Host: `inspection === null ? "none" : inspection.state`. */
+    readonly inspectionState: InspectionHostState;
+}): SurfaceBlurAction;
+/**
+ * Whether a window pointerdown outside the plot should close a pinned
+ * inspection. Host: only when `surfaceInteractive` effect is installed.
+ * Host must pass `targetInsideRoot: root?.contains(target) === true`.
+ *
+ * Takes domain `inspectionState` (not a pre-derived `isPinned` boolean) so
+ * hosts pass `inspection?.state` directly — same shape as `isTooltipDocked`.
+ */
+export declare function shouldClosePinnedOnOutsidePointer(input: {
+    readonly inspectionState: "transient" | "pinned" | "none" | null | undefined;
+    readonly targetInsideRoot: boolean;
+}): boolean;
+export type SceneInspectReconcilePlan = {
+    readonly type: "noop";
+} | {
+    readonly type: "clear-disabled";
+} | {
+    readonly type: "skip";
+} | {
+    readonly type: "invalidate-clear-transient";
+} | {
+    readonly type: "invalidate-idle";
+} | {
+    readonly type: "invalidate-reconcile-pinned";
+};
+/**
+ * Priority table for the model-run inspection reconcile effect.
+ *
+ *   1. inspect off → clear-disabled when live inspection exists, else noop
+ *   2. no model / same runId as reconciledRun → skip
+ *   3. run advanced + transient → invalidate-clear-transient
+ *   4. run advanced + pinned → invalidate-reconcile-pinned
+ *   5. run advanced + none → invalidate-idle
+ *
+ * Host on every invalidate-*: clear queues, cancel scheduled pointer, set
+ * reconciledRun to the new model runId, then branch-specific side effects.
+ *
+ * `getInspectionState` is a thunk so the host `$effect` can avoid reading
+ * hover `inspection` state on the skip path (same runId) — otherwise every
+ * transient pointer update would re-run this effect only to hit skip.
+ */
+export declare function planSceneInspectReconcile(input: {
+    readonly inspectionEnabled: boolean;
+    /** Host: `() => (inspection === null ? "none" : inspection.state)`. */
+    readonly getInspectionState: () => InspectionHostState;
+    readonly modelRunId: number | null;
+    readonly reconciledRun: number;
+}): SceneInspectReconcilePlan;
+/**
+ * Host mutators for `applySceneInspectReconcile`. The `$effect` shell owns
+ * plan + bag wiring; this bag owns field writes and coordinator/queue/reducer.
+ */
+export type SceneInspectReconcileBag = {
+    /**
+     * Current model when the effect ran. Required non-null for invalidate-*
+     * plans (plan guarantees run advanced). clear-disabled / noop / skip may
+     * pass null.
+     */
+    readonly model: RenderModel | null;
+    readonly dataIdentityEpoch: () => PropertyKey;
+    /** Clear live inspection + seed (transient clear, disabled clear, failed pin). */
+    clearInspection(): void;
+    /** Commit a successful pinned reconcile (snapshot + seed). */
+    setInspectionFromReconcile(input: {
+        readonly snapshot: InspectionChangeSnapshot;
+        readonly seed: CandidateFacts;
+    }): void;
+    setActiveCandidateId(id: number | null): void;
+    clearDismissedLatch(): void;
+    setReconciledRun(runId: number): void;
+    /** Reducer `{ type: "invalidate", reason: "scene" }` (cancels all scheduled pointer). */
+    dispatchSceneInvalidate(): void;
+    /** clear-disabled: discard pending pin stash; inspect-only cancel. */
+    cancelPointerDiscardPending(): void;
+    /** invalidate-*: clear queue fields only (after dispatchSceneInvalidate). */
+    clearPointerForSceneInvalidate(): void;
+    coordinatorInvalidate(): void;
+    releaseTransient(): void;
+    reconcilePinned(input: {
+        readonly model: RenderModel;
+        readonly identityEpoch: PropertyKey;
+        readonly layoutEpoch: PropertyKey;
+    }): {
+        readonly snapshot: InspectionChangeSnapshot;
+        readonly seed: CandidateFacts;
+        readonly semanticChanged: boolean;
+        readonly semanticFingerprint: string;
+    } | null;
+    emitClearProgrammatic(): void;
+    emitSemanticChange(snapshot: InspectionChangeSnapshot, semanticFingerprint: string): void;
+};
+/**
+ * Apply a scene-run inspection reconcile plan via host mutators.
+ *
+ * Keeps the factory `$effect` as plan → apply. Ordering is load-bearing:
+ * invalidate-* dispatches reducer invalidate before queue field clears; pinned
+ * reconcile failure emits programmatic clear then clears fields.
+ */
+export declare function applySceneInspectReconcile(plan: SceneInspectReconcilePlan, bag: SceneInspectReconcileBag): void;
+export type InspectionEmitAction = {
+    readonly type: "skip";
+} | {
+    readonly type: "emit";
+    /**
+     * When non-null, host assigns `lastInspectionFingerprint = updateFingerprint`
+     * before callbacks. When null, host must not mutate the last fingerprint
+     * (undefined semantic path on change — always emit without update).
+     */
+    readonly updateFingerprint: string | null;
+};
+/**
+ * Pure gate for host `emitInspection`: resolve fingerprint then skip/emit.
+ *
+ * Fingerprint production:
+ *   clear  → `clearInspectionFingerprint(source)` (`clear:${source}`)
+ *   change → `semanticFingerprint` (coordinator token; may be undefined)
+ *
+ * `semanticFingerprint` is meaningful only when `phase === "change"`.
+ *
+ * Emit rules after fingerprint is resolved:
+ *   undefined fingerprint → emit, do not update last
+ *   fingerprint === last  → skip (includes equal empty string; host inits last to "")
+ *   otherwise             → emit and update last to fingerprint
+ */
+export declare function resolveInspectionEmitAction(input: {
+    readonly phase: "clear" | "change";
+    readonly source: InteractionSource;
+    /** Coordinator semantic fingerprint; ignored when phase is clear. */
+    readonly semanticFingerprint: string | undefined;
+    readonly lastFingerprint: string;
+}): InspectionEmitAction;
+export type InspectionDismissKind = "escape" | "close";
+/**
+ * Host side-effect plan for dismissing inspection.
+ * Used by a single host `dismissInspection` that Escape and closeInspection share.
+ *
+ * Escape (keyboard): invalidate coordinator, clear brush, optional returnToInspect;
+ * discards pending pin stash so a later re-pin cannot restore a pre-Escape
+ * candidate (#856). Close: release pinned, clear pending, optional restore
+ * focus to capture surface.
+ */
+export type InspectionDismissPlan = {
+    readonly emitClear: boolean;
+    readonly clearPendingPinned: boolean;
+    readonly coordinator: "invalidate" | "release-pinned";
+    readonly clearBrush: boolean;
+    readonly clearTooltipHovered: boolean;
+    readonly restoreFocus: boolean;
+    readonly returnToInspect: boolean;
+};
+/**
+ * Pure plan for unified inspection dismiss.
+ * Host always dispatches reducer `{ type: "escape", source }` first, then applies
+ * this plan for field clears / coordinator / focus / tool.
+ */
+export declare function planInspectionDismiss(input: {
+    readonly kind: InspectionDismissKind;
+    readonly hasInspection: boolean;
+    /** Close only; defaults to true when omitted (matches closeInspection default). */
+    readonly restoreFocus?: boolean;
+    /** Escape only; from `resolveSurfaceKeyAction` escape.returnToInspect. */
+    readonly returnToInspect?: boolean;
+}): InspectionDismissPlan;
+export {};

package/dist/inspection/teardown.js

@@ -0,0 +1,181 @@
+/**
+ * Decision tables and scene-reconcile apply for capture-surface inspection
+ * *teardown* policy: blur/outside dismiss, scene-run reconcile (plan + bag
+ * apply), emit fingerprint, escape/close plan.
+ *
+ * Plan helpers are pure. `applySceneInspectReconcile` only calls the host bag
+ * (reducer, coordinator, queue, field writes) — no $effect registration.
+ */
+import { clearInspectionFingerprint } from "./coordinator.js";
+/**
+ * Pure decision for capture-surface `blur`.
+ *
+ * Host on non-ignore (ordering is load-bearing):
+ *   1. activeTraversalIndex = -1
+ *   2. reducer.dispatch set-active null
+ *   3. only blur-clear-inspection → setInspection(null, "keyboard")
+ *
+ * Host must pass `relatedTargetInsideRoot: root?.contains(related) === true`.
+ * `"none"` and `"transient"` both clear inspection; `"pinned"` keeps it.
+ */
+export function resolveSurfaceBlurAction(input) {
+    if (input.relatedTargetInsideRoot)
+        return { type: "ignore" };
+    if (input.inspectionState === "pinned")
+        return { type: "blur-keep-pinned" };
+    return { type: "blur-clear-inspection" };
+}
+/**
+ * Whether a window pointerdown outside the plot should close a pinned
+ * inspection. Host: only when `surfaceInteractive` effect is installed.
+ * Host must pass `targetInsideRoot: root?.contains(target) === true`.
+ *
+ * Takes domain `inspectionState` (not a pre-derived `isPinned` boolean) so
+ * hosts pass `inspection?.state` directly — same shape as `isTooltipDocked`.
+ */
+export function shouldClosePinnedOnOutsidePointer(input) {
+    return input.inspectionState === "pinned" && !input.targetInsideRoot;
+}
+/**
+ * Priority table for the model-run inspection reconcile effect.
+ *
+ *   1. inspect off → clear-disabled when live inspection exists, else noop
+ *   2. no model / same runId as reconciledRun → skip
+ *   3. run advanced + transient → invalidate-clear-transient
+ *   4. run advanced + pinned → invalidate-reconcile-pinned
+ *   5. run advanced + none → invalidate-idle
+ *
+ * Host on every invalidate-*: clear queues, cancel scheduled pointer, set
+ * reconciledRun to the new model runId, then branch-specific side effects.
+ *
+ * `getInspectionState` is a thunk so the host `$effect` can avoid reading
+ * hover `inspection` state on the skip path (same runId) — otherwise every
+ * transient pointer update would re-run this effect only to hit skip.
+ */
+export function planSceneInspectReconcile(input) {
+    if (!input.inspectionEnabled) {
+        return input.getInspectionState() === "none" ? { type: "noop" } : { type: "clear-disabled" };
+    }
+    if (input.modelRunId === null || input.modelRunId === input.reconciledRun) {
+        return { type: "skip" };
+    }
+    const inspectionState = input.getInspectionState();
+    if (inspectionState === "transient") {
+        return { type: "invalidate-clear-transient" };
+    }
+    if (inspectionState === "pinned") {
+        return { type: "invalidate-reconcile-pinned" };
+    }
+    return { type: "invalidate-idle" };
+}
+/**
+ * Apply a scene-run inspection reconcile plan via host mutators.
+ *
+ * Keeps the factory `$effect` as plan → apply. Ordering is load-bearing:
+ * invalidate-* dispatches reducer invalidate before queue field clears; pinned
+ * reconcile failure emits programmatic clear then clears fields.
+ */
+export function applySceneInspectReconcile(plan, bag) {
+    switch (plan.type) {
+        case "noop":
+        case "skip":
+            return;
+        case "clear-disabled":
+            bag.coordinatorInvalidate();
+            bag.clearInspection();
+            bag.clearDismissedLatch();
+            // Inspect-only cancel: move-area schedules must survive.
+            bag.cancelPointerDiscardPending();
+            return;
+        case "invalidate-clear-transient":
+        case "invalidate-idle":
+        case "invalidate-reconcile-pinned": {
+            // Plan requires run advance → model is non-null for invalidate-*.
+            const model = bag.model;
+            if (model === null)
+                return;
+            const runId = model.runId;
+            // invalidate dispatch already cancels all scheduled pointer work.
+            bag.dispatchSceneInvalidate();
+            bag.clearPointerForSceneInvalidate();
+            bag.clearDismissedLatch();
+            bag.setReconciledRun(runId);
+            if (plan.type === "invalidate-clear-transient") {
+                bag.releaseTransient();
+                bag.clearInspection();
+                return;
+            }
+            if (plan.type === "invalidate-idle")
+                return;
+            const reconciled = bag.reconcilePinned({
+                model,
+                identityEpoch: bag.dataIdentityEpoch(),
+                layoutEpoch: runId,
+            });
+            if (reconciled === null) {
+                // Failed pinned reconcile: clear inspection only (not area Escape).
+                bag.emitClearProgrammatic();
+                bag.clearInspection();
+            }
+            else {
+                bag.setInspectionFromReconcile({
+                    snapshot: reconciled.snapshot,
+                    seed: reconciled.seed,
+                });
+                bag.setActiveCandidateId(reconciled.seed.id);
+                if (reconciled.semanticChanged) {
+                    bag.emitSemanticChange(reconciled.snapshot, reconciled.semanticFingerprint);
+                }
+            }
+        }
+    }
+}
+/**
+ * Pure gate for host `emitInspection`: resolve fingerprint then skip/emit.
+ *
+ * Fingerprint production:
+ *   clear  → `clearInspectionFingerprint(source)` (`clear:${source}`)
+ *   change → `semanticFingerprint` (coordinator token; may be undefined)
+ *
+ * `semanticFingerprint` is meaningful only when `phase === "change"`.
+ *
+ * Emit rules after fingerprint is resolved:
+ *   undefined fingerprint → emit, do not update last
+ *   fingerprint === last  → skip (includes equal empty string; host inits last to "")
+ *   otherwise             → emit and update last to fingerprint
+ */
+export function resolveInspectionEmitAction(input) {
+    const fingerprint = input.phase === "clear" ? clearInspectionFingerprint(input.source) : input.semanticFingerprint;
+    if (fingerprint === undefined)
+        return { type: "emit", updateFingerprint: null };
+    if (fingerprint === input.lastFingerprint)
+        return { type: "skip" };
+    return { type: "emit", updateFingerprint: fingerprint };
+}
+/**
+ * Pure plan for unified inspection dismiss.
+ * Host always dispatches reducer `{ type: "escape", source }` first, then applies
+ * this plan for field clears / coordinator / focus / tool.
+ */
+export function planInspectionDismiss(input) {
+    if (input.kind === "escape") {
+        return {
+            emitClear: input.hasInspection,
+            clearPendingPinned: true,
+            coordinator: "invalidate",
+            clearBrush: true,
+            clearTooltipHovered: true,
+            restoreFocus: false,
+            returnToInspect: input.returnToInspect === true,
+        };
+    }
+    return {
+        emitClear: input.hasInspection,
+        clearPendingPinned: true,
+        coordinator: "release-pinned",
+        clearBrush: false,
+        clearTooltipHovered: true,
+        restoreFocus: input.restoreFocus !== false,
+        returnToInspect: false,
+    };
+}

package/dist/inspection/tooltip-chrome.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Tooltip chrome policy for theme-aware default content (#1069).
+ *
+ * Visual roles (paper / ink / border) live on the theme. This helper decides
+ * whether the default instructional footer ("Click to pin", overflow pin hint)
+ * belongs with that chrome — flat (gridless) themes drop to text on paper and
+ * stay silent; pinned-disabled inspect configs never advertise pinning.
+ */
+export type TooltipPinHintInput = {
+    /** Whether inspect pinning is enabled on the plot. */
+    readonly pin: boolean;
+    /**
+     * Resolved theme tooltip keyline. Gridless themes derive `"transparent"`;
+     * a concrete color means the theme still wants a boxed panel.
+     */
+    readonly tooltipBorder: string;
+};
+/** True when the default tooltip should show pin-related instructional footers. */
+export declare function shouldShowTooltipPinHint(input: TooltipPinHintInput): boolean;

package/dist/inspection/tooltip-chrome.js

@@ -0,0 +1,17 @@
+/**
+ * Tooltip chrome policy for theme-aware default content (#1069).
+ *
+ * Visual roles (paper / ink / border) live on the theme. This helper decides
+ * whether the default instructional footer ("Click to pin", overflow pin hint)
+ * belongs with that chrome — flat (gridless) themes drop to text on paper and
+ * stay silent; pinned-disabled inspect configs never advertise pinning.
+ */
+/** True when the default tooltip should show pin-related instructional footers. */
+export function shouldShowTooltipPinHint(input) {
+    if (!input.pin)
+        return false;
+    const border = input.tooltipBorder.trim().toLowerCase();
+    if (border === "transparent" || border === "none")
+        return false;
+    return true;
+}

package/dist/inspection/tooltip-motion.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tooltip first-appear / last-leave motion policy.
+ *
+ * Hover follow and miss-between-marks stay instant. Short opacity is the
+ * only allowed chart-chrome motion (DESIGN.md). Scale is not used.
+ */
+export declare const TOOLTIP_MOTION_MS = 160;
+export declare const TOOLTIP_EASE = "cubic-bezier(0.23, 1, 0.32, 1)";
+export type TooltipMotionReason = "hit" | "miss-on-plot" | "leave-plot" | "close";
+export type TooltipMotionPhase = "enter" | "none" | "exit";
+export declare function prefersReducedMotion(media: {
+    readonly matches: boolean;
+} | null | undefined): boolean;
+export declare function resolveTooltipDismissReason(input: {
+    readonly explicitClose: boolean;
+    readonly pointerOnCapture: boolean;
+}): "miss-on-plot" | "leave-plot" | "close";
+export declare function resolveTooltipMotion(input: {
+    readonly reason: TooltipMotionReason;
+    readonly sessionActive: boolean;
+    readonly reducedMotion: boolean;
+}): {
+    readonly phase: TooltipMotionPhase;
+    readonly sessionActive: boolean;
+};

package/dist/inspection/tooltip-motion.js

@@ -0,0 +1,32 @@
+/**
+ * Tooltip first-appear / last-leave motion policy.
+ *
+ * Hover follow and miss-between-marks stay instant. Short opacity is the
+ * only allowed chart-chrome motion (DESIGN.md). Scale is not used.
+ */
+export const TOOLTIP_MOTION_MS = 160;
+export const TOOLTIP_EASE = "cubic-bezier(0.23, 1, 0.32, 1)";
+export function prefersReducedMotion(media) {
+    return media?.matches === true;
+}
+export function resolveTooltipDismissReason(input) {
+    if (input.explicitClose)
+        return "close";
+    if (input.pointerOnCapture)
+        return "miss-on-plot";
+    return "leave-plot";
+}
+export function resolveTooltipMotion(input) {
+    if (input.reason === "hit") {
+        if (input.reducedMotion || input.sessionActive)
+            return { phase: "none", sessionActive: true };
+        return { phase: "enter", sessionActive: true };
+    }
+    if (input.reason === "miss-on-plot") {
+        return { phase: "none", sessionActive: input.sessionActive };
+    }
+    // leave-plot | close
+    if (input.sessionActive && !input.reducedMotion)
+        return { phase: "exit", sessionActive: false };
+    return { phase: "none", sessionActive: false };
+}