@fundar/data-chart-telling 0.0.24 → 0.0.26

package/dist/layout/plot/BasePlotLayout.svelte

@@ -1,30 +1,38 @@
-<script lang="ts" generics="TData extends Record<string, unknown>">
+<script lang="ts" generics="TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData">
   import type { ComponentProps, Snippet } from 'svelte';
-  import { SvelteSet } from 'svelte/reactivity';
   import { Plot, Pointer } from 'svelteplot';
   import { getConfiguration } from '../../configuration/config.svelte';
   import { AUTO_MARGIN_ESTIMATE, numericMargin } from './margins';
+  import { buildScale } from '../scales/buildScale';
+  import ScalesLayout from '../scales/ScalesLayout.svelte';
+  import GeometryLayout from '../geometry/GeometryLayout.svelte';
+  import CoordinatesLayout from '../coordinates/CoordinatesLayout.svelte';
+  import StylesLayout from '../styles/StylesLayout.svelte';
   import { getHover, createHover } from '../tooltip/hover.svelte';
   import { createHoverController } from '../tooltip/controller.svelte';
   import TooltipLayout from '../tooltip/TooltipLayout.svelte';
-  import type { AxisValue, AxisScale } from '../../types/plots/axis';
-  import type { AxisBasedScalesConfig } from '../../types/plots/props';
-  import type { GeoProjectionConfig } from '../../types/plots/scales/geo';
-  import type { HoverStrategy, HoverPoint } from '../../types/layout/tooltip';
-  import type { MarginConfig, TooltipConfig } from '../../types/plots/props';
+  import type { AxisValue, AxisBasedScalesConfig } from '../../types/layout/scales';
+  import type { CoordinatesConfig } from '../../types/layout/coordinates';
+  import type { StylesLayoutConfig } from '../../types/layout/styles';
+  import type { ScopedMarkerGroup } from '../../types/layout/geometry';
+  import type { HoverPoint } from '../../types/layout/tooltip';
+  import type { MarginConfig, HoverConfig } from '../../types/plots/props';
+  import type { MarkerConfig } from '../../types/markers/all';
+  import type { Series } from '../../types/plots/data/common';
+  import type { GeoFeature } from '../../types/plots/data/geo';
 
   type SveltePlotProps = ComponentProps<typeof Plot>;
 
   /**
-   * Shared chrome around every plot kind's svelteplot markup: the pointer-event
-   * wrapper, the hover/tooltip state machine, the `<Plot>` element itself, and
-   * the floating tooltip. Deliberately marker/axis-agnostic — axis-having plot
-   * kinds (line/bar/heatmap/pyramid) additionally compose `AxisLayout` /
-   * `GridLayout` / `RuleLayout` inside `children`; `GeoPlot` composes `GeoLayout`
-   * instead, since a map has no x/y axis pair. Every plot kind supplies its own
-   * `<Plot x y projection>` scale config (either directly via `x`/`y`/`projection`,
-   * or by leaving `x`/`y` unset so this component derives them from `scales`) and
-   * its own marks/markers through `children`.
+   * Shared chrome around every plot kind's svelteplot markup: the
+   * pointer-event wrapper, the hover/tooltip state machine, and the floating
+   * tooltip. Composes the Coordinates and Styles layers around every plot
+   * kind's own content, plus `GeometryLayout` (which renders nothing extra
+   * when `markers` is empty/unset). `ScalesLayout` composes in
+   * independently, only when `scales` is passed. Every plot kind supplies
+   * its own `<Plot x y projection>` scale config, either directly via
+   * `x`/`y` or by leaving them unset so this component derives them from
+   * `scales`.
    */
   let {
     width,
@@ -32,83 +40,84 @@
     data,
     getX,
     getY,
-    hoverPoints,
-    label,
-    tooltip = undefined,
-    hoverActive,
-    hoverStrategy = undefined,
-    hoverSync = undefined,
+    hover,
     x = undefined,
     y = undefined,
     scales = undefined,
-    projection = undefined,
+    coordinates = undefined,
     margins,
     marginEstimate = AUTO_MARGIN_ESTIMATE,
     xTickRotate = undefined,
-    excludeHover = undefined,
-    touchAction = undefined,
+    styles = undefined,
+    markers = undefined,
+    seriesData = undefined,
+    scopedGroups = undefined,
+    geoAllFeatures = undefined,
     containerEl = $bindable(undefined),
     children,
   }: {
     width: number;
     height: number;
-    /** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching. */
+    /** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching, and to `CoordinatesLayout` for a `domain: 'data'` projection auto-fit. */
     data: TData[];
     getX: (d: TData) => AxisValue;
     getY: (d: TData) => AxisValue;
-    hoverPoints: HoverPoint<TData>[];
-    label: (row: TData) => string;
-    tooltip?: TooltipConfig<TData>;
-    /** Whether the pointer/hover/tooltip machinery should mount at all. */
-    hoverActive: boolean;
-    /** Resolved hover strategy for the *local* hover store (ignored once a shared store is in scope). */
-    hoverStrategy?: HoverStrategy;
-    /** Resolved sync flag for the *local* hover store (ignored once a shared store is in scope). */
-    hoverSync?: boolean;
+    /** Every hover/tooltip prop this component's own hover machinery reads — see {@link HoverConfig}. */
+    hover: HoverConfig<TData>;
     /** Explicit `<Plot x>` override — bypasses `scales`-derived resolution (e.g. GeoPlot's fixed lon/lat domain). */
     x?: SveltePlotProps['x'];
     /** Explicit `<Plot y>` override — see `x`. */
     y?: SveltePlotProps['y'];
     /** Scale config `x`/`y` are derived from when not given directly. */
     scales?: AxisBasedScalesConfig<TData>;
-    /** Forwarded to `<Plot projection>` — GeoPlot only. */
-    projection?: GeoProjectionConfig;
+    /** This plot kind's coordinate system config — `GeoPlot` only (a projection + pan/zoom). */
+    coordinates?: CoordinatesConfig;
     /** Partial margin override — merged on top of the theme. */
     margins?: MarginConfig;
     /** Numeric fallback for a margin side that resolved to `'auto'` — see `numericMargin`'s doc comment. */
     marginEstimate?: Record<'top' | 'right' | 'bottom' | 'left', number>;
     /** Boosts the bottom margin for a rotated x tick label — axis-having plot kinds only. */
     xTickRotate?: number;
+    /** This plot kind's own `styles` prop, forwarded to the Styles layer. */
+    styles?: StylesLayoutConfig;
     /**
-     * When it returns `true` for a pointer event, that event is treated as a
-     * leave instead of a move — lets a nested layout (e.g. GeoLayout's inset
-     * markers) opt specific screen regions out of this plot's own hover
-     * matching without this component needing to know why.
+     * This plot kind's own markers array. Accepts a plain array, or a
+     * builder function for a plot kind whose own marker construction needs
+     * `setHoverMatch`/`clearHoverMatch`, only available once this
+     * component's own hover controller is set up.
      */
-    excludeHover?: (e: PointerEvent) => boolean;
-    /** Forwarded to the wrapper div's `touch-action` CSS — GeoPlot's zoom/pan only. */
-    touchAction?: string;
-    /** The wrapper div's own element — bind for a nested layout that needs it for its own gesture handling (e.g. GeoLayout's zoom/rotate). */
+    markers?:
+      | MarkerConfig[]
+      | ((hover: { setHoverMatch: (rows: TData[]) => void; clearHoverMatch: () => void }) => MarkerConfig[]);
+    /** All resolved series, forwarded to `GeometryLayout` — axis-based kinds only. Independently generic over `TSeries` (defaults to `TData`). */
+    seriesData?: Series<TSeries>[];
+    /** Per-series `GeometryLayout` groups — axis-based kinds only, same `TSeries` as `seriesData`. */
+    scopedGroups?: ScopedMarkerGroup<TSeries>[];
+    /** `GeoPlot`'s own untouched, tagged features, forwarded to `GeometryLayout` — `inset` marker only. */
+    geoAllFeatures?: (GeoFeature<Record<string, unknown>> & { __id: string })[];
+    /** The wrapper div's own element — bind for a nested layout that needs it for its own gesture handling (e.g. `CoordinatesLayout`'s zoom/rotate). */
     containerEl?: HTMLDivElement;
     /**
-     * `matchedPoints` carries the source `row` alongside the display fields
-     * — needed by plot kinds whose semantic value isn't tied to a fixed
-     * visual axis (e.g. `BarPlot`'s category, which can be drawn on either
-     * axis depending on orientation), so a template can resolve it straight
-     * off `row` instead of assuming which of `.x`/`.y` it landed on.
-     * `impliesRuleX`/`impliesRuleY` tell the plot kind whether the active
-     * strategy implies a crosshair rule on each axis by default.
-     * `numericMargins` lets a nested layout align itself with the plot's own
-     * content box without recomputing margins itself.
+     * `matchedPoints` carries the source `row` alongside the display fields,
+     * so a template can resolve it straight off `row` instead of assuming
+     * which visual axis it landed on. `activePoint` is the one matched point
+     * under the cursor. `numericMargins` lets a nested layout align itself
+     * with the plot's own content box. `setHoverMatch`/`clearHoverMatch` let
+     * a plot kind drive the match itself instead of svelteplot's
+     * distance-based `<Pointer>` — see `hover.pointMatching`. When `markers`
+     * is given, this is `GeometryLayout`'s own `children` instead of raw
+     * plot content. Optional — a plot kind whose every mark is a `markers`
+     * entry has nothing left to render here.
      */
-    children: Snippet<
+    children?: Snippet<
       [{
         matchedPoints: HoverPoint<TData>[];
-        ruleX: AxisValue | null;
-        ruleY: AxisValue | null;
-        impliesRuleX: boolean;
-        impliesRuleY: boolean;
+        activePoint: HoverPoint<TData> | null;
+        impliesCrosshairX: boolean;
+        impliesCrosshairY: boolean;
         numericMargins: { top: number; right: number; bottom: number; left: number };
+        setHoverMatch: (rows: TData[]) => void;
+        clearHoverMatch: () => void;
       }]
     >;
   } = $props();
