@ggts-sh/svelte 0.43.0

package/dist/inspection/tooltip-presence.svelte.d.ts

@@ -0,0 +1,49 @@
+import type { CellValue } from "@ggts-sh/core";
+import type { PlotInspectionChange } from "../interaction/interaction.js";
+/** Inspection snapshot shape owned by the plot engine. */
+type AnyInspection = PlotInspectionChange<Record<string, CellValue>, PropertyKey>;
+/**
+ * Tooltip session/ghost/presence state, extracted from <GGPlot>.
+ *
+ * Owns three concerns that must stay in lockstep (GGPlan: "Tooltip presence"):
+ * the hover session (whether enter/exit motion is allowed), the exit-motion
+ * ghost (a frozen snapshot that keeps rendering while the real tooltip exits),
+ * and the pointer/explicit-close flags the capture layer feeds in. The
+ * inspection state itself stays with the engine — the factory reads it through
+ * a LIVE getter so a sync always sees the current value, never a snapshot
+ * taken at construction.
+ *
+ * SSR-safe: no `requestAnimationFrame` is touched on the server (a queued sync
+ * degrades to a synchronous call), and reduced-motion detection guards for the
+ * missing `matchMedia`.
+ */
+export type TooltipPresenceState = {
+    /** Reactive exit-motion snapshot, `null` when no ghost should render. */
+    readonly ghost: AnyInspection | null;
+    /** Monotonic ghost generation; captured at ghost mount for safe clearing. */
+    readonly ghostEpoch: number;
+    /** Record whether the pointer is currently over the capture surface. */
+    setPointerOnCapture(on: boolean): void;
+    /** Flag the next dismissal as explicit (blur, Escape, close button). */
+    markExplicitClose(): void;
+    /** Session-active flag for enter-motion gating (read at tooltip mount). */
+    sessionActive(): boolean;
+    /** Whether the user prefers reduced motion (SSR-safe). */
+    reducedMotion(): boolean;
+    /** Schedule a presence sync on the next frame (server: synchronous). */
+    queueSync(): void;
+    /** Recompute session/ghost/presence from the live inspection. */
+    sync(): void;
+    /** Clear the ghost unless a newer generation has replaced it. */
+    clearGhost(generation: number): void;
+};
+/**
+ * Create the tooltip presence state. Call synchronously during component
+ * init: the cleanup effect and every later sync assume they run inside the
+ * component's reactive context.
+ */
+export declare function createTooltipPresenceState(options: {
+    /** LIVE getter into the engine's inspection state — never a snapshot. */
+    getInspection: () => AnyInspection | null;
+}): TooltipPresenceState;
+export {};

package/dist/inspection/tooltip-presence.svelte.js

