@ggts-sh/svelte 0.43.0

package/dist/legend/resolve-legend-filter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Resolve legend-filter capability from host-only GuideLegend `filter` layers
+ * and the deprecated plot-level `legendFilter` prop.
+ *
+ * Interactions stay off PortableSpec: `filter` is stripped before guideLegend()
+ * and travels as registry layer kind `legendFilter`.
+ *
+ * Skeleton (off / children→channels / plot-alone→"all") lives in
+ * resolve-legend-capability.ts; this module owns only the filter-specific
+ * merge: last explicit `mode`/`multiple` wins (plot first, then children in
+ * registry order).
+ */
+import type { LegendFilterInput } from "./filter.js";
+import { type LegendChannelSet } from "./resolve-legend-capability.js";
+/** Aesthetic channel a GuideLegend may enable for filter (non-position). */
+type LegendFilterChannel = "color" | "fill" | "size" | "linewidth" | "alpha" | "shape" | "linetype";
+/** One GuideLegend's host-only filter contribution (null when filter is off). */
+export type LegendFilterLayerValue = {
+    readonly channel: LegendFilterChannel;
+    readonly input: Exclude<LegendFilterInput, false>;
+} | null;
+export type LegendFilterChannelSet = LegendChannelSet;
+export type ResolvedLegendFilterCapability = {
+    /**
+     * Requested opt-in for wiring advisories (truthy when any child or plot
+     * prop enables filter).
+     */
+    readonly requested: LegendFilterInput | false;
+    /** Value fed to createLegendFilterState / capability resolve. */
+    readonly configInput: LegendFilterInput | false;
+    /**
+     * `"all"` = deprecated plot prop only (every discrete filterable legend).
+     * Otherwise only legends whose aesthetics intersect this set get checkboxes.
+     */
+    readonly channels: LegendFilterChannelSet;
+};
+/** Minimal entry shape for channel filtering (avoids importing .svelte.ts). */
+type FilterableEntryLike = {
+    readonly legend: {
+        readonly scale: string;
+        readonly aesthetics?: readonly string[];
+    };
+};
+type LegendFilterLayerLike = {
+    readonly kind: string;
+    /** Live getter or plain field — only read when kind is legendFilter. */
+    readonly value?: unknown;
+};
+/**
+ * Combine deprecated plot prop + GuideLegend filter children into one capability.
+ * Children define per-channel enablement when present; plot prop alone is `"all"`.
+ */
+export declare function resolveLegendFilterCapability(input: {
+    readonly plotProp: LegendFilterInput | undefined;
+    readonly layers: readonly LegendFilterLayerLike[];
+}): ResolvedLegendFilterCapability;
+/**
+ * Keep filterable targets whose scene legend aesthetics intersect the
+ * enabled channel set. Merged legends expose all aesthetics on
+ * `legend.aesthetics` (primary `scale` alone is not enough).
+ */
+export declare function filterFilterableLegendEntries<T extends FilterableEntryLike>(entries: readonly T[], channels: LegendFilterChannelSet): T[];
+/** True when `filter` is an active opt-in (boolean true or options object). */
+export declare function isLegendFilterPropEnabled(filter: LegendFilterInput | undefined): filter is Exclude<LegendFilterInput, false>;
+export {};

package/dist/legend/resolve-legend-filter.js