@@ -142,112 +151,64 @@
     left: numericMargin('left', computedMargins.left, marginEstimate),
   });
 
-  /** One representative row per unique axis value (first occurrence in `data`). */
-  function uniqueRows(rows: TData[], getAxisValue: (d: TData) => AxisValue): TData[] {
-    const seen = new SvelteSet<AxisValue>();
-    const out: TData[] = [];
-    for (const row of rows) {
-      const v = getAxisValue(row);
-      if (seen.has(v)) continue;
-      seen.add(v);
-      out.push(row);
-    }
-    return out;
-  }
-
-  /**
-   * svelteplot's own `sort` scale option only toggles a fixed ascending sort
-   * (lexicographic for strings) — it can't take a custom comparator. When the
-   * caller supplies one via `scales.x.sort`/`scales.y.sort` for a string-valued
-   * axis (e.g. dates formatted as text, or categories ordered by another
-   * field), compute the ordered domain ourselves and hand it to the scale as
-   * an explicit `domain`, which svelteplot does respect as-is for ordinal
-   * scales. The comparator receives one representative row per unique axis
-   * value, not just the axis value itself, so it can sort by this axis's own
-   * value or by any other field on the row.
-   */
-  function sortedScale(scale: AxisScale<TData> | undefined, rows: TData[], getAxisValue: (d: TData) => AxisValue): AxisScale<TData> | undefined {
-    const sort = scale?.sort;
-    if (!sort || scale?.domain) return scale;
-    const reps = uniqueRows(rows, getAxisValue);
-    if (reps.length === 0 || !reps.every((r) => typeof getAxisValue(r) === 'string')) return scale;
-    const domain = [...reps].sort(sort).map(getAxisValue);
-    return { ...scale, domain };
-  }
-
-  /**
-   * `grid`/`seriesLayout`/`seriesPadding` and a vertical `label` are rendered
-   * by `GridLayout`/`AxisLayout` themselves rather than passed through to
-   * svelteplot (which only draws a fixed-style implicit grid, and never
-   * rotates the axis title) — stripped here so they don't also trigger
-   * svelteplot's own (duplicate, unstyled) rendering of them. Also the single
-   * place a plot kind's fully-resolved `scales.x`/`scales.y` (defaults
-   * already merged in by the plot itself) turns into what svelteplot's own,
-   * narrower scale option type actually accepts.
-   */
-  function finalizeScale(scale: AxisScale<TData> | undefined, rows: TData[], getAxisValue: (d: TData) => AxisValue): AxisScale<TData> | undefined {
-    const sorted = sortedScale(scale, rows, getAxisValue);
-    if (!sorted) return sorted;
-    const out = { ...sorted };
-    delete out.grid;
-    delete out.seriesLayout;
-    delete out.seriesPadding;
-    if (scale?.labelOrientation === 'vertical') delete out.label;
-    return out;
-  }
-
   // Cast to svelteplot's own (narrower, axis-specific) scale option type:
-  // finalizeScale has already stripped the fields that don't exist there
+  // buildScale has already stripped the fields that don't exist there
   // (grid, the vertical label config, BarPlot's series-layout knobs).
-  const resolvedX = $derived(x !== undefined ? x : (finalizeScale(scales?.x, data, getX) as SveltePlotProps['x']));
-  const resolvedY = $derived(y !== undefined ? y : (finalizeScale(scales?.y, data, getY) as SveltePlotProps['y']));
+  const resolvedX = $derived(x !== undefined ? x : (buildScale(scales?.x, data, getX) as SveltePlotProps['x']));
+  const resolvedY = $derived(y !== undefined ? y : (buildScale(scales?.y, data, getY) as SveltePlotProps['y']));
+
+  /** Only ever meaningful for `GeoPlot` — every other kind leaves `coordinates` unset. */
+  const touchAction = $derived(coordinates?.zoom !== false && coordinates?.zoom != null ? 'none' : undefined);
 
   // ── Hover / tooltip ───────────────────────────────────────────────────────
   const sharedHover = getHover();
   const localHover = createHover();
-  const hover = $derived(sharedHover ?? localHover);
+  const hoverStore = $derived(sharedHover ?? localHover);
+
+  /** Declared intent, defaulted — see {@link HoverConfig.pointMatching}. */
+  const pointMatchingStrategy = $derived(hover.pointMatching ?? 'nearest');
 
   /**
-   * Which axes svelteplot's `<Pointer>` should search along — derived from
-   * the *active* strategy rather than taken as separate props. Passing
-   * `undefined` for an axis collapses every point to the same coordinate on
-   * that axis in the search quadtree, making the nearest-neighbor match
-   * ignore it entirely: `'x'` (line/bar) searches x only, `'y'` (pyramid —
-   * its category sits on y, and a bar's own magnitude on x shouldn't pull in
-   * a *different* row just because that row's bar tip is nearer in x)
-   * searches y only, and `'punctual'` (heatmap/geo's 2D grid) needs both.
-   * Reactive to `hover.strategy`, so a caller overriding `tooltip.strategy`/a
-   * hover marker's `strategy` away from the plot kind's default gets
-   * correctly-dimensioned matching too.
+   * Which axes svelteplot's `<Pointer>` should search along, derived from
+   * the active strategy. `undefined` for an axis collapses every point to
+   * the same coordinate on that axis, excluding it from the match entirely.
    */