@@ -0,0 +1,110 @@
+import { TOOLTIP_MOTION_MS, prefersReducedMotion, resolveTooltipDismissReason, resolveTooltipMotion, } from "./tooltip-motion.js";
+function reducedMotion() {
+    if (typeof matchMedia !== "function")
+        return false;
+    return prefersReducedMotion(matchMedia("(prefers-reduced-motion: reduce)"));
+}
+/**
+ * Create the tooltip presence state. Call synchronously during component
+ * init: the cleanup effect and every later sync assume they run inside the
+ * component's reactive context.
+ */
+export function createTooltipPresenceState(options) {
+    const { getInspection } = options;
+    const session = { active: false };
+    let pointerOnCapture = false;
+    let pendingExplicitClose = false;
+    let lastLiveInspection = null;
+    let hadLiveInspection = false;
+    const ghostEpoch = { n: 0 };
+    let ghostTimer;
+    let ghost = $state(null);
+    let syncFrame = 0;
+    $effect(() => () => {
+        clearTimeout(ghostTimer);
+        cancelAnimationFrame(syncFrame);
+    });
+    function clearGhost(generation) {
+        if (generation !== ghostEpoch.n)
+            return;
+        ghost = null;
+        if (ghostTimer !== undefined) {
+            clearTimeout(ghostTimer);
+            ghostTimer = undefined;
+        }
+    }
+    function startGhost(snapshot) {
+        ghostEpoch.n += 1;
+        const generation = ghostEpoch.n;
+        ghost = snapshot;
+        clearTimeout(ghostTimer);
+        ghostTimer = setTimeout(() => {
+            clearGhost(generation);
+        }, TOOLTIP_MOTION_MS + 50);
+    }
+    function sync() {
+        const current = getInspection();
+        const present = current !== null;
+        if (current !== null)
+            lastLiveInspection = current;
+        if (present === hadLiveInspection)
+            return;
+        hadLiveInspection = present;
+        if (present) {
+            const next = resolveTooltipMotion({
+                reason: "hit",
+                sessionActive: session.active,
+                reducedMotion: reducedMotion(),
+            });
+            session.active = next.sessionActive;
+            clearGhost(ghostEpoch.n);
+            return;
+        }
+        const reason = resolveTooltipDismissReason({
+            explicitClose: pendingExplicitClose,
+            pointerOnCapture,
+        });
+        pendingExplicitClose = false;
+        const next = resolveTooltipMotion({
+            reason,
+            sessionActive: session.active,
+            reducedMotion: reducedMotion(),
+        });
+        session.active = next.sessionActive;
+        if (next.phase === "exit" && lastLiveInspection !== null)
+            startGhost(lastLiveInspection);
+    }
+    function queueSync() {
+        if (syncFrame !== 0)
+            return;
+        if (typeof requestAnimationFrame !== "function") {
+            sync();
+            return;
+        }
+        syncFrame = requestAnimationFrame(() => {
+            syncFrame = 0;
+            sync();
+        });
+    }
+    return {
+        get ghost() {
+            return ghost;
+        },
+        get ghostEpoch() {
+            return ghostEpoch.n;
+        },
+        setPointerOnCapture(on) {
+            pointerOnCapture = on;
+        },
+        markExplicitClose() {
+            pendingExplicitClose = true;
+        },
+        sessionActive() {
+            return session.active;
+        },
+        reducedMotion,
+        queueSync,
+        sync,
+        clearGhost,
+    };
+}

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

@@ -0,0 +1 @@
+export { tooltipTotalPlacement } from "@ggts-sh/core/interaction";

package/dist/inspection/tooltip-total.js

@@ -0,0 +1,2 @@
+// Shared pure behavior used by React and Svelte.
+export { tooltipTotalPlacement } from "@ggts-sh/core/interaction";

package/dist/interaction/capability-resolution.svelte.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Host capability resolution — the one seam between the layer registry /
+ * plot props and the engine for interaction capabilities (inspect from
+ * `<Inspect>` children + prop, legendFocus / legendFilter from GuideLegend
+ * layers + deprecated plot props).
+ *
+ * THREE independent deriveds — never one combined bag. The inspect resolve
+ * reads only `registry.capabilities("inspect")` (`#capabilityVersion`), so
+ * geom/mark layer churn must not re-run it: interactionConfig diagnostics
+ * re-deliver per recompute (registry contract). The legend resolves read
+ * `registry.layers` (`#version`).
+ *
+ * `interactionConfig` normalization stays in the engine — it must NOT read
+ * `caps()` (legendFilter is not a normalizeInteractionConfig input; reading
+ * it there re-delivered config diagnostics on every filter toggle).
+ */
+import type { LayerRegistry } from "../geoms/registry.svelte.js";
+import { type ResolvedLegendFilterCapability } from "../legend/resolve-legend-filter.js";
+import { type ResolvedLegendFocusCapability } from "../legend/resolve-legend-focus.js";
+import { type EnginePlotProps, type ResolvedPlotCapabilities } from "../plot-props.js";
+import { type ResolveInspectCapabilityResult } from "./resolve-inspect-capability.js";
+/**
+ * SSR-safe derived: Svelte 5.33's one-pass SSR can cache a construction-time
+ * empty registry before declaration children initialize. The server branch
+ * recomputes on EVERY read (never caches); client reads keep normal rune
+ * dependency tracking. Call during component init (or an effect root) only.
+ */
+export declare function ssrSafeDerived<T>(compute: () => T): () => T;
+export type CapabilityResolution = {
+    /** Inspect from prop + `<Inspect>` capability children (last child wins). */
+    readonly inspect: () => ResolveInspectCapabilityResult;
+    /** Legend focus from GuideLegend layers + deprecated plot prop. */
+    readonly legendFocus: () => ResolvedLegendFocusCapability;
+    /** Legend filter from GuideLegend layers + deprecated plot prop. */
+    readonly legendFilter: () => ResolvedLegendFilterCapability;
+    /** All five capability defaults for wiring advisories. */
+    readonly caps: () => ResolvedPlotCapabilities;
+};
+export declare function createCapabilityResolution(host: {
+    registry: LayerRegistry;
+    props: EnginePlotProps;
+}): CapabilityResolution;