@@ -0,0 +1,54 @@
+import { filterEntriesByChannels, resolveLegendChannelCapability, } from "./resolve-legend-capability.js";
+function isEnabledInput(input) {
+    return input !== undefined && input !== false;
+}
+/**
+ * Merge mode/multiple from plot prop + children. Last explicit field wins
+ * (plot first, then children in registry order).
+ */
+function resolveConfigInput(plotProp, children) {
+    let mode;
+    let multiple;
+    const consider = (input) => {
+        if (input === true)
+            return;
+        if (input.mode !== undefined)
+            mode = input.mode;
+        if (input.multiple !== undefined)
+            multiple = input.multiple;
+    };
+    if (isEnabledInput(plotProp))
+        consider(plotProp);
+    for (const child of children)
+        consider(child.input);
+    if (mode === undefined && multiple === undefined)
+        return true;
+    return {
+        ...(mode === undefined ? {} : { mode }),
+        ...(multiple === undefined ? {} : { multiple }),
+    };
+}
+/**
+ * Combine deprecated plot prop + GuideLegend filter children into one capability.
+ * Children define per-channel enablement when present; plot prop alone is `"all"`.
+ */
+export function resolveLegendFilterCapability(input) {
+    return resolveLegendChannelCapability({
+        plotProp: input.plotProp,
+        layers: input.layers,
+        layerKind: "legendFilter",
+        mergeChildrenConfig: resolveConfigInput,
+    });
+}
+/**
+ * Keep filterable targets whose scene legend aesthetics intersect the
+ * enabled channel set. Merged legends expose all aesthetics on
+ * `legend.aesthetics` (primary `scale` alone is not enough).
+ */
+export function filterFilterableLegendEntries(entries, channels) {
+    return filterEntriesByChannels(entries, channels);
+}
+/** True when `filter` is an active opt-in (boolean true or options object). */
+export function isLegendFilterPropEnabled(filter) {
+    return isEnabledInput(filter);
+}

package/dist/legend/resolve-legend-focus.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Resolve legend-focus capability from host-only GuideLegend `focus` layers
+ * and the deprecated plot-level `legendFocus` prop.
+ *
+ * Interactions stay off PortableSpec: `focus` is stripped before guideLegend()
+ * and travels as registry layer kind `legendFocus`.
+ *
+ * Skeleton (off / children→channels / plot-alone→"all") lives in
+ * resolve-legend-capability.ts; this module owns only the focus-specific
+ * merge: any explicit `preview: false` wins across prop and children.
+ */
+import type { LegendFocusInput } from "../interaction/interaction.js";
+import type { InteractiveLegendEntry } from "./focus.js";
+import { type LegendChannelSet } from "./resolve-legend-capability.js";
+/** Aesthetic channel a GuideLegend may enable for focus (non-position). */
+type LegendFocusChannel = "color" | "fill" | "size" | "linewidth" | "alpha" | "shape" | "linetype";
+/** One GuideLegend's host-only focus contribution (null when focus is off). */
+export type LegendFocusLayerValue = {
+    readonly channel: LegendFocusChannel;
+    readonly input: Exclude<LegendFocusInput, false>;
+} | null;
+export type LegendFocusChannelSet = LegendChannelSet;
+export type ResolvedLegendFocusCapability = {
+    /**
+     * Requested opt-in for wiring advisories (truthy even when keyless
+     * degradation later nulls the resolved config).
+     */
+    readonly requested: LegendFocusInput | false;
+    /** Value fed to normalizeInteractionConfig. */
+    readonly configInput: LegendFocusInput | false;
+    /**
+     * `"all"` = deprecated plot prop only (every discrete interactive legend).
+     * Otherwise only legends whose aesthetics intersect this set get targets.
+     */
+    readonly channels: LegendFocusChannelSet;
+};
+type LegendFocusLayerLike = {
+    readonly kind: string;
+    /** Live getter or plain field — only read when kind is legendFocus. */
+    readonly value?: unknown;
+};
+/**
+ * Combine deprecated plot prop + GuideLegend focus children into one capability.
+ * Children define per-channel enablement when present; plot prop alone is `"all"`.
+ */
+export declare function resolveLegendFocusCapability(input: {
+    readonly plotProp: LegendFocusInput | undefined;
+    readonly layers: readonly LegendFocusLayerLike[];
+}): ResolvedLegendFocusCapability;
+/**
+ * Keep interactive targets whose scene legend aesthetics intersect the
+ * enabled channel set. Merged legends expose all aesthetics on
+ * `legend.aesthetics` (primary `scale` alone is not enough).
+ */
+export declare const filterInteractiveLegendEntries: (entries: readonly InteractiveLegendEntry[], channels: LegendFocusChannelSet) => InteractiveLegendEntry[];
+/** True when `focus` is an active opt-in (boolean true or options object). */
+export declare function isLegendFocusPropEnabled(focus: LegendFocusInput | undefined): focus is Exclude<LegendFocusInput, false>;
+export {};

