@ggts-sh/svelte 0.43.0

package/dist/assembly/layout.js

@@ -0,0 +1,175 @@
+/**
+ * Pure plot-root layout chrome: inline size/theme style, responsive
+ * breakpoint helpers, tooltip viewport clamp, and legend clear-control
+ * anchor lookup. Hosts own class bindings and tool-rail visibility.
+ */
+const NARROW_TOOLS_MAX_WIDTH_PX = 560;
+const DOCKED_TOOLTIP_MAX_WIDTH_PX = 480;
+/**
+ * Pre-measure fallback for container-width plots (SSR and collapsed hosts).
+ * 52rem at the common 16px root — matches docs `.plot-panel` max width so a
+ * typical laptop does not paint a skinny chart and then jump wider after
+ * ResizeObserver. Not a phone-first size; phones are not the design target.
+ */
+const DEFAULT_PLOT_WIDTH_PX = 832;
+const DEFAULT_PLOT_HEIGHT_PX = 400;
+/**
+ * True when the width prop is omitted or `"container"` (responsive layout).
+ * Shared by resolvePlotSize, paint readiness widthMode, root class, ResizeObserver
+ * install, and plotRootInlineStyle containerWidth flag.
+ * Type predicate so fixed-mode branches narrow to `number`.
+ */
+export function isContainerWidthProp(width) {
+    return width === undefined || width === "container";
+}
+/**
+ * Resolved plot pixel size for the pipeline and root style.
+ * Container mode: measured container width, then assembled, then
+ * DEFAULT_PLOT_WIDTH_PX (832). Fixed mode: the numeric width prop (assembled
+ * fallback is unused once fixed). Height: height prop, then assembled, then 400.
+ */
+export function resolvePlotSize(input) {
+    const width = isContainerWidthProp(input.width)
+        ? (input.containerWidth ?? input.assembledWidth ?? DEFAULT_PLOT_WIDTH_PX)
+        : input.width;
+    const height = input.height ?? input.assembledHeight ?? DEFAULT_PLOT_HEIGHT_PX;
+    return { width, height };
+}
+/** True when the tool rail should use the narrow layout (width < 560). */
+export function isNarrowToolsWidth(widthPx) {
+    return widthPx < NARROW_TOOLS_MAX_WIDTH_PX;
+}
+/**
+ * True when a pinned tooltip should dock (width < 480).
+ * Prefer `isTooltipDocked` at call sites that also gate on pin state.
+ */
+export function isDockedTooltipWidth(widthPx) {
+    return widthPx < DOCKED_TOOLTIP_MAX_WIDTH_PX;
+}
+/**
+ * Whether the inspection tooltip (and root docked chrome class) should dock.
+ * Unifies root class and Tooltip `docked` prop (both used pinned + width).
+ */
+export function isTooltipDocked(input) {
+    return input.inspectionState === "pinned" && isDockedTooltipWidth(input.widthPx);
+}
+/** Stable DOM id for the plot's inspection tooltip element. */
+export function plotTooltipDomId(plotId) {
+    return `${plotId}-tooltip`;
+}
+/**
+ * Capture-surface `aria-controls` when a pinned interactive tooltip is up.
+ * Undefined otherwise (attribute omitted).
+ *
+ * Takes domain state (not pre-derived booleans) so hosts pass `inspection?.state`
+ * and inspect `contentMode` directly — same shape as `isTooltipDocked`.
+ */
+export function resolveCaptureAriaControls(input) {
+    if (input.inspectionState !== "pinned" || input.contentMode !== "interactive")
+        return undefined;
+    return plotTooltipDomId(input.plotId);
+}
+/**
+ * Tooltip layout box: min(scene, client) per axis.
+ * Uses nullish coalesce so a laid-out zero client size does not fall back
+ * to the scene (matches historical `root?.clientWidth ?? sceneWidth`).
+ */
+export function tooltipViewportSize(input) {
+    return {
+        width: Math.min(input.sceneWidth, input.clientWidth ?? input.sceneWidth),
+        height: Math.min(input.sceneHeight, input.clientHeight ?? input.sceneHeight),
+    };
+}
+/**
+ * Root `style` attribute value.
+ * Sized box: `width:…;height:…;` then raw `themeStyle` (no extra separator).
+ * Empty concatenation → `undefined` (matches host `… || undefined`).
+ */
+export function plotRootInlineStyle(input) {
+    const sizeCss = input.needsSizedBox
+        ? `width:${input.containerWidth ? "100%" : `${input.sceneWidth}px`};height:${input.sceneHeight}px;`
+        : "";
+    return `${sizeCss}${input.themeStyle}` || undefined;
+}
+/** Edge/gap pad between a pressed legend box and the Clear recovery control. */
+export const CLEAR_CONTROL_GAP_PX = 4;
+/**
+ * Compact control height — matches discrete legend row targets (min 24px AA
+ * target size) rather than the old 44×44 AAA square that dwarfed swatches.
+ */
+export const CLEAR_CONTROL_HEIGHT_PX = 24;
+/** Approximate painted width of the "Clear" label + horizontal padding (layout clamp only). */
+const CLEAR_CONTROL_WIDTH_PX = 44;
+/** Grace period after pointer leaves legend chrome before Clear fades for screenshots. */
+export const CLEAR_HIDE_DELAY_MS = 2500;
+/**
+ * Scene-local position for the legend Clear recovery control, or null to hide.
+ *
+ * Placement (collision-safe relative to the pressed legend):
+ * - **right / vertical** — prefer **below** the stack; if that would clamp into
+ *   the legend box (tall low guide), try **above**, then **left** of the box
+ * - **bottom / horizontal** — prefer **right** of the strip; else under, then above
+ *
+ * Candidates are clamped into the scene, then the first that does not intersect
+ * the pressed legend box wins. null when focus is off / nothing pressed / no match.
+ */
+export function resolveClearControlLayout(input) {
+    if (!input.legendFocusEnabled || input.pressedScale === null)
+        return null;
+    const legend = input.legends.find((entry) => entry.scale === input.pressedScale);
+    if (legend === undefined)
+        return null;
+    const position = legend.position ?? "right";
+    const direction = legend.direction ?? (position === "bottom" ? "horizontal" : "vertical");
+    const gap = CLEAR_CONTROL_GAP_PX;
+    const btnW = CLEAR_CONTROL_WIDTH_PX;
+    const btnH = CLEAR_CONTROL_HEIGHT_PX;
+    const maxLeft = Math.max(gap, input.sceneWidth - btnW - gap);
+    const maxTop = Math.max(gap, input.sceneHeight - btnH - gap);
+    const clamp = (left, top) => ({
+        left: Math.min(Math.max(gap, left), maxLeft),
+        top: Math.min(Math.max(gap, top), maxTop),
+    });
+    const overlapsLegend = (layout) => {
+        const right = layout.left + btnW;
+        const bottom = layout.top + btnH;
+        const legRight = legend.x + legend.width;
+        const legBottom = legend.y + legend.height;
+        return !(right <= legend.x ||
+            layout.left >= legRight ||
+            bottom <= legend.y ||
+            layout.top >= legBottom);
+    };
+    const candidates = position === "bottom" || direction === "horizontal"
+        ? [
+            // beside, then under, then above the horizontal strip
+            clamp(legend.x + legend.width + gap, legend.y + Math.max(0, (legend.height - btnH) / 2)),
+            clamp(legend.x, legend.y + legend.height + gap),
+            clamp(legend.x, legend.y - gap - btnH),
+        ]
+        : [
+            // under, then above, then left of the vertical stack
+            clamp(legend.x, legend.y + legend.height + gap),
+            clamp(legend.x, legend.y - gap - btnH),
+            clamp(legend.x - gap - btnW, legend.y),
+        ];
+    for (const candidate of candidates) {
+        if (!overlapsLegend(candidate))
+            return candidate;
+    }
+    // Last resort: first candidate (still scene-clamped) when every park collides
+    // (degenerate: legend fills the scene). Prefer under/beside intent over hide.
+    return candidates[0] ?? null;
+}
+/**
+ * Whether the Clear control should paint (opacity / pointer-events) while a
+ * series remains pressed. Host owns the hide timer; this pure gate only
+ * combines pressed + chrome hover/focus + elapsed hide.
+ */
+export function shouldRevealClearControl(input) {
+    if (!input.pressed)
+        return false;
+    if (input.chromeActive)
+        return true;
+    return !input.hideElapsed;
+}