package/dist/interaction/capability-resolution.svelte.js

@@ -0,0 +1,40 @@
+import { resolveLegendFilterCapability, } from "../legend/resolve-legend-filter.js";
+import { resolveLegendFocusCapability, } from "../legend/resolve-legend-focus.js";
+import { readLegacyPlotLegendFilter, readLegacyPlotLegendFocus, resolveCapabilities, } from "../plot-props.js";
+import { resolveInspectCapability, } from "./resolve-inspect-capability.js";
+/**
+ * SSR-safe derived: Svelte 5.33's one-pass SSR can cache a construction-time
+ * empty registry before declaration children initialize. The server branch
+ * recomputes on EVERY read (never caches); client reads keep normal rune
+ * dependency tracking. Call during component init (or an effect root) only.
+ */
+export function ssrSafeDerived(compute) {
+    const derived = $derived.by(compute);
+    return () => (typeof window === "undefined" ? compute() : derived);
+}
+export function createCapabilityResolution(host) {
+    const inspect = ssrSafeDerived(() => resolveInspectCapability({
+        prop: host.props.inspect,
+        children: host.registry.capabilities("inspect"),
+    }));
+    const legendFocus = ssrSafeDerived(() => resolveLegendFocusCapability({
+        plotProp: readLegacyPlotLegendFocus(host.props),
+        layers: host.registry.layers,
+    }));
+    const legendFilter = ssrSafeDerived(() => resolveLegendFilterCapability({
+        plotProp: readLegacyPlotLegendFilter(host.props),
+        layers: host.registry.layers,
+    }));
+    const caps = () => {
+        const select = host.props.select;
+        const zoom = host.props.zoom;
+        return resolveCapabilities({
+            inspect: inspect().input,
+            legendFocus: legendFocus().requested,
+            legendFilter: legendFilter().requested,
+            ...(select !== undefined && { select }),
+            ...(zoom !== undefined && { zoom }),
+        });
+    };
+    return { inspect, legendFocus, legendFilter, caps };
+}

package/dist/interaction/capability.d.ts