-  const pointerMatchX = $derived(hover.strategy === 'y' ? undefined : getX);
-  const pointerMatchY = $derived(hover.strategy === 'x' ? undefined : getY);
+  const pointerMatchX = $derived(hoverStore.strategy === 'y' ? undefined : getX);
+  const pointerMatchY = $derived(hoverStore.strategy === 'x' ? undefined : getY);
 
   $effect(() => {
     if (sharedHover) return;
-    localHover.strategy = hoverStrategy ?? 'x';
-    localHover.sync = hoverSync ?? false;
+    localHover.strategy = hover.strategy ?? 'x';
+    localHover.sync = hover.sync ?? false;
   });
 
   const ctrl = createHoverController<TData>({
-    hover: () => hover,
-    facetId: () => tooltip?.facetId ?? '',
-    points: () => hoverPoints,
+    hover: () => hoverStore,
+    facetId: () => hover.tooltip?.facetId ?? '',
+    points: () => hover.points,
     getX: () => getX,
     getY: () => getY,
-    label: () => label,
-    seriesFilter: () => tooltip?.series,
+    label: () => hover.label,
+    seriesFilter: () => hover.tooltip?.series,
     width: () => width,
     height: () => height,
   });
 
   function onMove(e: PointerEvent) {
-    if (excludeHover?.(e)) {
+    if (hover.exclude?.(e)) {
       ctrl.onLeave();
       return;
     }
     ctrl.onMove(e);
   }
+
+  const resolvedMarkers = $derived(
+    typeof markers === 'function' ? markers({ setHoverMatch: ctrl.onPointer, clearHoverMatch: ctrl.onLeave }) : markers,
+  );
+
+  /** `hover.crosshair === false` forces both off, overriding the strategy-implied default — see {@link HoverConfig.crosshair}. */
+  const effectiveImpliesCrosshairX = $derived(hover.crosshair === false ? false : ctrl.impliesCrosshairX);
+  const effectiveImpliesCrosshairY = $derived(hover.crosshair === false ? false : ctrl.impliesCrosshairY);
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
@@ -256,40 +217,66 @@
   bind:this={containerEl}
   style:color={cfg.axis.color}
   style:touch-action={touchAction}
-  onpointermove={hoverActive ? onMove : undefined}
-  onpointerleave={hoverActive ? ctrl.onLeave : undefined}
+  onpointermove={hover.active ? onMove : undefined}
+  onpointerleave={hover.active ? ctrl.onLeave : undefined}
 >
-  <Plot
+  <CoordinatesLayout
     {width}
     {height}
     margin={computedMargins}
     x={resolvedX}
     y={resolvedY}
-    projection={projection as SveltePlotProps['projection']}
+    {coordinates}
+    {data}
+    {containerEl}
   >
-    {@render children({
-      matchedPoints: ctrl.points,
-      ruleX: ctrl.ruleX,
-      ruleY: ctrl.ruleY,
-      impliesRuleX: ctrl.impliesRuleX,
-      impliesRuleY: ctrl.impliesRuleY,
-      numericMargins,
-    })}
+    <StylesLayout {styles} {width} {height} {numericMargins} />
+    {#if scales !== undefined}
+      <ScalesLayout {data} {getX} {getY} {width} {height} {numericMargins} {scales} />
+    {/if}
+    <GeometryLayout
+      markers={resolvedMarkers}
+      seriesData={seriesData ?? []}
+      scopedGroups={scopedGroups ?? []}
+      matchedPoints={ctrl.points}
+      activePoint={ctrl.activePoint}
+      impliesCrosshairX={effectiveImpliesCrosshairX}
+      impliesCrosshairY={effectiveImpliesCrosshairY}
+      {width}
+      {height}
+      {numericMargins}
+      {data}
+      {geoAllFeatures}
+      tooltipAnchorX={hover.tooltip?.anchorX}
+      tooltipAnchorY={hover.tooltip?.anchorY}
+    >
+      {@render children?.({
+        matchedPoints: ctrl.points,
+        activePoint: ctrl.activePoint,
+        impliesCrosshairX: effectiveImpliesCrosshairX,
+        impliesCrosshairY: effectiveImpliesCrosshairY,
+        numericMargins,
+        setHoverMatch: ctrl.onPointer,
+        clearHoverMatch: ctrl.onLeave,
+      })}
+    </GeometryLayout>
 
-    {#if hoverActive}
+    {#if hover.active && pointMatchingStrategy === 'nearest'}
       <Pointer {data} x={pointerMatchX} y={pointerMatchY} maxDistance={400} onupdate={ctrl.onPointer} />
     {/if}
-  </Plot>
+  </CoordinatesLayout>
 
-  {#if tooltip}
+  {#if hover.tooltip}
     <TooltipLayout
       visible={ctrl.showTooltip && ctrl.tooltipPosition != null}
       x={ctrl.tooltipPosition?.x ?? 0}
       y={ctrl.tooltipPosition?.y ?? 0}
       bounds={{ width, height }}
       rows={ctrl.matchedRows.map((p) => p.row)}
-      format={tooltip.format}
-      content={tooltip.content}
+      format={hover.tooltip.format}
+      content={hover.tooltip.content}
+      anchorX={hover.tooltip.anchorX}
+      anchorY={hover.tooltip.anchorY}
     />
   {/if}
 </div>

package/dist/layout/plot/BasePlotLayout.svelte.d.ts

@@ -1,74 +1,84 @@
 import type { Snippet } from 'svelte';
-import type { AxisValue } from '../../types/plots/axis';
-import type { AxisBasedScalesConfig } from '../../types/plots/props';
-import type { GeoProjectionConfig } from '../../types/plots/scales/geo';
-import type { HoverStrategy, HoverPoint } from '../../types/layout/tooltip';
-import type { MarginConfig, TooltipConfig } from '../../types/plots/props';
-declare function $$render<TData extends Record<string, unknown>>(): {
+import type { AxisValue, AxisBasedScalesConfig } from '../../types/layout/scales';
+import type { CoordinatesConfig } from '../../types/layout/coordinates';
+import type { StylesLayoutConfig } from '../../types/layout/styles';
+import type { ScopedMarkerGroup } from '../../types/layout/geometry';
+import type { HoverPoint } from '../../types/layout/tooltip';
+import type { MarginConfig, HoverConfig } from '../../types/plots/props';
+import type { MarkerConfig } from '../../types/markers/all';
+import type { Series } from '../../types/plots/data/common';
+import type { GeoFeature } from '../../types/plots/data/geo';
+declare function $$render<TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData>(): {
     props: {
         width: number;
         height: number;
-        /** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching. */
+        /** Flat rows fed to svelteplot's `<Pointer>` for nearest-point matching, and to `CoordinatesLayout` for a `domain: 'data'` projection auto-fit. */
         data: TData[];
         getX: (d: TData) => AxisValue;
         getY: (d: TData) => AxisValue;
-        hoverPoints: HoverPoint<TData>[];
-        label: (row: TData) => string;
-        tooltip?: TooltipConfig<TData>;
-        /** Whether the pointer/hover/tooltip machinery should mount at all. */
-        hoverActive: boolean;
-        /** Resolved hover strategy for the *local* hover store (ignored once a shared store is in scope). */
-        hoverStrategy?: HoverStrategy;
-        /** Resolved sync flag for the *local* hover store (ignored once a shared store is in scope). */
-        hoverSync?: boolean;
+        /** Every hover/tooltip prop this component's own hover machinery reads — see {@link HoverConfig}. */
+        hover: HoverConfig<TData>;
         /** Explicit `<Plot x>` override — bypasses `scales`-derived resolution (e.g. GeoPlot's fixed lon/lat domain). */
-        x?: false | Partial<import("svelteplot/types/scale.js").XScaleOptions> | import("svelteplot/types/data.js").RawValue[] | undefined;
+        x?: false | import("svelteplot/types/data.js").RawValue[] | Partial<import("svelteplot/types/scale.js").XScaleOptions> | undefined;
         /** Explicit `<Plot y>` override — see `x`. */
         y?: false | import("svelteplot/types/data.js").RawValue[] | Partial<import("svelteplot/types/scale.js").YScaleOptions> | undefined;
         /** Scale config `x`/`y` are derived from when not given directly. */
         scales?: AxisBasedScalesConfig<TData>;
-        /** Forwarded to `<Plot projection>` — GeoPlot only. */
-        projection?: GeoProjectionConfig;
+        /** This plot kind's coordinate system config — `GeoPlot` only (a projection + pan/zoom). */
+        coordinates?: CoordinatesConfig;
         /** Partial margin override — merged on top of the theme. */
         margins?: MarginConfig;
         /** Numeric fallback for a margin side that resolved to `'auto'` — see `numericMargin`'s doc comment. */
         marginEstimate?: Record<"top" | "right" | "bottom" | "left", number>;
         /** Boosts the bottom margin for a rotated x tick label — axis-having plot kinds only. */
         xTickRotate?: number;
+        /** This plot kind's own `styles` prop, forwarded to the Styles layer. */
+        styles?: StylesLayoutConfig;
         /**
-         * When it returns `true` for a pointer event, that event is treated as a
-         * leave instead of a move — lets a nested layout (e.g. GeoLayout's inset
-         * markers) opt specific screen regions out of this plot's own hover
-         * matching without this component needing to know why.
+         * This plot kind's own markers array. Accepts a plain array, or a
+         * builder function for a plot kind whose own marker construction needs
+         * `setHoverMatch`/`clearHoverMatch`, only available once this
+         * component's own hover controller is set up.
          */
-        excludeHover?: (e: PointerEvent) => boolean;
-        /** Forwarded to the wrapper div's `touch-action` CSS — GeoPlot's zoom/pan only. */
-        touchAction?: string;
-        /** The wrapper div's own element — bind for a nested layout that needs it for its own gesture handling (e.g. GeoLayout's zoom/rotate). */
+        markers?: MarkerConfig[] | ((hover: {
+            setHoverMatch: (rows: TData[]) => void;
+            clearHoverMatch: () => void;
+        }) => MarkerConfig[]);
+        /** All resolved series, forwarded to `GeometryLayout` — axis-based kinds only. Independently generic over `TSeries` (defaults to `TData`). */
+        seriesData?: Series<TSeries>[];
+        /** Per-series `GeometryLayout` groups — axis-based kinds only, same `TSeries` as `seriesData`. */
+        scopedGroups?: ScopedMarkerGroup<TSeries>[];
+        /** `GeoPlot`'s own untouched, tagged features, forwarded to `GeometryLayout` — `inset` marker only. */
+        geoAllFeatures?: (GeoFeature<Record<string, unknown>> & {
+            __id: string;
+        })[];
+        /** The wrapper div's own element — bind for a nested layout that needs it for its own gesture handling (e.g. `CoordinatesLayout`'s zoom/rotate). */
         containerEl?: HTMLDivElement;
         /**
-         * `matchedPoints` carries the source `row` alongside the display fields
-         * — needed by plot kinds whose semantic value isn't tied to a fixed
-         * visual axis (e.g. `BarPlot`'s category, which can be drawn on either
-         * axis depending on orientation), so a template can resolve it straight
-         * off `row` instead of assuming which of `.x`/`.y` it landed on.
-         * `impliesRuleX`/`impliesRuleY` tell the plot kind whether the active
-         * strategy implies a crosshair rule on each axis by default.
-         * `numericMargins` lets a nested layout align itself with the plot's own
-         * content box without recomputing margins itself.
+         * `matchedPoints` carries the source `row` alongside the display fields,
+         * so a template can resolve it straight off `row` instead of assuming
+         * which visual axis it landed on. `activePoint` is the one matched point
+         * under the cursor. `numericMargins` lets a nested layout align itself
+         * with the plot's own content box. `setHoverMatch`/`clearHoverMatch` let
+         * a plot kind drive the match itself instead of svelteplot's
+         * distance-based `<Pointer>` — see `hover.pointMatching`. When `markers`
+         * is given, this is `GeometryLayout`'s own `children` instead of raw
+         * plot content. Optional — a plot kind whose every mark is a `markers`
+         * entry has nothing left to render here.
          */
-        children: Snippet<[{
+        children?: Snippet<[{
             matchedPoints: HoverPoint<TData>[];
-            ruleX: AxisValue | null;
-            ruleY: AxisValue | null;
-            impliesRuleX: boolean;
-            impliesRuleY: boolean;
+            activePoint: HoverPoint<TData> | null;
+            impliesCrosshairX: boolean;
+            impliesCrosshairY: boolean;
             numericMargins: {
                 top: number;
                 right: number;
                 bottom: number;
                 left: number;
             };
+            setHoverMatch: (rows: TData[]) => void;
+            clearHoverMatch: () => void;
         }]>;
     };
     exports: {};
@@ -76,20 +86,20 @@ declare function $$render<TData extends Record<string, unknown>>(): {
     slots: {};
     events: {};
 };
-declare class __sveltets_Render<TData extends Record<string, unknown>> {
-    props(): ReturnType<typeof $$render<TData>>['props'];
-    events(): ReturnType<typeof $$render<TData>>['events'];
-    slots(): ReturnType<typeof $$render<TData>>['slots'];
+declare class __sveltets_Render<TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData> {
+    props(): ReturnType<typeof $$render<TData, TSeries>>['props'];
+    events(): ReturnType<typeof $$render<TData, TSeries>>['events'];
+    slots(): ReturnType<typeof $$render<TData, TSeries>>['slots'];
     bindings(): "containerEl";
     exports(): {};
 }
 interface $$IsomorphicComponent {
-    new <TData extends Record<string, unknown>>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData>['props']>, ReturnType<__sveltets_Render<TData>['events']>, ReturnType<__sveltets_Render<TData>['slots']>> & {
-        $$bindings?: ReturnType<__sveltets_Render<TData>['bindings']>;
-    } & ReturnType<__sveltets_Render<TData>['exports']>;
-    <TData extends Record<string, unknown>>(internal: unknown, props: ReturnType<__sveltets_Render<TData>['props']> & {}): ReturnType<__sveltets_Render<TData>['exports']>;
-    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+    new <TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<TData, TSeries>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<TData, TSeries>['props']>, ReturnType<__sveltets_Render<TData, TSeries>['events']>, ReturnType<__sveltets_Render<TData, TSeries>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<TData, TSeries>['bindings']>;
+    } & ReturnType<__sveltets_Render<TData, TSeries>['exports']>;
+    <TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData>(internal: unknown, props: ReturnType<__sveltets_Render<TData, TSeries>['props']> & {}): ReturnType<__sveltets_Render<TData, TSeries>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any, any>['bindings']>;
 }
 declare const BasePlotLayout: $$IsomorphicComponent;
-type BasePlotLayout<TData extends Record<string, unknown>> = InstanceType<typeof BasePlotLayout<TData>>;
+type BasePlotLayout<TData extends Record<string, unknown>, TSeries extends Record<string, unknown> = TData> = InstanceType<typeof BasePlotLayout<TData, TSeries>>;
 export default BasePlotLayout;

package/dist/layout/plot/margins.d.ts

@@ -4,22 +4,6 @@ export declare const AUTO_MARGIN_ESTIMATE: {
     readonly bottom: 30;
     readonly left: 40;
 };
-/**
- * GeoPlot's own margin default — a small, uniform gap on every side, unlike
- * `AUTO_MARGIN_ESTIMATE`'s asymmetric axis-tick-label estimate (extra room
- * on the left/bottom for y tick labels and an x-axis title). A map has no
- * axes to make room for, so borrowing that estimate just left GeoPlot with
- * a lopsided, oversized margin — most visibly a much taller gap under the
- * map than an `inset` marker's own default `margin` (see `insetLayout.ts`),
- * even though both are meant to read as the same edge gap. Matching this
- * constant to that 8px inset default keeps the two visually aligned.
- */
-export declare const GEO_MARGIN_ESTIMATE: {
-    readonly top: 8;
-    readonly right: 8;
-    readonly bottom: 8;
-    readonly left: 8;
-};
 /**
  * Best-effort numeric fallback for a margin side that resolved to `'auto'`.
  * Used for layout heuristics that need *a* number before svelteplot has

package/dist/layout/plot/margins.js

@@ -1,15 +1,4 @@
 export const AUTO_MARGIN_ESTIMATE = { top: 20, right: 20, bottom: 30, left: 40 };
-/**
- * GeoPlot's own margin default — a small, uniform gap on every side, unlike
- * `AUTO_MARGIN_ESTIMATE`'s asymmetric axis-tick-label estimate (extra room
- * on the left/bottom for y tick labels and an x-axis title). A map has no
- * axes to make room for, so borrowing that estimate just left GeoPlot with
- * a lopsided, oversized margin — most visibly a much taller gap under the
- * map than an `inset` marker's own default `margin` (see `insetLayout.ts`),
- * even though both are meant to read as the same edge gap. Matching this
- * constant to that 8px inset default keeps the two visually aligned.
- */
-export const GEO_MARGIN_ESTIMATE = { top: 8, right: 8, bottom: 8, left: 8 };
 /**
  * Best-effort numeric fallback for a margin side that resolved to `'auto'`.
  * Used for layout heuristics that need *a* number before svelteplot has