package/dist/chrome/StatusChrome.svelte

@@ -0,0 +1,125 @@
+<script lang="ts">
+  /**
+   * Status / a11y chrome for GGPlot (sr-only instructions, live region,
+   * empty state, capability status). Host owns interaction state and text.
+   *
+   * Element ids stay plot-scoped so capture `aria-describedby` and live
+   * region wiring remain stable across extraction.
+   */
+  const {
+    plotId,
+    showInstructions = false,
+    description = "Use arrow keys to inspect data. Press Enter to pin. Press Escape to dismiss.",
+    activeDatumLabel = "No active datum",
+    showAreaInstruction = false,
+    showLiveRegion = false,
+    liveText = "",
+    emptyPlot = false,
+    capabilityStatus = null,
+  }: {
+    plotId: string;
+    /** When true, render description + active datum sr-only pair. */
+    showInstructions?: boolean;
+    /** Keyboard-usage description for the capture surface (tool-specific). */
+    description?: string;
+    activeDatumLabel?: string;
+    showAreaInstruction?: boolean;
+    showLiveRegion?: boolean;
+    liveText?: string;
+    emptyPlot?: boolean;
+    capabilityStatus?: string | null;
+  } = $props();
+</script>
+
+{#if showInstructions}
+  <p id={`${plotId}-description`} class="gg-sr-only">
+    {description}
+  </p>
+  <p id={`${plotId}-active`} class="gg-sr-only">
+    {activeDatumLabel}
+  </p>
+{/if}
+{#if showAreaInstruction}
+  <p class="gg-area-instruction">Choose opposite corner</p>
+{/if}
+{#if showLiveRegion}
+  <div
+    id={`${plotId}-live`}
+    class="gg-sr-only"
+    aria-live="polite"
+    aria-atomic="true"
+  >
+    {liveText}
+  </div>
+{/if}
+{#if emptyPlot}
+  <div class="gg-empty-state" role="status">No data to display</div>
+{/if}
+{#if capabilityStatus !== null}
+  <p class="gg-capability-status" role="status">{capabilityStatus}</p>
+{/if}
+
+<style>
+  .gg-area-instruction {
+    position: absolute;
+    right: 8px;
+    bottom: 8px;
+    z-index: 2;
+    margin: 0;
+    border-radius: 3px;
+    padding: 4px 7px;
+    background: var(--gg-tooltipBg, var(--gg-theme-tooltipBg, #fff));
+    color: var(--gg-foreground, var(--gg-theme-foreground, currentColor));
+    font-size: 13px;
+    line-height: 1.25;
+    pointer-events: none;
+  }
+
+  .gg-empty-state {
+    position: absolute;
+    left: 50%;
+    top: 50%;
+    transform: translate(-50%, -50%);
+    /* --gg-theme-interactionMuted is a numeric alpha token — invalid in a
+       color position (see ToolRail.svelte). Inactive chrome uses --gg-toolInactive. */
+    color: var(--gg-toolInactive, currentColor);
+    font: 12px/1.4 var(--gg-font-family, sans-serif);
+    pointer-events: none;
+  }
+
+  .gg-capability-status {
+    position: absolute;
+    top: calc(100% + 4px);
+    left: 0;
+    margin: 0;
+    /* Numeric alpha token — invalid in a color position (see ToolRail). */
+    color: var(--gg-toolInactive, currentColor);
+    font: 11px/1.4 var(--gg-font-family, sans-serif);
+  }
+
+  /* sr-only pattern (NOT display:none — must stay in the a11y tree). */
+  .gg-sr-only {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip-path: inset(50%);
+    white-space: nowrap;
+    border: 0;
+  }
+
+  /* Mirrors GGPlot root reduced-motion policy for this component scope
+     (parent `.gg-plot-root *` cannot cross Svelte style boundaries). */
+  @media (prefers-reduced-motion: reduce) {
+    .gg-area-instruction,
+    .gg-empty-state,
+    .gg-capability-status,
+    .gg-sr-only {
+      scroll-behavior: auto;
+      transition: none !important;
+      animation: none !important;
+    }
+  }
+</style>

package/dist/chrome/StatusChrome.svelte.d.ts

@@ -0,0 +1,16 @@
+type $$ComponentProps = {
+    plotId: string;
+    /** When true, render description + active datum sr-only pair. */
+    showInstructions?: boolean;
+    /** Keyboard-usage description for the capture surface (tool-specific). */
+    description?: string;
+    activeDatumLabel?: string;
+    showAreaInstruction?: boolean;
+    showLiveRegion?: boolean;
+    liveText?: string;
+    emptyPlot?: boolean;
+    capabilityStatus?: string | null;
+};
+declare const StatusChrome: import("svelte").Component<$$ComponentProps, {}, "">;
+type StatusChrome = ReturnType<typeof StatusChrome>;
+export default StatusChrome;

package/dist/chrome/ToolRail.svelte

@@ -0,0 +1,293 @@
+<script lang="ts">
+  import type {
+    InteractionTool,
+    ZoomDomains,
+  } from "../interaction/interaction.js";
+
+  type RecoveryInputSource = "keyboard" | "pointer" | "touch";
+
+  const {
+    availableTools,
+    activeTool,
+    ready,
+    emptyPlot,
+    narrow = false,
+    zoomDomains = null,
+    hasPointSelection = false,
+    hasIntervalSelection = false,
+    intervalTargetLabel,
+    canSetIntervalBounds = false,
+    canSetZoomBounds = false,
+    intervalAxes = [],
+    zoomAxes = [],
+    onChooseTool,
+    onResetZoom,
+    onClearPointSelection,
+    onClearIntervalSelection,
+    onClearCurrentInterval,
+    onEditBounds,
+  }: {
+    availableTools: readonly InteractionTool[];
+    activeTool: InteractionTool;
+    ready: boolean;
+    emptyPlot: boolean;
+    narrow?: boolean;
+    zoomDomains?: ZoomDomains | null;
+    hasPointSelection?: boolean;
+    hasIntervalSelection?: boolean;
+    intervalTargetLabel?: string | undefined;
+    canSetIntervalBounds?: boolean;
+    canSetZoomBounds?: boolean;
+    intervalAxes?: readonly ("x" | "y")[];
+    zoomAxes?: readonly ("x" | "y")[];
+    onChooseTool: (tool: InteractionTool) => void;
+    onResetZoom: (source: RecoveryInputSource) => void;
+    onClearPointSelection: (source: RecoveryInputSource) => void;
+    onClearIntervalSelection: (source: RecoveryInputSource) => void;
+    onClearCurrentInterval: (source: RecoveryInputSource) => void;
+    onEditBounds: (
+      action: "select" | "zoom",
+      axis: "x" | "y",
+      trigger: HTMLElement,
+    ) => void;
+  } = $props();
+
+  let recoveryPointerType: string | null = null;
+
+  function recoverySource(event: MouseEvent): RecoveryInputSource {
+    const source =
+      recoveryPointerType === "touch"
+        ? "touch"
+        : recoveryPointerType === null && event.detail === 0
+          ? "keyboard"
+          : "pointer";
+    recoveryPointerType = null;
+    return source;
+  }
+
+  function captureRecoveryPointer(event: PointerEvent): void {
+    recoveryPointerType = event.pointerType;
+  }
+
+  function labelFor(tool: InteractionTool): string {
+    if (tool === "select-area") return "Select area";
+    if (tool === "zoom-area") return "Zoom area";
+    if (tool === "point") return "Select point";
+    return "Inspect";
+  }
+
+  function boundsLabel(
+    action: "select" | "zoom",
+    axis: "x" | "y",
+    editing: boolean,
+  ): string {
+    const target =
+      action === "select" && intervalTargetLabel !== undefined
+        ? `: ${intervalTargetLabel}`
+        : "";
+    return `${editing ? "Edit" : "Set"} ${axis} ${action === "select" ? "selection" : "zoom"} bounds${target}`;
+  }
+
+  function panelClearLabel(): string {
+    return `Clear panel selection${intervalTargetLabel === undefined ? "" : `: ${intervalTargetLabel}`}`;
+  }
+</script>
+
+<div
+  class="gg-tool-rail"
+  class:gg-tool-rail-narrow={narrow}
+  role="toolbar"
+  aria-label="Chart interaction tools"
+  aria-busy={!ready}
+>
+  <div class="gg-tool-modes">
+    {#each availableTools as available (available)}
+      <button
+        type="button"
+        disabled={!ready ||
+          (emptyPlot &&
+            (available === "select-area" || available === "zoom-area"))}
+        class:active={activeTool === available}
+        aria-pressed={activeTool === available}
+        onclick={() => onChooseTool(available)}>{labelFor(available)}</button
+      >
+    {/each}
+  </div>
+  <div class="gg-tool-recovery-actions">
+    {#if zoomDomains !== null}
+      <button
+        type="button"
+        disabled={!ready}
+        onpointerdown={captureRecoveryPointer}
+        onpointercancel={() => (recoveryPointerType = null)}
+        onclick={(event) => onResetZoom(recoverySource(event))}
+        >Reset zoom</button
+      >
+    {/if}
+    {#if canSetZoomBounds}
+      {#each zoomAxes as axis (axis)}
+        <button
+          type="button"
+          disabled={!ready}
+          onclick={(event) => onEditBounds("zoom", axis, event.currentTarget)}
+          >{boundsLabel("zoom", axis, zoomDomains !== null)}</button
+        >
+      {/each}
+    {/if}
+    {#if hasPointSelection}
+      <button
+        type="button"
+        disabled={!ready}
+        onpointerdown={captureRecoveryPointer}
+        onpointercancel={() => (recoveryPointerType = null)}
+        onclick={(event) => onClearPointSelection(recoverySource(event))}
+        >Clear selection</button
+      >
+    {/if}
+    {#if hasIntervalSelection}
+      <button
+        type="button"
+        disabled={!ready}
+        onpointerdown={captureRecoveryPointer}
+        onpointercancel={() => (recoveryPointerType = null)}
+        onclick={(event) => onClearCurrentInterval(recoverySource(event))}
+        >{panelClearLabel()}</button
+      >
+      <button
+        type="button"
+        disabled={!ready}
+        onpointerdown={captureRecoveryPointer}
+        onpointercancel={() => (recoveryPointerType = null)}
+        onclick={(event) => onClearIntervalSelection(recoverySource(event))}
+        >Clear all selections</button
+      >
+    {/if}
+    {#if canSetIntervalBounds}
+      {#each intervalAxes as axis (axis)}
+        <button
+          type="button"
+          disabled={!ready}
+          onclick={(event) => onEditBounds("select", axis, event.currentTarget)}
+          >{boundsLabel("select", axis, hasIntervalSelection)}</button
+        >
+      {/each}
+    {/if}
+  </div>
+</div>
+
+<style>
+  .gg-tool-rail {
+    position: absolute;
+    left: 8px;
+    right: 8px;
+    top: -48px;
+    display: grid;
+    /* Modes keep their content width; R3 recovery/bounds actions can outgrow
+       any plot width, so their track shrinks and scrolls instead of
+       overlapping the mode tabs. */
+    grid-template-columns: auto minmax(0, 1fr);
+    gap: 4px;
+    align-items: center;
+    z-index: 1;
+    line-height: 1.2;
+    pointer-events: auto;
+  }
+
+  .gg-tool-modes,
+  .gg-tool-recovery-actions {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+  }
+
+  .gg-tool-recovery-actions {
+    overflow-x: auto;
+  }
+
+  .gg-tool-rail button {
+    min-height: 44px;
+    min-width: 44px;
+    border: 0;
+    border-bottom: 2px solid transparent;
+    border-radius: 0;
+    padding: 0 10px;
+    background: transparent;
+    /* --gg-theme-interactionMuted is a NUMERIC alpha token (theme.ts
+       interactionMuted: 0.36). Inactive chrome ink uses --gg-toolInactive so
+       it never collides with --gg-interactionMuted (themeVar opacity). */
+    color: var(--gg-toolInactive, currentColor);
+    font: inherit;
+    font-size: 14px;
+    white-space: nowrap;
+    flex-shrink: 0;
+  }
+
+  .gg-tool-rail button:focus-visible {
+    outline: 2px solid var(--gg-focusRing, var(--gg-theme-focusRing, Highlight));
+    outline-offset: 2px;
+  }
+
+  .gg-tool-rail button.active {
+    border-bottom-color: var(
+      --gg-toolActive,
+      var(--gg-theme-toolActive, currentColor)
+    );
+    color: var(--gg-toolActive, var(--gg-theme-toolActive, currentColor));
+  }
+
+  .gg-tool-recovery-actions:empty {
+    display: none;
+  }
+
+  /* Container queries cascade across component boundaries; keep the
+     responsive narrow layout for engines that honour named containers. */
+  @container gg-plot (max-width: 559px) {
+    .gg-tool-rail {
+      top: -92px;
+      grid-template-columns: 1fr;
+      grid-template-rows: auto auto;
+    }
+
+    .gg-tool-modes,
+    .gg-tool-recovery-actions {
+      width: 100%;
+    }
+  }
+
+  /* Prop-driven fallback for engines that do not apply a query to
+     descendants of a component-owned named container during hydration. */
+  .gg-tool-rail-narrow {
+    top: -92px;
+    grid-template-columns: 1fr;
+    grid-template-rows: auto auto;
+  }
+
+  .gg-tool-rail-narrow .gg-tool-modes,
+  .gg-tool-rail-narrow .gg-tool-recovery-actions {
+    width: 100%;
+  }
+
+  @media (forced-colors: active) {
+    .gg-tool-rail button:focus-visible {
+      outline-color: Highlight;
+    }
+
+    .gg-tool-rail button.active {
+      border-bottom-color: Highlight;
+      color: ButtonText;
+    }
+
+    /* Chromium does not repaint a button's forced text/border color when
+       `disabled` is removed unless the COMPUTED value changes with the state
+       (these buttons render disabled during SSR and are enabled after
+       hydration, so without this rule they froze race-dependently on the
+       disabled GrayText paint — PR #160's vr flake). Both properties are
+       needed: the base rule's `transparent` border is also forced-painted.
+       Placed after `.active` so a disabled active tool still reads as
+       disabled. */
+    .gg-tool-rail button:disabled {
+      border-bottom-color: GrayText;
+      color: GrayText;
+    }
+  }
+</style>

package/dist/chrome/ToolRail.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { InteractionTool, ZoomDomains } from "../interaction/interaction.js";
+type RecoveryInputSource = "keyboard" | "pointer" | "touch";
+type $$ComponentProps = {
+    availableTools: readonly InteractionTool[];
+    activeTool: InteractionTool;
+    ready: boolean;
+    emptyPlot: boolean;
+    narrow?: boolean;
+    zoomDomains?: ZoomDomains | null;
+    hasPointSelection?: boolean;
+    hasIntervalSelection?: boolean;
+    intervalTargetLabel?: string | undefined;
+    canSetIntervalBounds?: boolean;
+    canSetZoomBounds?: boolean;
+    intervalAxes?: readonly ("x" | "y")[];
+    zoomAxes?: readonly ("x" | "y")[];
+    onChooseTool: (tool: InteractionTool) => void;
+    onResetZoom: (source: RecoveryInputSource) => void;
+    onClearPointSelection: (source: RecoveryInputSource) => void;
+    onClearIntervalSelection: (source: RecoveryInputSource) => void;
+    onClearCurrentInterval: (source: RecoveryInputSource) => void;
+    onEditBounds: (action: "select" | "zoom", axis: "x" | "y", trigger: HTMLElement) => void;
+};
+declare const ToolRail: import("svelte").Component<$$ComponentProps, {}, "">;
+type ToolRail = ReturnType<typeof ToolRail>;
+export default ToolRail;

package/dist/chrome/chrome-state.svelte.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Plot chrome controller extracted from GGPlot for S8.
+ *
+ * Owns the fifteen construction-time chrome deriveds (tool rail, capability
+ * status, precise axes, theme/root style, etc.) plus `markLabel` as a
+ * derived-FUNCTION accessor and `datumLabel` as a plain method.
+ *
+ * Pure deriveds only — no $state, no handlers, no effects. Every construction
+ * input is earlier-declared at the host factory site (original line 581).
+ */
+import type { CellValue, RenderModel } from "@ggts-sh/core";
+import { type InteractionDiagnostic, type InteractionTool, type PlotInteractionInterval, type ResolvedInteractionConfig } from "../interaction/interaction.js";
+import type { ContinuousZoomDomains } from "../scene/geometry.js";
+export type PlotChromeStateDeps = {
+    model: () => RenderModel | null;
+    /** Narrow getter over `interactionConfig.zoom`. */
+    zoomConfig: () => ResolvedInteractionConfig["zoom"];
+    /** Narrow getter over `interactionConfig.select`. */
+    selectConfig: () => ResolvedInteractionConfig["select"];
+    /** Configured (unfiltered) available tools from normalizeInteractionConfig. */
+    configuredAvailableTools: () => readonly InteractionTool[];
+    /** Interaction config diagnostics (facet-unsupported, etc.). */
+    interactionDiagnostics: () => readonly InteractionDiagnostic[];
+    interactive: () => boolean;
+    effectiveZoomDomains: () => ContinuousZoomDomains | null;
+    effectiveIntervals: () => readonly PlotInteractionInterval<PropertyKey>[];
+    /** Host alias over the selection controller. */
+    effectiveSelectedKeys: () => readonly PropertyKey[];
+    effectiveEmphasisKeys: () => readonly PropertyKey[];
+    legendFocusEnabled: () => boolean;
+    hasCanvas: () => boolean;
+    /** Width prop (number | "container" | undefined). */
+    width: () => number | "container" | undefined;
+    resolvedWidth: () => number;
+    resolvedHeight: () => number;
+};
+export type PlotChromeState = {
+    readonly availableTools: readonly InteractionTool[];
+    readonly canPublishPointSelection: boolean;
+    readonly hasPointSelection: boolean;
+    readonly hasIntervalSelection: boolean;
+    readonly showToolRail: boolean;
+    readonly emptyPlot: boolean;
+    readonly preciseIntervalAxes: readonly ("x" | "y")[];
+    readonly preciseZoomAxes: readonly ("x" | "y")[];
+    readonly areaScaleDiagnostics: readonly InteractionDiagnostic[];
+    readonly legendDiagnostics: readonly InteractionDiagnostic[];
+    readonly capabilityStatus: string | null;
+    readonly rootStyle: string | undefined;
+    /**
+     * Derived function accessor — callback identity changes only when `model`
+     * changes (codex P2-8 / r2 P2-4).
+     */
+    readonly markLabel: (row: number) => string;
+    /** Method reading the current model at call time. */
+    datumLabel(values: Record<string, CellValue> | null): string;
+};
+/**
+ * Create the plot chrome controller. All deriveds are construction-time —
+ * every dep is earlier-declared at the host factory position. No $state,
+ * handlers, or effects.
+ */
+export declare function createPlotChromeState(deps: PlotChromeStateDeps): PlotChromeState;