@@ -0,0 +1,129 @@
+import { type InteractionDiagnostic, type InteractionTool } from "./interaction.js";
+export type ZoomAreaMode = "x" | "y" | "xy";
+/**
+ * Drop zoom-area when no continuous channel supports brush zoom.
+ * Other tools pass through unchanged.
+ */
+export declare function filterAvailableTools(tools: readonly InteractionTool[], zoomHasSupportedChannel: boolean): InteractionTool[];
+/**
+ * Filter configured tools using live zoom mode + model scales.
+ * When zoom or scales are not yet available, zoom-area is kept (same as
+ * chrome's pre-model construction path). Shared by plot-engine surface
+ * enablement and chrome-state so the two cannot drift (#1082).
+ */
+export declare function resolveFilteredAvailableTools(tools: readonly InteractionTool[], zoom: {
+    readonly mode: ZoomAreaMode;
+} | null, scales: ScaleTypeRef | null): InteractionTool[];
+/** True when select config publishes point selection. */
+export declare function canPublishPointSelection(select: {
+    readonly type: string;
+} | null | undefined): boolean;
+/**
+ * Resolve the tool the host should sync into the reducer.
+ * Priority: requested if available → first available → `"inspect"`.
+ *
+ * Note: empty `available` still yields `"inspect"` (even when inspect is not
+ * listed). That matches the host `$effect` and intentionally diverges from
+ * `resolveChooseToolAction`, which rejects unavailable tools.
+ */
+export declare function resolveEffectiveTool(requested: InteractionTool, available: readonly InteractionTool[]): InteractionTool;
+export type ChooseToolAction = {
+    readonly type: "ignore";
+} | {
+    readonly type: "request";
+} | {
+    readonly type: "apply";
+};
+export type ShowToolRailInput = {
+    readonly interactive: boolean;
+    readonly availableToolCount: number;
+    /** Host: `interactionConfig.select?.type === "point"`. */
+    readonly canPublishPointSelection: boolean;
+    readonly selectedKeyCount: number;
+    readonly hasIntervalSelection: boolean;
+    readonly hasZoomDomains: boolean;
+};
+/**
+ * True when every batch has zero rows (including an empty batches list).
+ * Host still requires a live model before calling this.
+ */
+export declare function isEmptyPlotScene(batches: readonly {
+    readonly rowIndex: {
+        readonly length: number;
+    };
+}[]): boolean;
+/**
+ * Whether the tool rail chrome should mount.
+ * Multi-tool mode, or any recovery control (point clear / interval clear / zoom reset).
+ */
+export declare function shouldShowToolRail(input: ShowToolRailInput): boolean;
+export type InertSelectionOverlayInput = {
+    /**
+     * Host chart-local `interactive` (tools or legend focus).
+     * Inert overlay is only for non-interactive emphasis/selection paint.
+     */
+    readonly interactive: boolean;
+    readonly selectedAnchorCount: number;
+    readonly emphasizedAnchorCount: number;
+};
+/**
+ * Whether to paint the non-interactive selection/emphasis overlay.
+ * Host also must not be in surface-interactive mode; SceneOverlays
+ * enforces that with `{:else if}` so both never mount together.
+ */
+export declare function shouldShowInertSelectionOverlay(input: InertSelectionOverlayInput): boolean;
+/**
+ * Pure routing for host `chooseTool`.
+ *
+ * Priority:
+ *   1. ignore — `next` not in `available` (wins over controlled; no callback)
+ *   2. request — controlled prop (`tool !== undefined`): callback only
+ *   3. apply — local: dispatch + clear draft/queue + callback
+ */
+export declare function resolveChooseToolAction(input: {
+    readonly next: InteractionTool;
+    readonly available: readonly InteractionTool[];
+    readonly isControlled: boolean;
+}): ChooseToolAction;
+export type ScaleTypeRef = {
+    readonly x: {
+        readonly type: string;
+    };
+    readonly y: {
+        readonly type: string;
+    };
+};
+/** True when at least one channel requested by mode is non-band. */
+export declare function zoomSupportsChannel(mode: ZoomAreaMode, scales: ScaleTypeRef): boolean;
+/** Band channels that block zoom under the given mode. */
+export declare function bandChannelsForZoom(mode: ZoomAreaMode, scales: ScaleTypeRef): Array<"x" | "y">;
+/**
+ * Zoom-only band-scale diagnostics (not interval-select).
+ * `catalogEntry` is spread into each diagnostic with prop/actual filled.
+ */
+export declare function zoomScaleDiagnosticsFromChannels(channels: readonly ("x" | "y")[], catalogEntry: Omit<InteractionDiagnostic, "prop" | "actual"> & Partial<Pick<InteractionDiagnostic, "prop" | "actual">>): InteractionDiagnostic[];
+export type CapabilityStatusInput = {
+    readonly facetUnavailableMessage?: string;
+    readonly areaDiagnostics: readonly InteractionDiagnostic[];
+    readonly zoomSupported: boolean;
+    readonly interactive: boolean;
+    readonly emptyPlot: boolean;
+    /** Null when no render model (preserves host `model !== null` guard). */
+    readonly candidateCount: number | null;
+};
+/**
+ * User-facing capability status under the plot.
+ * Order: facet unavailable → zoom limited/unavailable → no inspectable marks → null.
+ */
+export declare function capabilityStatusText(input: CapabilityStatusInput): string | null;
+/** Legend type surface for discrete-only advisory (host maps scene legends). */
+export type LegendTypeRef = {
+    readonly type: string;
+};
+/**
+ * When legend focus is enabled and the scene has legends but none are discrete,
+ * return the INTERACTION_LEGEND_DISCRETE_ONLY advisory with `actual` legend types.
+ * Empty when disabled, no legends, or any discrete legend is present.
+ * Contract is "not discrete" (ramps, unknown types, etc.), not ramp-only.
+ */
+export declare function legendFocusDiscreteOnlyDiagnostics(legendFocusEnabled: boolean, legends: readonly LegendTypeRef[]): InteractionDiagnostic[];