package/dist/legend/resolve-legend-focus.js

@@ -0,0 +1,36 @@
+import { filterEntriesByChannels, resolveLegendChannelCapability, } from "./resolve-legend-capability.js";
+/** Merge preview flags: any explicit `preview: false` disables preview. */
+function resolvePreview(plotProp, children) {
+    if (typeof plotProp === "object" && plotProp.preview === false)
+        return false;
+    for (const child of children) {
+        if (typeof child.input === "object" && child.input.preview === false)
+            return false;
+    }
+    return true;
+}
+function toConfigInput(preview) {
+    return preview ? true : { preview: false };
+}
+/**
+ * Combine deprecated plot prop + GuideLegend focus children into one capability.
+ * Children define per-channel enablement when present; plot prop alone is `"all"`.
+ */
+export function resolveLegendFocusCapability(input) {
+    return resolveLegendChannelCapability({
+        plotProp: input.plotProp,
+        layers: input.layers,
+        layerKind: "legendFocus",
+        mergeChildrenConfig: (plotProp, children) => toConfigInput(resolvePreview(plotProp, children)),
+    });
+}
+/**
+ * Keep interactive targets whose scene legend aesthetics intersect the
+ * enabled channel set. Merged legends expose all aesthetics on
+ * `legend.aesthetics` (primary `scale` alone is not enough).
+ */
+export const filterInteractiveLegendEntries = filterEntriesByChannels;
+/** True when `focus` is an active opt-in (boolean true or options object). */
+export function isLegendFocusPropEnabled(focus) {
+    return focus !== undefined && focus !== false;
+}

package/dist/legend/surface.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Pure legend surface event decisions for GGPlot.
+ *
+ * Hosts own DOM handlers, suppress/touch index lifecycle, focus moves,
+ * commitLegend side effects, and announcements. This module owns only
+ * key routing, touch/click coordination, and commit/preview-dismiss priority.
+ */
+import type { InteractionSource } from "../interaction/interaction.js";
+import { type LegendEntryIdentity, type LegendInteractionSource } from "./focus.js";
+export type LegendKeyInput = {
+    readonly key: string;
+};
+type LegendKeyAction = {
+    readonly type: "move";
+    readonly key: string;
+} | {
+    readonly type: "commit";
+} | {
+    readonly type: "clear";
+} | {
+    readonly type: "none";
+};
+export type LegendKeyResolution = {
+    readonly action: LegendKeyAction;
+    readonly preventDefault: boolean;
+};
+/**
+ * Pure decision for a legend target `keydown` handler.
+ * Priority: roving arrows/Home/End → Enter/Space commit → Escape clear → none.
+ * Callers own preventDefault, focus move, commitLegend, and clearLegendFocus.
+ */
+export declare function resolveLegendKeyAction(input: LegendKeyInput): LegendKeyResolution;
+export type LegendPointerUpInput = {
+    readonly pointerType: string;
+    readonly index: number;
+    /** Host `legendTouchIndex` from pointerdown; -1 if none/cancelled. */
+    readonly touchIndex: number;
+};
+export type LegendPointerUpAction = {
+    readonly type: "touch-commit";
+} | {
+    readonly type: "none";
+};
+/**
+ * Pure decision for legend target `pointerup`.
+ * Touch-commit only when pointerType is touch and touchIndex matches index.
+ * Host on touch-commit: clear touchIndex, set suppressLegendClick, then commit.
+ * Host on none: no suppress flag change (mismatched up after cancel stays quiet).
+ *
+ * `legendTouchIndex` is a single host slot (not pointerId-keyed). Multi-touch
+ * is not modeled; cancel resets the slot before this resolver runs.
+ */
+export declare function resolveLegendPointerUpAction(input: LegendPointerUpInput): LegendPointerUpAction;
+export type LegendClickInput = {
+    /** Host `suppressLegendClick` after a touch commit. */
+    readonly suppressClick: boolean;
+    /**
+     * MouseEvent.detail classification used by the host today.
+     * detail === 0 → source "keyboard" (also true for some programmatic clicks —
+     * this is current source classification, not an a11y guarantee).
+     */
+    readonly detail: number;
+};
+export type LegendClickAction = {
+    readonly type: "suppress";
+} | {
+    readonly type: "commit";
+    readonly source: "keyboard" | "pointer";
+};
+/**
+ * Pure decision for legend target `click`.
+ * Priority: suppressClick → suppress; else commit with detail-classified source.
+ * Host on suppress: clear suppressLegendClick and return (exact-once touch).
+ * Host on commit: legendAction(index, source) + commitLegend when non-null.
+ */
+export declare function resolveLegendClickAction(input: LegendClickInput): LegendClickAction;
+export type LegendClearControlInput = {
+    /** MouseEvent.detail from the clear control click. */
+    readonly detail: number;
+    /**
+     * Host `legendClearPointerType` from pointerdown on the clear control
+     * (null when never set / after cancel).
+     */
+    readonly pointerType: string | null;
+};
+/**
+ * Pure InteractionSource for the legend clear control `click`.
+ * Priority: detail === 0 → keyboard; pointerType === "touch" → touch; else pointer.
+ * Host still clears `legendClearPointerType` after classification.
+ */
+export declare function resolveLegendClearControlSource(input: LegendClearControlInput): InteractionSource;
+export type LegendBlurInput = {
+    readonly relatedTarget: EventTarget | null;
+    /** Host plot root; null when unmounted. */
+    readonly root: ParentNode | null;
+};
+/**
+ * Whether blur should clear transient legend preview.
+ *
+ * Retain preview only when focus moves to another legend target **inside this
+ * plot's root**. Cross-plot moves to another `[data-gg-legend-target]` must
+ * clear, or the previous plot stays muted with a stale preview.
+ */
+export declare function shouldClearLegendPreviewOnBlur(input: LegendBlurInput): boolean;
+export type InteractionLiveRegionInput = {
+    readonly surfaceInteractive: boolean;
+    readonly legendFocusEnabled: boolean;
+    readonly legendFilterEnabled?: boolean;
+};
+/**
+ * Live region is required for surface tools, legend-only focus, **or** legend
+ * filtering so keyboard commits/clears and programmatic filter reconciliation
+ * still announce when inspect/select/zoom are off.
+ */
+export declare function shouldRenderInteractionLiveRegion(input: InteractionLiveRegionInput): boolean;
+export type LegendCommitAction = {
+    readonly type: "toggle-clear";
+    readonly source: InteractionSource;
+} | {
+    readonly type: "ignore";
+} | {
+    readonly type: "commit";
+    readonly source: InteractionSource;
+};
+/**
+ * Pure routing for host `commitLegend` after identity + key lookup.
+ *
+ * Priority (load-bearing):
+ *   1. toggle-clear — pressed identity matches action identity
+ *   2. ignore — keyCount === 0
+ *   3. commit
+ *
+ * Non-ignore actions carry mapped InteractionSource via `legendInteractionSource`
+ * so the host does not re-map `action.source` after routing.
+ *
+ * Host may compute `keysForLegend(action)` before this call (eager Map.get);
+ * keys are unused on toggle-clear but O(1). A pressed entry whose domain keys
+ * reshuffled empty still toggles clear (does not fall into ignore).
+ */
+export declare function resolveLegendCommitAction(input: {
+    readonly pressed: LegendEntryIdentity | null;
+    readonly identity: LegendEntryIdentity;
+    readonly keyCount: number;
+    /** Host: `action.source` (legend entry interaction source). */
+    readonly entrySource: LegendInteractionSource;
+}): LegendCommitAction;
+export type LegendPreviewDismissAction = {
+    readonly type: "none";
+} | {
+    readonly type: "clear-only";
+    readonly source: InteractionSource;
+} | {
+    readonly type: "clear-and-emit";
+    readonly source: InteractionSource;
+};
+/**
+ * Pure routing for host `previewLegend(null)` (dismiss path only).
+ *
+ *   none           — `previewSource === null` (no active preview)
+ *   clear-only     — drop preview, no clear event; carries mapped source
+ *   clear-and-emit — drop preview and emit legend-focus clear; carries mapped source
+ *
+ * `previewSource` is host `legendPreview?.action.source ?? null` — a single
+ * discriminant (no separate hasActivePreview boolean) so
+ * `hasActivePreview: true` with null source is unrepresentable.
+ *
+ * Emit gate uses **committed** emphasis (`interaction?.emphasized(scope) ??
+ * localEmphasisKeys`), not `effectiveEmphasisKeys` (which includes preview).
+ * That differs intentionally from `clearLegendFocus`, which ORs preview /
+ * committed / effective emphasis before emit.
+ */
+export declare function resolveLegendPreviewDismissAction(input: {
+    /** Host: `legendPreview?.action.source ?? null`. */
+    readonly previewSource: LegendInteractionSource | null;
+    readonly committedEmphasisEmpty: boolean;
+}): LegendPreviewDismissAction;
+/**
+ * Whether `clearLegendFocus` should emit a legend-focus clear event.
+ *
+ * Unlike `resolveLegendPreviewDismissAction` (preview dismiss), this gate ORs
+ * active preview, committed legend entry, and **effective** emphasis key count
+ * (preview keys included when present). That matches the host clearing all
+ * focus surfaces, not only a transient preview leave.
+ */
+export declare function shouldEmitLegendFocusClear(input: {
+    readonly hasPreview: boolean;
+    readonly hasCommitted: boolean;
+    readonly emphasisKeyCount: number;
+}): boolean;
+export {};