package/dist/interaction/capability.js

@@ -0,0 +1,134 @@
+import { INTERACTION_DIAGNOSTIC_CATALOG, } from "./interaction.js";
+/**
+ * Drop zoom-area when no continuous channel supports brush zoom.
+ * Other tools pass through unchanged.
+ */
+export function filterAvailableTools(tools, zoomHasSupportedChannel) {
+    return tools.filter((tool) => tool !== "zoom-area" || zoomHasSupportedChannel);
+}
+/**
+ * Filter configured tools using live zoom mode + model scales.
+ * When zoom or scales are not yet available, zoom-area is kept (same as
+ * chrome's pre-model construction path). Shared by plot-engine surface
+ * enablement and chrome-state so the two cannot drift (#1082).
+ */
+export function resolveFilteredAvailableTools(tools, zoom, scales) {
+    const zoomHasSupportedChannel = zoom === null || scales === null || zoomSupportsChannel(zoom.mode, scales);
+    return filterAvailableTools(tools, zoomHasSupportedChannel);
+}
+/** True when select config publishes point selection. */
+export function canPublishPointSelection(select) {
+    return select?.type === "point";
+}
+/**
+ * Resolve the tool the host should sync into the reducer.
+ * Priority: requested if available → first available → `"inspect"`.
+ *
+ * Note: empty `available` still yields `"inspect"` (even when inspect is not
+ * listed). That matches the host `$effect` and intentionally diverges from
+ * `resolveChooseToolAction`, which rejects unavailable tools.
+ */
+export function resolveEffectiveTool(requested, available) {
+    if (available.includes(requested))
+        return requested;
+    return available[0] ?? "inspect";
+}
+/**
+ * True when every batch has zero rows (including an empty batches list).
+ * Host still requires a live model before calling this.
+ */
+export function isEmptyPlotScene(batches) {
+    return batches.every((batch) => batch.rowIndex.length === 0);
+}
+/**
+ * Whether the tool rail chrome should mount.
+ * Multi-tool mode, or any recovery control (point clear / interval clear / zoom reset).
+ */
+export function shouldShowToolRail(input) {
+    return (input.interactive &&
+        (input.availableToolCount > 1 ||
+            (input.canPublishPointSelection && input.selectedKeyCount > 0) ||
+            input.hasIntervalSelection ||
+            input.hasZoomDomains));
+}
+/**
+ * Whether to paint the non-interactive selection/emphasis overlay.
+ * Host also must not be in surface-interactive mode; SceneOverlays
+ * enforces that with `{:else if}` so both never mount together.
+ */
+export function shouldShowInertSelectionOverlay(input) {
+    return !input.interactive && (input.selectedAnchorCount > 0 || input.emphasizedAnchorCount > 0);
+}
+/**
+ * Pure routing for host `chooseTool`.
+ *
+ * Priority:
+ *   1. ignore — `next` not in `available` (wins over controlled; no callback)
+ *   2. request — controlled prop (`tool !== undefined`): callback only
+ *   3. apply — local: dispatch + clear draft/queue + callback
+ */
+export function resolveChooseToolAction(input) {
+    if (!input.available.includes(input.next))
+        return { type: "ignore" };
+    if (input.isControlled)
+        return { type: "request" };
+    return { type: "apply" };
+}
+/** True when at least one channel requested by mode is non-band. */
+export function zoomSupportsChannel(mode, scales) {
+    return (mode !== "y" && scales.x.type !== "band") || (mode !== "x" && scales.y.type !== "band");
+}
+/** Band channels that block zoom under the given mode. */
+export function bandChannelsForZoom(mode, scales) {
+    const channels = [];
+    if (mode !== "y" && scales.x.type === "band")
+        channels.push("x");
+    if (mode !== "x" && scales.y.type === "band")
+        channels.push("y");
+    return channels;
+}
+/**
+ * Zoom-only band-scale diagnostics (not interval-select).
+ * `catalogEntry` is spread into each diagnostic with prop/actual filled.
+ */
+export function zoomScaleDiagnosticsFromChannels(channels, catalogEntry) {
+    return channels.map((channel) => ({
+        ...catalogEntry,
+        prop: `scales.${channel}`,
+        actual: "band",
+    }));
+}
+/**
+ * User-facing capability status under the plot.
+ * Order: facet unavailable → zoom limited/unavailable → no inspectable marks → null.
+ */
+export function capabilityStatusText(input) {
+    if (input.facetUnavailableMessage !== undefined)
+        return `Area interaction unavailable: ${input.facetUnavailableMessage}`;
+    if (input.areaDiagnostics.length > 0)
+        return `Zoom ${input.zoomSupported ? "limited" : "unavailable"}: ${input.areaDiagnostics[0].message}`;
+    if (input.interactive &&
+        !input.emptyPlot &&
+        input.candidateCount !== null &&
+        input.candidateCount === 0)
+        return "No inspectable marks";
+    return null;
+}
+/**
+ * When legend focus is enabled and the scene has legends but none are discrete,
+ * return the INTERACTION_LEGEND_DISCRETE_ONLY advisory with `actual` legend types.
+ * Empty when disabled, no legends, or any discrete legend is present.
+ * Contract is "not discrete" (ramps, unknown types, etc.), not ramp-only.
+ */
+export function legendFocusDiscreteOnlyDiagnostics(legendFocusEnabled, legends) {
+    if (!legendFocusEnabled || legends.length === 0)
+        return [];
+    if (legends.some((legend) => legend.type === "discrete"))
+        return [];
+    return [
+        {
+            ...INTERACTION_DIAGNOSTIC_CATALOG.INTERACTION_LEGEND_DISCRETE_ONLY,
+            actual: legends.map((legend) => legend.type),
+        },
+    ];
+}

package/dist/interaction/controller.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { CreatePlotInteractionOptions, PlotInteractionController } from "@ggts-sh/core/interaction";
+export type { ControllerDatumIdentity, CreatePlotInteractionOptions, PlotInteractionController, PlotInteractionMutationOptions, PlotInteractionZoomOptions, } from "@ggts-sh/core/interaction";
+/** Svelte reactivity over the shared framework-independent controller. */
+export declare function createPlotInteraction<Key extends PropertyKey = PropertyKey>(options?: CreatePlotInteractionOptions<Key>): PlotInteractionController<Key>;

package/dist/interaction/controller.svelte.js

@@ -0,0 +1,43 @@
+import { createPlotInteraction as createController } from "@ggts-sh/core/interaction";
+/** Svelte reactivity over the shared framework-independent controller. */
+export function createPlotInteraction(options = {}) {
+    let revision = $state(0);
+    const controller = createController({
+        ...options,
+        onchange(transition) {
+            revision = transition.revision;
+            options.onchange?.(transition);
+        },
+    });
+    const reactiveController = {
+        ...controller,
+        get revision() {
+            return revision;
+        },
+        get snapshot() {
+            void revision;
+            return controller.snapshot;
+        },
+        selected: (scope) => {
+            void revision;
+            return controller.selected(scope);
+        },
+        emphasized: (scope) => {
+            void revision;
+            return controller.emphasized(scope);
+        },
+        isSelected: (key, scope) => {
+            void revision;
+            return controller.isSelected(key, scope);
+        },
+        intervals: (scope) => {
+            void revision;
+            return controller.intervals(scope);
+        },
+        zoom: (scope) => {
+            void revision;
+            return controller.zoom(scope);
+        },
+    };
+    return Object.freeze(reactiveController);
+}