package/dist/legend/surface.js

@@ -0,0 +1,158 @@
+/**
+ * Pure legend surface event decisions for GGPlot.
+ *
+ * Hosts own DOM handlers, suppress/touch index lifecycle, focus moves,
+ * commitLegend side effects, and announcements. This module owns only
+ * key routing, touch/click coordination, and commit/preview-dismiss priority.
+ */
+import { legendInteractionSource, } from "./focus.js";
+const isRovingKey = (key) => key === "ArrowRight" ||
+    key === "ArrowDown" ||
+    key === "ArrowLeft" ||
+    key === "ArrowUp" ||
+    key === "Home" ||
+    key === "End";
+/**
+ * Pure decision for a legend target `keydown` handler.
+ * Priority: roving arrows/Home/End → Enter/Space commit → Escape clear → none.
+ * Callers own preventDefault, focus move, commitLegend, and clearLegendFocus.
+ */
+export function resolveLegendKeyAction(input) {
+    const { key } = input;
+    if (isRovingKey(key)) {
+        return { preventDefault: true, action: { type: "move", key } };
+    }
+    if (key === "Enter" || key === " ") {
+        return { preventDefault: true, action: { type: "commit" } };
+    }
+    if (key === "Escape") {
+        return { preventDefault: true, action: { type: "clear" } };
+    }
+    return { preventDefault: false, action: { type: "none" } };
+}
+/**
+ * Pure decision for legend target `pointerup`.
+ * Touch-commit only when pointerType is touch and touchIndex matches index.
+ * Host on touch-commit: clear touchIndex, set suppressLegendClick, then commit.
+ * Host on none: no suppress flag change (mismatched up after cancel stays quiet).
+ *
+ * `legendTouchIndex` is a single host slot (not pointerId-keyed). Multi-touch
+ * is not modeled; cancel resets the slot before this resolver runs.
+ */
+export function resolveLegendPointerUpAction(input) {
+    if (input.pointerType !== "touch")
+        return { type: "none" };
+    if (input.touchIndex !== input.index)
+        return { type: "none" };
+    return { type: "touch-commit" };
+}
+/**
+ * Pure decision for legend target `click`.
+ * Priority: suppressClick → suppress; else commit with detail-classified source.
+ * Host on suppress: clear suppressLegendClick and return (exact-once touch).
+ * Host on commit: legendAction(index, source) + commitLegend when non-null.
+ */
+export function resolveLegendClickAction(input) {
+    if (input.suppressClick)
+        return { type: "suppress" };
+    return {
+        type: "commit",
+        source: input.detail === 0 ? "keyboard" : "pointer",
+    };
+}
+/**
+ * Pure InteractionSource for the legend clear control `click`.
+ * Priority: detail === 0 → keyboard; pointerType === "touch" → touch; else pointer.
+ * Host still clears `legendClearPointerType` after classification.
+ */
+export function resolveLegendClearControlSource(input) {
+    if (input.detail === 0)
+        return "keyboard";
+    if (input.pointerType === "touch")
+        return "touch";
+    return "pointer";
+}
+/**
+ * Whether blur should clear transient legend preview.
+ *
+ * Retain preview only when focus moves to another legend target **inside this
+ * plot's root**. Cross-plot moves to another `[data-gg-legend-target]` must
+ * clear, or the previous plot stays muted with a stale preview.
+ */
+export function shouldClearLegendPreviewOnBlur(input) {
+    if (!(input.relatedTarget instanceof Element))
+        return true;
+    if (!input.relatedTarget.matches("[data-gg-legend-target]"))
+        return true;
+    if (input.root === null)
+        return true;
+    return !input.root.contains(input.relatedTarget);
+}
+/**
+ * Live region is required for surface tools, legend-only focus, **or** legend
+ * filtering so keyboard commits/clears and programmatic filter reconciliation
+ * still announce when inspect/select/zoom are off.
+ */
+export function shouldRenderInteractionLiveRegion(input) {
+    return input.surfaceInteractive || input.legendFocusEnabled || input.legendFilterEnabled === true;
+}
+/**
+ * Pure routing for host `commitLegend` after identity + key lookup.
+ *
+ * Priority (load-bearing):
+ *   1. toggle-clear — pressed identity matches action identity
+ *   2. ignore — keyCount === 0
+ *   3. commit
+ *
+ * Non-ignore actions carry mapped InteractionSource via `legendInteractionSource`
+ * so the host does not re-map `action.source` after routing.
+ *
+ * Host may compute `keysForLegend(action)` before this call (eager Map.get);
+ * keys are unused on toggle-clear but O(1). A pressed entry whose domain keys
+ * reshuffled empty still toggles clear (does not fall into ignore).
+ */
+export function resolveLegendCommitAction(input) {
+    const source = legendInteractionSource(input.entrySource);
+    if (input.pressed !== null &&
+        input.pressed.scale === input.identity.scale &&
+        input.pressed.entryIndex === input.identity.entryIndex)
+        return { type: "toggle-clear", source };
+    if (input.keyCount === 0)
+        return { type: "ignore" };
+    return { type: "commit", source };
+}
+/**
+ * Pure routing for host `previewLegend(null)` (dismiss path only).
+ *
+ *   none           — `previewSource === null` (no active preview)
+ *   clear-only     — drop preview, no clear event; carries mapped source
+ *   clear-and-emit — drop preview and emit legend-focus clear; carries mapped source
+ *
+ * `previewSource` is host `legendPreview?.action.source ?? null` — a single
+ * discriminant (no separate hasActivePreview boolean) so
+ * `hasActivePreview: true` with null source is unrepresentable.
+ *
+ * Emit gate uses **committed** emphasis (`interaction?.emphasized(scope) ??
+ * localEmphasisKeys`), not `effectiveEmphasisKeys` (which includes preview).
+ * That differs intentionally from `clearLegendFocus`, which ORs preview /
+ * committed / effective emphasis before emit.
+ */
+export function resolveLegendPreviewDismissAction(input) {
+    if (input.previewSource === null)
+        return { type: "none" };
+    const source = legendInteractionSource(input.previewSource);
+    if (input.committedEmphasisEmpty)
+        return { type: "clear-and-emit", source };
+    return { type: "clear-only", source };
+}
+/**
+ * Whether `clearLegendFocus` should emit a legend-focus clear event.
+ *
+ * Unlike `resolveLegendPreviewDismissAction` (preview dismiss), this gate ORs
+ * active preview, committed legend entry, and **effective** emphasis key count
+ * (preview keys included when present). That matches the host clearing all
+ * focus surfaces, not only a transient preview leave.
+ */
+export function shouldEmitLegendFocusClear(input) {
+    return input.hasPreview || input.hasCommitted || input.emphasisKeyCount > 0;
+}

package/dist/plot-engine-deriveds.svelte.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Plot-engine pure derivations — accessors only, no $state, no effects,
+ * no controller construction.
+ *
+ * Two factories, called synchronously while `createPlotEngine` runs during
+ * component init so every `$derived` lands in the component graph at the
+ * engine's original construction position:
+ *
+ * - `createPlotEngineDeriveds` — early host derivations (assembled spec,
+ *   faceted intent, row-identity datum key, interaction scope, interaction
+ *   config, capability enablement). All inputs exist before the interaction
+ *   assembly; nothing here reads the runtime.
+ * - `createPlotEngineHostDeriveds` — late host derivations that need the
+ *   runtime + assembled controllers (legend entry lists, hover glyph
+ *   extents, crosshair gap obstacles). Registered at the engine's original
+ *   position, after the interaction assembly and chrome state.
+ *
+ * All inputs are lazy getters over live engine references — never snapshots.
+ */
+import type { PortableSpec } from "@ggts-sh/spec";
+import type { LayerRegistry } from "./geoms/registry.svelte.js";
+import { type PlotInteractionScope, type ResolvedInteractionConfig } from "./interaction/interaction.js";
+import { type CapabilityResolution } from "./interaction/capability-resolution.svelte.js";
+import type { InspectionState } from "./inspection/inspection-state.svelte.js";
+import type { LegendFilterState, FilterableLegendEntry } from "./legend/filter-state.svelte.js";
+import type { InteractiveLegendEntry, LegendEntryIdentity } from "./legend/focus.js";
+import type { LegendFocusState } from "./legend/focus-state.svelte.js";
+import type { ResolvedLegendFilterCapability } from "./legend/resolve-legend-filter.js";
+import type { ResolvedLegendFocusCapability } from "./legend/resolve-legend-focus.js";
+import { type EnginePlotProps } from "./plot-props.js";
+import type { PlotRuntime } from "./runtime/runtime.svelte.js";
+import type { DatumKey } from "./runtime/resolve-datum-key.js";
+import { type CrosshairGapBox } from "./scene/geometry.js";
+/** Structural host slice — the registry + live props proxy. */
+export type PlotEngineDerivedsHost = {
+    registry: LayerRegistry;
+    props: EnginePlotProps;
+};
+/** Early host derivations, returned as live accessors (never snapshots). */
+export type PlotEngineDeriveds = {
+    assembled: () => PortableSpec | null;
+    resolvedDatumKey: () => DatumKey;
+    resolvedInteractionScope: () => PlotInteractionScope;
+    interactionConfig: () => ResolvedInteractionConfig;
+    interactive: () => boolean;
+    surfaceInteractive: () => boolean;
+    inspectEnabled: () => boolean;
+    legendFocusEnabled: () => boolean;
+    coordFlipped: () => boolean;
+};
+export declare function createPlotEngineDeriveds(host: PlotEngineDerivedsHost, capabilityResolution: CapabilityResolution): PlotEngineDeriveds;
+/** Lazy inputs for the late host derivations (runtime + controllers exist). */
+export type PlotEngineHostDerivedsInput = {
+    runtime: PlotRuntime;
+    inspection: InspectionState;
+    legendFocusState: LegendFocusState;
+    legendFilterState: LegendFilterState;
+    legendFocusEnabled: () => boolean;
+    legendFocusChannels: () => ResolvedLegendFocusCapability["channels"];
+    legendFilterChannels: () => ResolvedLegendFilterCapability["channels"];
+};
+/** Late host derivations, returned as live accessors (never snapshots). */
+export type PlotEngineHostDeriveds = {
+    interactiveLegendEntries: () => InteractiveLegendEntry[];
+    effectiveLegendPressed: () => LegendEntryIdentity | null;
+    legendClearActive: () => boolean;
+    filterableLegendEntries: () => FilterableLegendEntry[];
+    hoverGlyphExtents: () => {
+        readonly width: number;
+        readonly height: number;
+        readonly textAnchor: "start" | "middle" | "end";
+    } | null;
+    crosshairGapObstacles: () => readonly CrosshairGapBox[];
+};
+export declare function createPlotEngineHostDeriveds(input: PlotEngineHostDerivedsInput): PlotEngineHostDeriveds;