package/dist/interaction/inspect-geom-advisories.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Inspect-mode × geom advisories — re-export pure collectors from @ggts-sh/core
+ * so host plot-engine and the headless CLI share one implementation (#1531).
+ *
+ * Catalog messages for these codes also live in core
+ * (`INSPECT_GEOM_DIAGNOSTIC_CATALOG`); INTERACTION_DIAGNOSTIC_CATALOG spreads them.
+ * CLI-only helpers (`collectInspectIntentDiagnostics`, intent modes) stay on
+ * `@ggts-sh/core` — do not re-export them here (knip).
+ */
+export { discreteColorFillDomainSizes, HIGH_CARDINALITY_DISCRETE_THRESHOLD, inspectAxisOnBarColDiagnostics, inspectAxisOnDistributionDiagnostics, inspectHighCardinalityDiagnostics, layerGeomsFromSpecLayers, } from "@ggts-sh/core";

package/dist/interaction/inspect-geom-advisories.js

@@ -0,0 +1,10 @@
+/**
+ * Inspect-mode × geom advisories — re-export pure collectors from @ggts-sh/core
+ * so host plot-engine and the headless CLI share one implementation (#1531).
+ *
+ * Catalog messages for these codes also live in core
+ * (`INSPECT_GEOM_DIAGNOSTIC_CATALOG`); INTERACTION_DIAGNOSTIC_CATALOG spreads them.
+ * CLI-only helpers (`collectInspectIntentDiagnostics`, intent modes) stay on
+ * `@ggts-sh/core` — do not re-export them here (knip).
+ */
+export { discreteColorFillDomainSizes, HIGH_CARDINALITY_DISCRETE_THRESHOLD, inspectAxisOnBarColDiagnostics, inspectAxisOnDistributionDiagnostics, inspectHighCardinalityDiagnostics, layerGeomsFromSpecLayers, } from "@ggts-sh/core";

package/dist/interaction/interaction-context.svelte.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared interaction context — the single dep bag threaded through every
+ * interaction controller factory (zoom, selection, interval, surface,
+ * inspection).
+ *
+ * Before this module each factory declared its own 6–19-field deps type and
+ * plot-engine hand-wired ~60 fields, most of them the same model / config /
+ * handler / DOM getters re-typed per controller. One context replaces the
+ * shared bag; per-factory `options` now hold only what is genuinely
+ * controller-specific (sibling ports, host-derived enablement, narrow config
+ * slices).
+ *
+ * Every field is a deferred getter or stable sink: factories must not read
+ * reactive values at construction beyond what their own docs allow. The
+ * assembly (interaction-states.svelte.ts) owns construction order.
+ */
+import type { CellValue, RenderModel } from "@ggts-sh/core";
+import type { CandidateFacts } from "@ggts-sh/core";
+import type { PlotInteractionController } from "./controller.svelte.js";
+import type { InteractionTool, PlotInspection, PlotInteractionEvent, PlotInteractionScope, PlotSelection, ResolvedInteractionConfig, ZoomEvent } from "./interaction.js";
+/** Shared dep bag for all interaction controller factories. */
+export type InteractionContext = {
+    /** Trained render model; null pre-model (SSR / first effect). */
+    readonly model: () => RenderModel | null;
+    /** Component DOM handles. */
+    readonly root: () => HTMLDivElement | null;
+    readonly captureSurface: () => HTMLDivElement | null;
+    /** External linked controller, when the plot is controller-driven. */
+    readonly interaction: () => PlotInteractionController | undefined;
+    readonly resolvedInteractionScope: () => PlotInteractionScope;
+    /** Narrow config slices over the resolved interaction config. */
+    readonly selectConfig: () => ResolvedInteractionConfig["select"];
+    readonly inspectConfig: () => ResolvedInteractionConfig["inspect"];
+    /** Component-held tooltip hover flag (markup handlers write via engine). */
+    readonly tooltipHovered: () => boolean;
+    /** Stable announcer sink. */
+    readonly announce: (message: string) => void;
+    /** Deferred handler getters (handler-only; never construction-time reads). */
+    readonly oninteraction: () => ((event: PlotInteractionEvent<Record<string, CellValue>>) => void) | undefined;
+    readonly oninspect: () => ((event: PlotInspection<Record<string, CellValue>>) => void) | undefined;
+    readonly onselect: () => ((event: PlotSelection) => void) | undefined;
+    readonly onzoom: () => ((event: ZoomEvent) => void) | undefined;
+    readonly ontoolchange: () => ((tool: InteractionTool) => void) | undefined;
+    /** Durable row identity service (semantic keys). */
+    readonly keyAt: (index: number) => PropertyKey | null;
+    readonly semanticKey: (row: Record<string, CellValue> | null, index: number | null) => PropertyKey | null;
+    readonly candidateSemanticKeys: (candidate: CandidateFacts) => PropertyKey[];
+};
+/**
+ * Fields the host must supply to build an InteractionContext. Identical in
+ * shape to the context itself — resolveInteractionContext exists so the host
+ * has one explicit seam to widen later (defaults, SSR hatches) without
+ * touching five factories again.
+ */
+export type InteractionContextDeps = InteractionContext;
+/** Build the shared interaction context from host-supplied getters. */
+export declare function resolveInteractionContext(deps: InteractionContextDeps): InteractionContext;

package/dist/interaction/interaction-context.svelte.js

@@ -0,0 +1,4 @@
+/** Build the shared interaction context from host-supplied getters. */
+export function resolveInteractionContext(deps) {
+    return { ...deps };
+}

package/dist/interaction/interaction-diagnostics.d.ts

@@ -0,0 +1,11 @@
+export type InteractionDiagnosticCode = "INTERACTION_INTERVAL_FACET_UNSUPPORTED" | "INTERACTION_INVALID_MAX_DISTANCE" | "INTERACTION_POINT_REQUIRES_KEY" | "INTERACTION_INTERVAL_PRESET_REQUIRES_KEY" | "INTERACTION_INVALID_KEY" | "INTERACTION_DUPLICATE_KEY" | "INTERACTION_UNSTABLE_KEY" | "INTERACTION_MISSING_LINEAGE" | "INTERACTION_LEGEND_REQUIRES_KEY" | "INTERACTION_LEGEND_DISCRETE_ONLY" | "INTERACTION_INTERVAL_SCALE_UNSUPPORTED" | "INTERACTION_TOOL_UNAVAILABLE" | "INTERACTION_SCOPE_WITHOUT_CONTROLLER" | "INTERACTION_HANDLER_WITHOUT_CAPABILITY" | "INTERACTION_INSPECT_X_ON_COL" | "INTERACTION_INSPECT_X_ON_BAR" | "INTERACTION_INSPECT_X_BISECTS_COL_LABELS" | "INTERACTION_INSPECT_X_BISECTS_BAR_LABELS" | "INTERACTION_INSPECT_AXIS_ON_VIOLIN" | "INTERACTION_INSPECT_AXIS_ON_BOXPLOT" | "INTERACTION_INSPECT_AXIS_ON_ERRORBAR" | "INTERACTION_INSPECT_AXIS_ON_LINERANGE" | "INTERACTION_INSPECT_AXIS_ON_POINTRANGE" | "INTERACTION_INSPECT_AXIS_ON_CROSSBAR" | "INTERACTION_INSPECT_IDENTITY_DROPPED" | "INTERACTION_DUPLICATE_INSPECT_CAPABILITY" | "INTERACTION_INSPECT_HIGH_CARDINALITY_DISCRETE";
+export interface InteractionDiagnostic {
+    readonly severity: "error" | "warning" | "advisory";
+    readonly code: InteractionDiagnosticCode;
+    readonly message: string;
+    readonly prop: string;
+    readonly actual?: unknown;
+    readonly suggestions: ReadonlyArray<string>;
+    readonly docUrl: string;
+}
+export declare const INTERACTION_DIAGNOSTIC_CATALOG: Readonly<Record<InteractionDiagnosticCode, Omit<InteractionDiagnostic, "actual">>>;