@graphysdk/viz-engine 0.0.1-alpha.0 → 0.0.1

package/dist/index.d.ts

@@ -17,11 +17,8 @@ export declare type AestheticKey = keyof AesMapping;
  * Aesthetic value can be:
  * - string (shorthand for { variable: string })
  * - { variable: string } (explicit variable mapping)
- * - { value: DataValue } (constant value applied to every observation)
  */
-declare type AestheticValue = string | VariableMapping | ValueMapping;
-
-declare function aggregate(options: AggregateOptions): AggregateTransformInput;
+declare type AestheticValue = string | VariableMapping;
 
 /***************************************************************
  * Aggregate Transform
@@ -57,56 +54,6 @@ declare type AggregationInput = Record<VariableName, {
     aggregation: AggregationFunction;
 }>;
 
-export declare interface AngleExtent {
-    startAngle: NumericDataValue;
-    endAngle: NumericDataValue;
-}
-
-declare interface AnnotationDataPoint {
-    rowIndex?: number;
-    columnKey?: string;
-    rowValue?: DataValue;
-}
-
-declare interface Appearance {
-    paletteId?: string;
-    seriesStyles?: Record<string, SeriesStyle>;
-    useSingleColorForBars?: boolean;
-    background?: string;
-    backgroundModifier?: 'none' | 'tint';
-    border?: Partial<{
-        style: 'none' | 'custom' | 'tinted' | 'gradient' | 'preset' | 'grey';
-        color: string;
-        width: number;
-    }>;
-    hasRoundedCorners?: boolean;
-    textStyle?: Partial<{
-        heading: GraphTextStyle;
-        body: GraphTextStyle;
-    }>;
-    textScale?: number;
-    highlightStyle?: 'grey' | 'fade-color';
-    isLogoHidden?: boolean;
-    numberFormat?: Partial<{
-        decimalPlaces: 'auto' | number;
-        abbreviation: 'none' | 'auto' | 'k' | 'm' | 'b';
-    }>;
-    showTooltips?: boolean;
-    animateTransitions?: boolean;
-}
-
-/**
- * Appearance configuration (after defaults applied)
- */
-declare interface AppearanceConfig {
-    /**
-     * Background color for the chart canvas.
-     * null means inherit from the renderer/theme default.
-     * @default null
-     */
-    background: string | null;
-}
-
 declare function area(options?: GeomOptions<'area'>): LayerInputOf<'area'>;
 
 /**
@@ -119,19 +66,6 @@ export declare interface AreaGeomParams {
     missingValues: MissingValuesType;
 }
 
-declare interface AverageLine {
-    columnKey: string;
-}
-
-/** Configuration for the axes (if the graph supports them). */
-declare interface Axes {
-    x?: AxisOptions;
-    y?: AxisOptions;
-    y2?: Pick<AxisOptions, 'label'>;
-    hasDualYAxis?: boolean;
-    showGridLines?: boolean;
-}
-
 /**
  * Axes configuration (after defaults applied)
  * Groups all axis-related settings per axis.
@@ -178,38 +112,19 @@ declare interface AxisMapping {
     };
 }
 
-declare interface AxisOptions {
-    label?: string;
-    isHidden?: boolean;
-    isReversed?: boolean;
-    scaleType?: 'linear' | 'logarithmic';
-    min?: number;
-    max?: number;
-    tickDisplayMode?: 'auto' | 'edges';
-}
-
 declare type AxisPosition = 'left' | 'right' | 'top' | 'bottom';
 
 /**
- * A single axis tick with its raw value and normalized position. Ticks in one axis share the same
- * `valueFormat` — it lives on `CompiledAxisGuide`, not per-tick.
+ * A single axis tick with its raw value and normalized position.
+ * The renderer uses `position` for placement and `value` for label formatting.
  */
 export declare interface AxisTick {
-    /** Raw value in data space (number, Date, or string) */
+    /** Raw value in data space (number, Date, or string) — used for label formatting */
     value: DataValue;
     /** Normalized position in [0,1] space — used for placement */
     position: number;
 }
 
-/**
- * A tick-set candidate for an axis. The runtime picks the densest one whose labels fit. Datetime candidates
- * may carry a `valueFormat` matched to their interval's granularity, overriding the axis-level format.
- */
-export declare interface AxisTickCandidate {
-    ticks: AxisTick[];
-    valueFormat?: ValueFormat;
-}
-
 /**
  * Configuration for a single axis's ticks
  */
@@ -225,10 +140,6 @@ declare function bar(options?: GeomOptions<'bar'>): LayerInputOf<'bar'>;
  */
 declare type BarGeomParams = Record<string, never>;
 
-declare interface BarOptions {
-    sortBars?: boolean;
-}
-
 /**
  * Base params shared by all coordinate systems
  */
@@ -249,8 +160,6 @@ declare interface BaseGeomOptions<T extends GeomParams> {
     position?: PositionType;
     yScaleType?: YScaleType;
     params?: Partial<T>;
-    transforms?: TransformInput[];
-    interactive?: boolean;
 }
 
 export declare type BoxSize = {
@@ -258,21 +167,6 @@ export declare type BoxSize = {
     height: number;
 };
 
-/**
- * Pure projection of `(compiled, hover)` into the tooltip's `{ header, rows }`.
- *
- * Row order is layer-declaration order across layers, color-scale domain order within a layer
- * (= the legend's display order). The primary hit is emphasized in place — never reordered to
- * the top — so the visual position stays anchored to the legend.
- */
-export declare const buildTooltipContent: ({ compiled, hover, formattingLocale, }: BuildTooltipContentInput) => TooltipContent | null;
-
-declare interface BuildTooltipContentInput {
-    compiled: CompiledSpec;
-    hover: HoverState;
-    formattingLocale?: Locale;
-}
-
 /**
  * Caching decorator for any TextMeasurer implementation.
  *
@@ -305,28 +199,18 @@ declare interface CartesianCoordSpec {
 }
 
 /**
- * Cartesian coordinate system - standard x/y plot. Also used for flipped coordinates (flip is
- * an axis-assignment variant, not a different geometric paradigm).
+ * Cartesian coordinate system - standard x/y plot.
+ * Also used for flipped coordinates (flip is an axis-assignment variant,
+ * not a different geometric paradigm — the axisMapping encodes the flip).
  */
 export declare interface CartesianCoordSystem {
     type: 'cartesian';
-    /**
-     * The data-space axis that is the main (independent) one. `'x'` for standard cartesian (bars
-     * rise, X ticks on the horizontal axis); `'y'` for `coord.flip()` (bars extend, Y ticks on the
-     * horizontal axis). Consumers that need to branch on flip read this; the runtime `coord/axes`
-     * helpers turn it into main/cross accessors so the branch lives in one place.
-     */
-    mainAxis: MainAxis;
     /** Axis orientation metadata for the guide compiler */
     axisMapping: AxisMapping;
 }
 
 declare type CategoricalDataValue = string | null;
 
-declare interface CategoricalValueFormat {
-    type: 'text';
-}
-
 /**
  * Chart display and interaction mode.
  * - 'readonly': Normal chart display with full interactivity but no editing (default)
@@ -352,197 +236,17 @@ declare interface ColorScaleMethods {
     palette: (options?: PaletteScaleOptions) => PaletteScaleInput;
 }
 
-declare type ColumnMetadata = Record<string, {
-    type: DataType;
-    valueFormat: ValueFormat;
-    label?: string;
-}>;
-
-declare interface ComboOptions {
-    comboType?: 'grouped-bars' | 'stacked-bars' | 'lines';
-}
-
-export declare interface Command<TParams extends Record<string, unknown> = Record<string, unknown>> {
-    /**
-     * Command type discriminator for type guards
-     */
-    readonly type: string;
-    /**
-     * Metadata for tracking
-     */
-    readonly metadata: CommandMetadata;
-    /**
-     * Serializable parameters for this command.
-     */
-    readonly params: TParams;
-    /**
-     * Execute the command against a spec.
-     * Returns the new spec and a revert command that can undo this change.
-     */
-    apply: (spec: Spec) => CommandApplyResult | null;
-}
-
-/**
- * Result of executing a command.
- * Contains the new spec and a revert command that can undo the change.
- */
-export declare interface CommandApplyResult {
-    /** The spec after applying the command */
-    readonly spec: Spec;
-    /** A standalone command that reverses this execution */
-    readonly revert: Command;
-}
-
-/**
- * Unique identifier for commands.
- */
-declare type CommandId = string;
-
-/**
- * Metadata attached to every command for tracking.
- */
-export declare interface CommandMetadata {
-    /** Unique identifier for this command */
-    readonly id: CommandId;
-    /** When the command was executed */
-    readonly timestamp: number;
-    /** Human-readable description for UI display */
-    readonly description: string;
-    /** Author of the command */
-    readonly author: string;
-}
-
-/**
- * Event types emitted by CommandStackManager.
- */
-export declare type CommandStackEvent = {
-    type: 'apply';
-    command: Command;
-    spec: Spec;
-} | {
-    type: 'undo';
-    command: Command;
-    spec: Spec;
-} | {
-    type: 'redo';
-    command: Command;
-    spec: Spec;
-} | {
-    type: 'clear';
-};
-
-/**
- * Listener for command stack events.
- */
-export declare type CommandStackListener = (event: CommandStackEvent) => void;
-
-/**
- * Manages command execution with undo/redo support using revert commands.
- *
- * Commands are stateless — executing a command returns the new spec and a
- * standalone revert command. The manager stores these revert commands on
- * the undo stack. Undo executes the revert (producing a new forward command
- * for redo), and redo executes that forward command (producing a new revert
- * for undo again).
- *
- * @example
- * ```typescript
- * const manager = new CommandStackManager();
- *
- * // Execute a command
- * let spec = manager.apply(command, spec);
- *
- * // Undo the last command
- * const undoResult = manager.undo(spec);
- * if (undoResult) {
- *   spec = undoResult.spec;
- * }
- *
- * // Redo the undone command
- * const redoResult = manager.redo(spec);
- * if (redoResult) {
- *   spec = redoResult.spec;
- * }
- * ```
- */
-export declare class CommandStackManager {
-    private undoStack;
-    private redoStack;
-    private listeners;
-    private readonly maxHistorySize;
-    private isEmitting;
-    private cachedSnapshot;
-    constructor(options?: CommandStackOptions);
-    /**
-     * Execute a command and add it to the undo stack.
-     * Clears the redo stack (standard undo/redo behavior).
-     */
-    apply(command: Command, spec: Spec): Spec;
-    /**
-     * Undo the most recent command.
-     * Executes the revert command and moves the entry to the redo stack.
-     * Returns the result with new spec and the original command, or null if nothing to undo.
-     */
-    undo(spec: Spec): UndoRedoResult | null;
-    /**
-     * Redo the most recently undone command.
-     * Executes the redo action and moves the entry back to the undo stack.
-     * Returns the result with new spec and the original command, or null if nothing to redo.
-     */
-    redo(spec: Spec): UndoRedoResult | null;
-    /**
-     * Clear all history (both undo and redo stacks).
-     */
-    clear(): void;
-    /**
-     * Get an immutable snapshot of the command stack state.
-     * Returns a cached object with referential stability.
-     */
-    getSnapshot(): CommandStackSnapshot;
-    /**
-     * Subscribe to command stack events.
-     * @returns Unsubscribe function
-     */
-    subscribe(listener: CommandStackListener): () => void;
-    private withReentrancyGuard;
-    private emit;
-}
-
-/**
- * Options for CommandStackManager.
- */
-declare interface CommandStackOptions {
-    /** Maximum number of commands to keep in history (default: 100) */
-    maxHistorySize?: number;
-}
-
-/**
- * Immutable snapshot of command stack state.
- * Designed for use with React's `useSyncExternalStore(manager.subscribe, manager.getSnapshot)`.
- */
-export declare interface CommandStackSnapshot {
-    readonly canUndo: boolean;
-    readonly canRedo: boolean;
-    readonly undoDescription: string | null;
-    readonly redoDescription: string | null;
-}
-
 /** Comparison operators for declarative filtering. */
 declare type ComparisonOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte';
 
 /**
  * Convenience entry point to create a fully wired {@link Compiler} and compile a spec.
- *
- * Accepts either a low-level {@link SpecInput} (constructed via `createSpec`/`pipe`)
- * or a high-level {@link GraphConfig}. When given a `GraphConfig`, it parses the raw
- * data and converts it to a `SpecInput` before running the pipeline.
  */
-export declare const compile: (input: CompilerInput) => CompiledSpec;
+export declare const compile: (spec: SpecInput) => CompiledSpec;
 
 /**
  * Axis guide produced from a position scale (x, y, ySecondary).
- * Tick candidates carry normalized positions so the renderer needs no scale logic (selection
- * happens at layout time).
+ * Ticks carry their normalized positions so the renderer needs no scale logic.
  */
 export declare interface CompiledAxisGuide {
     /** Which scale this axis represents */
@@ -555,10 +259,8 @@ export declare interface CompiledAxisGuide {
     label: string | null;
     /** Whether the axis (line + ticks + labels) is visible */
     isVisible: boolean;
-    /** Candidate tick sets, sorted by ascending count. Runtime picks the densest one that fits. */
-    tickCandidates: AxisTickCandidate[];
-    /** Resolved format descriptor shared by all ticks on this axis */
-    valueFormat: ValueFormat;
+    /** Ticks with raw values and normalized positions */
+    ticks: AxisTick[];
     /** Tick mode from config */
     tickMode: AxisLabelMode;
     /** Whether tick marks are visible */
@@ -567,8 +269,6 @@ export declare interface CompiledAxisGuide {
     gridVisible: boolean;
     /** Scale type — the renderer uses this to select a formatting strategy */
     scaleType: ScaleType;
-    /** Band width in [0, 1] space for discrete position scales. Undefined otherwise. */
-    bandwidth?: number;
 }
 
 declare interface CompiledGeom {
@@ -588,7 +288,6 @@ declare interface CompiledGroup {
 export declare interface CompiledGuides {
     axes: CompiledAxisGuide[];
     legends: CompiledLegendGuide[];
-    panel: CompiledPanel;
 }
 
 /**
@@ -604,8 +303,7 @@ export declare interface CompiledIdentityScale extends CompiledScaleBase {
  * Render-ready layer with resolved mappings and transformed data.
  */
 export declare interface CompiledLayer {
-    /** Stable identity carried over from `LayerSpec.id`. Preserved across recompiles. */
-    id: string;
+    index: number;
     data: Dataset;
     geom: GeomName;
     /** Final mapping after merging root + layer + stat + geom overrides */
@@ -613,26 +311,8 @@ export declare interface CompiledLayer {
     position: PositionType;
     yScaleType: YScaleType;
     params: LayerSpec['params'];
-    /**
-     * When `false`, the runtime hover engine excludes this layer from primary hit-detection — a
-     * colocated interactive layer (line/area/bar) wins instead. The layer can still be surfaced as
-     * a related companion when another layer is primary.
-     */
-    interactive: boolean;
 }
 
-/**
- * `CompiledLayer` narrowed to a specific `geom`. Lets call sites that already know the geom
- * (geom renderers dispatched off `layer.geom`) take a typed `params` directly, eliminating the
- * `as ...GeomParams` cast that was needed when `params` was the full param union.
- */
-export declare type CompiledLayerFor<G extends GeomName> = Omit<CompiledLayer, 'geom' | 'params'> & {
-    geom: G;
-    params: Extract<LayerSpec, {
-        geom: G;
-    }>['params'];
-};
-
 export declare interface CompiledLegendGuide {
     /** Which aesthetics this legend represents (may be merged) */
     aesthetics: AestheticKey[];
@@ -644,14 +324,6 @@ export declare interface CompiledLegendGuide {
     display: ResolvedLegendDisplay;
     /** Legend entries in domain order */
     items: LegendItem[];
-    /** Resolved format descriptor shared by all items in this legend */
-    valueFormat: ValueFormat;
-}
-
-export declare interface CompiledPanel {
-    border: {
-        isVisible: boolean;
-    };
 }
 
 declare interface CompiledPositionAdjuster {
@@ -680,7 +352,7 @@ declare interface CompiledScaleBase<Input = DataValue> {
     aesthetic: AestheticKey;
     domain: Input[];
     spec: ScaleSpec;
-    generateTicks: (options?: GenerateTicksOptions) => Input[];
+    generateTicks: () => Input[];
 }
 
 export declare type CompiledScales = Partial<Record<ScaledAestheticKey, CompiledScale>>;
@@ -689,7 +361,6 @@ export declare type CompiledScales = Partial<Record<ScaledAestheticKey, Compiled
  * Fully compiled spec, ready for the renderer.
  */
 export declare interface CompiledSpec {
-    spec: Spec;
     coordSystem: CoordSystem;
     layers: CompiledLayer[];
     scales: CompiledScales;
@@ -722,7 +393,7 @@ declare type CompiledVisualScaleOptions<Input = DataValue> = Omit<CompiledVisual
  * the entire plot.
  */
 export declare class Compiler {
-    private readonly specCompiler;
+    private readonly specValidator;
     private readonly transformCompiler;
     private readonly layerCompiler;
     private readonly scaleCompiler;
@@ -730,22 +401,16 @@ export declare class Compiler {
     private readonly positionMapperCompiler;
     private readonly visualMapperCompiler;
     private readonly guideCompiler;
-    constructor(specCompiler: SpecResolver, transformCompiler: TransformCompiler, layerCompiler: LayerCompiler, scaleCompiler: ScaleCompiler, coordCompiler: CoordCompiler, positionMapperCompiler: PositionMapperCompiler, visualMapperCompiler: VisualMapperCompiler, guideCompiler: GuideCompiler);
-    compile(compilerInput: CompilerInput): CompiledSpec;
+    constructor(specValidator: SpecValidator, transformCompiler: TransformCompiler, layerCompiler: LayerCompiler, scaleCompiler: ScaleCompiler, coordCompiler: CoordCompiler, positionMapperCompiler: PositionMapperCompiler, visualMapperCompiler: VisualMapperCompiler, guideCompiler: GuideCompiler);
+    compile(specInput: SpecInput): CompiledSpec;
 }
 
-/**
- * Any value accepted by {@link Compiler.compile}: a low-level {@link SpecInput}, a high-level {@link GraphConfig}
- * or an already-resolved {@link Spec}.
- */
-export declare type CompilerInput = SpecInput | GraphConfig | Spec;
-
 /**
  * Create a custom  configuration
  */
 export declare function config(options: ConfigInput): ConfigItem;
 
-export declare type ConfigInput = DeepPartial<ConfigSpec> & {
+declare type ConfigInput = DeepPartial<ConfigSpec> & {
     legend?: LegendConfigInput;
     content?: ContentInput;
 };
@@ -764,54 +429,17 @@ declare interface ConfigItem {
  */
 export declare interface ConfigSpec {
     mode: ChartMode;
-    parsingLocale: Locale;
+    parsingLocale: string;
     legend: LegendConfig;
     axes: AxesConfig;
     panel: PanelConfig;
     headline: HeadlineConfig;
     numberFormat: NumberFormatConfig;
     content: ContentConfig;
-    appearance: AppearanceConfig;
-}
-
-declare function constant(options: ConstantOptions): ConstantTransformInput;
-
-/***************************************************************
- * Constant Transform
- ***************************************************************/
-declare interface ConstantOptions {
-    /** The name of the new variable. */
-    variableName: VariableName;
-    /** The type of the new variable. */
-    type: DataType;
-    /** The constant value to assign to every observation. */
-    value: DataValue;
-}
-
-declare interface ConstantTransformInput {
-    type: 'transform';
-    transformType: 'constant';
-    options: ConstantOptions;
-}
-
-/** Text content in the graph. */
-declare interface Content {
-    title?: string | unknown;
-    isTitleHidden?: boolean;
-    subtitle?: string | unknown;
-    isSubtitleHidden?: boolean;
-    caption?: string | unknown;
-    isCaptionHidden?: boolean;
-    source?: Partial<{
-        label: string;
-        url: string;
-    }>;
-    isSourceHidden?: boolean;
 }
 
 /** Resolved content configuration (all fields populated). */
 export declare interface ContentConfig {
-    isVisible: boolean;
     title: TextContent | null;
     subtitle: TextContent | null;
     caption: TextContent | null;
@@ -1016,7 +644,7 @@ export declare const createSizeValueReader: (data: Dataset, mapping: AesMapping)
  *     scale.x(),
  *   )
  */
-export declare function createSpec(data: Data, ...items: Array<AesMapping | SpecItem>): SpecInput;
+export declare function createSpec(data: Dataset, ...items: Array<AesMapping | SpecItem>): SpecInput;
 
 export declare const createStrokeWidthValueReader: (data: Dataset, mapping: AesMapping) => (observation: Observation) => DataValue;
 
@@ -1024,47 +652,6 @@ export declare const createXValueReader: (data: Dataset, mapping: AesMapping) =>
 
 export declare const createYValueReader: (data: Dataset, mapping: AesMapping) => (observation: Observation) => DataValue;
 
-/** Three letter ISO string representing the currency */
-declare type CurrencyIso = 'aed' | 'aud' | 'bdt' | 'bhd' | 'brl' | 'cad' | 'chf' | 'clp' | 'cny' | 'cop' | 'czk' | 'dkk' | 'egp' | 'eur' | 'gbp' | 'hkd' | 'huf' | 'idr' | 'ils' | 'inr' | 'jpy' | 'krw' | 'kwd' | 'mxn' | 'myr' | 'ngn' | 'nok' | 'nzd' | 'php' | 'pkr' | 'pln' | 'qar' | 'ron' | 'rub' | 'sar' | 'sek' | 'sgd' | 'thb' | 'try' | 'twd' | 'usd' | 'vnd' | 'zar';
-
-declare interface CurrencyValueFormat {
-    type: 'currency';
-    iso: CurrencyIso;
-}
-
-/**
- * Data to visualize. Structured as a table.
- *
- * The public-API contract. Row values must be {@link DataValue} (string, number,
- * Date, or null). Internal entry points (e.g. the dataset parser) accept a
- * looser row type — see {@link RawData} — because they must defensively handle
- * malformed input.
- */
-export declare interface Data {
-    /**
-     * Column definitions. Every column is an object with a stable `key` that matches the keys used in each row and an optional `label` to show in the UI.
-     */
-    columns: Array<{
-        /** Unique, stable identifier. */
-        key: string;
-        /** Friendly label for the column. */
-        label?: string;
-        /* Excluded from this release type: _metadata */
-    }>;
-    /**
-     * Data rows. Each row object must contain keys that match `columns[i].key`.
-     */
-    rows: Array<Record<string, DataValue>>;
-    /* Excluded from this release type: _metadata */
-}
-
-declare interface DataLabels {
-    showDataLabels?: boolean;
-    dataLabelFormat?: 'absolute' | 'percentage';
-    showStackTotals?: boolean;
-    showCategoryLabels?: boolean;
-}
-
 /**
  * An immutable, columnar dataset. Uses Arquero internally for filtering, grouping and aggregation.
  *
@@ -1111,12 +698,6 @@ export declare class Dataset {
      * Returns true if the dataset has the given variable.
      */
     hasVariable(variable: VariableName): boolean;
-    /**
-     * Returns a JSON-serialisable {@link Data} representation of this dataset. Inverse of
-     * {@link parseDataset}: feeding the result back through the parser reconstructs an
-     * equivalent dataset.
-     */
-    toData(): Data;
     /**
      * Adds a new variable to the dataset.
      */
@@ -1234,19 +815,14 @@ export declare class Dataset {
      * @throws If any variable in `reshape` is not numeric.
      *
      * @example
-     * const reshaped = data.reshapeFromWideToLong({
-     *   keep: ['country'],
-     *   reshape: ['2020', '2021'],
-     *   keyName: 'year',
-     *   valueName: 'gdp',
-     * });
+     * const reshaped = data.reshapeFromWideToLong(
+     *   ['country'],       // keep
+     *   ['2020', '2021'],  // reshape
+     *   'year',            // keyName
+     *   'gdp',             // valueName
+     * );
      */
-    reshapeFromWideToLong({ keep, reshape, keyName, valueName, }?: {
-        keep?: VariableName[];
-        reshape?: VariableName[];
-        keyName?: VariableName;
-        valueName?: VariableName;
-    }): Dataset;
+    reshapeFromWideToLong(keep?: VariableName[], reshape?: VariableName[], keyName?: VariableName, valueName?: VariableName): Dataset;
     /**
      * Prints the dataset to the console.
      */
@@ -1273,17 +849,6 @@ export declare class Dataset {
     private getDistinctValues;
 }
 
-/**
- * Metadata about the dataset (before we reshape it from wide to long format).
- */
-declare interface DatasetMetadata {
-    /**
-     * Column metadata, keyed by column key. For each column,
-     * we store the inferred value format and a function to get the default label.
-     */
-    columns: ColumnMetadata;
-}
-
 /** The type of a variable's values. Internally, numeric values are stored as numbers, dates as Date objects and categorical values as strings. */
 export declare type DataType = 'numeric' | 'categorical' | 'temporal';
 
@@ -1329,13 +894,6 @@ declare type DatetimeScaleOptions = {
 
 declare type DatetimeScaleSpec = Required<DatetimeScaleInput>;
 
-declare interface DatetimeTickInterval {
-    unit: DatetimeTickIntervalUnit;
-    step: number;
-}
-
-declare type DatetimeTickIntervalUnit = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
-
 /**
  * Recursively makes every property of `T` optional.
  * Unlike the built-in `Partial`, this applies to nested objects as well.
@@ -1362,8 +920,6 @@ export declare const DEFAULT_FONT_STYLE = "normal";
  */
 export declare const DEFAULT_FONT_WEIGHT = 500;
 
-export declare const DEFAULT_LOCALE: Locale;
-
 export declare const DEFAULT_PALETTE_NAME = "default";
 
 declare interface DiscreteScaleInput {
@@ -1403,14 +959,12 @@ declare type DiscreteScaleSpec = Required<DiscreteScaleInput>;
 
 declare type DiscreteSort = 'ascending' | 'descending' | 'none';
 
-/** Measured heights of content regions (header: title+subtitle, footer: caption). */
+/** Measured heights of content regions (title+subtitle, caption). */
 export declare interface ExternalMeasurements {
-    headerSize: BoxSize;
-    footerSize: BoxSize;
+    titleSize: BoxSize;
+    captionSize: BoxSize;
 }
 
-declare function filter(options: FilterOptions): FilterTransformInput;
-
 /***************************************************************
  * Filter Transform
  ***************************************************************/
@@ -1450,45 +1004,6 @@ export declare interface FontSpec {
     style?: 'normal' | 'italic' | 'oblique';
 }
 
-/**
- * Formats all legend guides by attaching a `formattedLabel` to each item.
- */
-export declare const formatLegends: (compiled: CompiledSpec, { formattingLocale }?: {
-    formattingLocale?: Locale;
-}) => FormattedLegend[];
-
-export declare interface FormattedAxis extends Omit<CompiledAxisGuide, 'tickCandidates'> {
-    ticks: Array<AxisTick & {
-        formattedLabel: string;
-    }>;
-    /** Rotation in degrees applied uniformly to all tick labels. 0 = no rotation. */
-    labelRotation: number;
-    /** Max label width in px before ellipsis truncation. null = no cap. */
-    labelMaxWidthPx: number | null;
-}
-
-export declare interface FormattedLegend extends Omit<CompiledLegendGuide, 'items'> {
-    items: Array<LegendItem & {
-        formattedLabel: string;
-    }>;
-}
-
-/**
- * Options for `generateTicks`:
- * - `{ count }` — approximate tick count (continuous, datetime).
- * - `{ interval }` — fixed time interval (datetime only).
- * - `{ atInputs: true }` — ticks at the deduped input values (datetime only).
- *
- * Discrete scales ignore options. Unsupported variants on a given scale fall back to defaults.
- */
-declare type GenerateTicksOptions = {
-    count: number;
-} | {
-    interval: DatetimeTickInterval;
-} | {
-    atInputs: true;
-};
-
 /**
  * Base class for geoms that turn observations into visual marks (points, bars, lines etc).
  */
@@ -1557,24 +1072,22 @@ declare class GeomRegistry extends Registry<GeomName, Geom> {
 /** Reads the resolved alpha (opacity) value from an observation. */
 export declare function getAlpha(observation: Observation): NumericDataValue;
 
-export declare function getAngleExtent(observation: Observation): AngleExtent;
-
 /** Reads the resolved color string from an observation. */
-export declare function getColor(observation: Observation): string | undefined;
+export declare function getColor(observation: Observation): CategoricalDataValue;
 
-/** Reads the coordinate lying on the cross axis of the coord system. */
-export declare function getCrossAxisCoordinate(mainAxis: MainAxis, point: XYPoint): number;
+export declare function getEndAngle(observation: Observation): NumericDataValue;
 
 export declare const getGroup: (observation: Observation) => CategoricalDataValue;
 
-/** Reads the coordinate lying on the main (independent) axis of the coord system. */
-export declare function getMainAxisCoordinate(mainAxis: MainAxis, point: XYPoint): number;
+export declare function getInnerRadius(observation: Observation): NumericDataValue;
 
-export declare function getRadiusExtent(observation: Observation): RadiusExtent;
+export declare function getOuterRadius(observation: Observation): NumericDataValue;
 
 /** Reads the resolved size value from an observation. */
 export declare function getSize(observation: Observation): NumericDataValue;
 
+export declare function getStartAngle(observation: Observation): NumericDataValue;
+
 /** Reads the resolved stroke width value from an observation. */
 export declare function getStrokeWidth(observation: Observation): NumericDataValue;
 
@@ -1605,65 +1118,9 @@ export declare function getYMax(observation: Observation): NumericDataValue;
 /** Reads the normalized yMin (lower extent) from an observation. */
 export declare function getYMin(observation: Observation): NumericDataValue;
 
-/** Goal line with a target value. */
-declare interface GoalLine {
-    target: number;
-    marker?: DataValue;
-    label?: string;
-}
-
-declare type GraphAnnotation = GraphStickerAnnotation | GraphTooltipAnnotation | GraphHighlightAnnotation | GraphTextAnnotation | GraphArrowAnnotation | GraphDifferenceArrowAnnotation | GraphShapeAnnotation;
-
-declare interface GraphArrowAnnotation {
-    id: string;
-    type: 'arrow';
-    startX: number;
-    startY: number;
-    endX: number;
-    endY: number;
-    color?: string;
-    thickness: 'thin' | 'medium' | 'thick';
-    startArrowheadStyle: 'none' | 'line-arrow';
-    lineStyle: 'solid' | 'dashed';
-    endArrowheadStyle: 'none' | 'line-arrow';
-    hasStickerStyle: boolean;
-}
-
-export declare interface GraphConfig {
-    data: Data;
-    type?: GraphType;
-    options?: Options;
-    axes?: Axes;
-    legend?: Legend;
-    appearance?: Appearance;
-    themeOverrides?: unknown;
-    content?: Content;
-    headlineNumbers?: HeadlineNumbers;
-    dataLabels?: DataLabels;
-    annotations?: GraphAnnotation[];
-    referenceLines?: ReferenceLines;
-}
-
-declare interface GraphDifferenceArrowAnnotation {
-    id: string;
-    type: 'difference-arrow';
-    show: 'absolute-difference' | 'relative-difference' | 'proportion';
-    start: AnnotationDataPoint;
-    end: AnnotationDataPoint;
-    color?: string;
-    size: 'medium' | 'small' | 'large';
-    labelPosition?: number;
-}
-
-declare type GraphHighlightAnnotation = {
-    id: string;
-    type: 'highlight';
-    highlight: 'data-point' | 'series' | 'x-value';
-} & AnnotationDataPoint;
-
 /** Output of the layout computation. */
 export declare interface GraphLayout {
-    /** The full graphical area (axes + panel + axis labels), excluding header and footer. */
+    /** The full graphical area (axes + panel + axis labels), excluding title and caption. */
     plot: Rect;
     /** The panel area where geom layers render i.e. the data rectangle inside the axes. */
     panel: Rect;
@@ -1671,59 +1128,14 @@ export declare interface GraphLayout {
     axes: Partial<Record<LayoutEdge, Rect>>;
     /** Rects for axis title labels, keyed by edge. */
     axisLabels: Partial<Record<LayoutEdge, Rect>>;
-    /** Rect for the header region (title + subtitle, above the panel). */
-    header: Rect;
-    /** Rect for the footer region (caption, below the panel). */
-    footer: Rect;
+    /** Rect for the title + subtitle region (above the panel). */
+    title: Rect;
+    /** Rect for the caption region (below the panel). */
+    caption: Rect;
     /** Rects for the legend regions, keyed by edge. */
     legends: Partial<Record<LayoutEdge, Rect>>;
 }
 
-declare interface GraphShapeAnnotation {
-    id: string;
-    type: 'shape';
-    shape: 'rectangle';
-    layer: 'belowPlot' | 'abovePlot';
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    fillColor: string;
-    fillOpacity: number;
-    strokeWidth: number;
-}
-
-declare type GraphStickerAnnotation = {
-    id: string;
-    type: 'sticker';
-    sticker: 'rocket' | 'clapping-hands' | 'thumbs-up' | 'thumbs-down' | 'grinning-face';
-} & AnnotationDataPoint;
-
-declare interface GraphTextAnnotation {
-    id: string;
-    type: 'text';
-    content: unknown;
-    x: number;
-    y: number;
-    width: number;
-    backgroundColor?: string;
-    backgroundColorStyle?: 'fade' | 'opaque';
-}
-
-declare interface GraphTextStyle {
-    fontId?: string;
-    color?: string;
-}
-
-declare type GraphTooltipAnnotation = {
-    id: string;
-    type: 'tooltip';
-    caption: unknown;
-} & AnnotationDataPoint;
-
-/** Type of graph to use for the data. */
-export declare type GraphType = 'line' | 'areaStacked' | 'bar' | 'barStacked' | 'barStackedFill' | 'column' | 'columnStacked' | 'columnStackedFill' | 'combo' | 'pie' | 'donut' | 'funnel' | 'heatmap' | 'scatter' | 'bubble' | 'waterfall' | 'mekko' | 'table';
-
 export declare const GROUP_VARIABLES: {
     readonly group: string;
 };
@@ -1747,7 +1159,7 @@ declare class GroupBy {
     /**
      * Computes the group key based on the first value of the grouped variable. If multiple variables are grouped, returns a composite key.
      */
-    private getStableKey;
+    private getGroupKey;
 }
 
 /**
@@ -1788,7 +1200,6 @@ declare interface GuideCompilerInput {
     config: ConfigSpec;
     layers: CompiledLayer[];
     coordSystem: CoordSystem;
-    datasetMetadata: DatasetMetadata;
 }
 
 declare type GuideGeometry = 'linear' | 'circular' | 'radial';
@@ -1829,12 +1240,6 @@ declare interface HeadlineConfig {
     position: HeadlinePosition;
 }
 
-declare interface HeadlineNumbers {
-    show?: 'current' | 'average' | 'total' | 'conversion' | 'none';
-    compareWith?: 'previous' | 'first' | 'none';
-    size?: 'auto' | 'small' | 'medium' | 'large';
-}
-
 /**
  * Placement of headline numbers
  * - 'above': Display above the chart (default, in the header region)
@@ -1872,121 +1277,6 @@ export declare class HeuristicTextMeasurer implements TextMeasurer {
     measureText(text: string, font: FontSpec): MeasuredText;
 }
 
-/**
- * The mouse position captured alongside a hit. Present even when the cursor is over no geom.
- *
- * Both coordinates are normalized pane-local values in `[0, 1]`. `y` is data-space (0 at the
- * bottom of the plot, 1 at the top), matching the compiler's `POSITION_VARIABLES.y` convention
- * — so the tracker is responsible for flipping SVG's top-origin Y before calling `query()`.
- */
-export declare interface HoverCursor {
-    x: number;
-    y: number;
-}
-
-/**
- * The transferable hover core. Indexes a compiled spec, diffs on update, and produces a
- * `HoverState` for any cursor position. No DOM access, no framework coupling.
- */
-export declare class HoverEngine {
-    private layerIndexes;
-    private layerRefs;
-    private aspectRatio;
-    private warmStarts;
-    private cachedState;
-    private cachedKey;
-    /**
-     * IDs of layers whose `CompiledLayer.interactive` is `false`. Recomputed on every `update()`
-     * so toggling the flag does not force an index rebuild. Used to filter the layer list before
-     * `hitTest` and `classify` see it — non-interactive layers participate in neither primary
-     * detection nor group/related, so they are visual decoration only as far as hover is concerned.
-     */
-    private nonInteractiveLayerIds;
-    constructor(spec: CompiledSpec);
-    /**
-     * Diff-aware re-index. Layers whose `data`, `geom`, `position` or the graph's coord-system
-     * reference changed are rebuilt; others are retained, including their warm-start seed. All
-     * four references live in `LayerRefSnapshot`, so `areRefsEqual` is the single source of truth
-     * for invalidation.
-     *
-     * Prev state is keyed by the stable `CompiledLayer.id` (== `LayerIndex.layerId`), not by array
-     * position, so reordering, insertion or removal of layers does not spuriously invalidate
-     * untouched layers' indexes or warm-starts.
-     */
-    update(spec: CompiledSpec): void;
-    /**
-     * Renderers call this on mount and on resize. Viewport is set-once, not per-query.
-     *
-     * On every call, viewport-dependent indexes are asked to re-prep themselves for the new
-     * viewport (`reindexPoints2DForAspect` is idempotent on aspect match, so unchanged-aspect
-     * calls are cheap). The renderer is expected to debounce resize events so the underlying
-     * Delaunay rebuild does not fire on every observed frame during a drag.
-     */
-    setViewport(viewport: HoverViewport): void;
-    /**
-     * Synchronous query. Returns the same `HoverState` reference while the primary stays on the
-     * same `(layerId, pointIndex)`, so subscribers using identity-based equality can short-circuit
-     * intra-geom cursor moves without re-rendering. Cache invalidates on `update()`. Warm-start
-     * seeds are written after every match so the next call walks a minimum number of Delaunay edges.
-     */
-    query(cursor: HoverCursor): HoverState;
-    private invalidateCache;
-}
-
-/**
- * A single hit returned by the hover engine.
- *
- * `layerId` is the stable `CompiledLayer.id` — *not* an array position. The engine preserves it
- * across `update()` calls regardless of layer reordering or insertion, so callers must resolve a
- * layer by matching `layer.id === hit.layerId`, never by `layers[layerId]`.
- *
- * `pointIndex` is an opaque per-layer stable handle for the hit geom, used by the engine as a
- * warm-start seed for subsequent queries. The encoding is per index kind:
- * - `buckets` / `rects` / `arcs`: the dataset row inside the layer's observations.
- * - `points`: the entry's position inside the layer's `points[]` (i.e. the Delaunay's array
- *   index). Diverges from the dataset row when the dataset has null x/y gaps, so callers must
- *   read `observation` rather than indexing `data` by `pointIndex`.
- *
- * In every case the handle is stable across `update()` calls for layers whose `data`/`geom`/
- * `position` references were not replaced (the warm-start identity promised by the ADR), and
- * callers that need the observation row should read `observation` — never index into the dataset
- * by `pointIndex`.
- */
-export declare interface HoverHit {
-    layerId: string;
-    pointIndex: number;
-    /**
-     * Normalized panel-local position. Cartesian: `[0, 1]²` in data-space (y=0 at the bottom,
-     * y=1 at the top — matching the compiler's `POSITION_VARIABLES.y`). Polar: `(angle in radians
-     * clockwise from 12 o'clock, radius in [0, 1])`.
-     */
-    x: number;
-    y: number;
-    /** The observation being hovered over. Renderers read values from here; the engine does not format. */
-    observation: Observation;
-}
-
-/** Output of `HoverEngine.query()`. */
-export declare interface HoverState {
-    primary: HoverHit | null;
-    group: HoverHit[];
-    /**
-     * Cross-layer and same-layer companion hits, bucketed by `CompiledLayer.id` so a per-layer
-     * consumer reads its own hits in O(1) (`related.get(layer.id) ?? []`) instead of filtering
-     * a flat array on every render. Layers with no companions are absent from the map — callers
-     * fall back to an empty array on miss.
-     */
-    related: ReadonlyMap<string, HoverHit[]>;
-}
-
-/** Viewport facts the engine needs for aspect-corrected hit testing. */
-export declare interface HoverViewport {
-    /** Panel width in pixels. */
-    width: number;
-    /** Pane height in pixels. */
-    height: number;
-}
-
 declare interface IdentityScaleInput {
     type: 'scale';
     scaledAesthetic: ScaledAestheticKey;
@@ -2014,46 +1304,16 @@ declare type InferredScaleOptions = ContinuousScaleOptions | DiscreteScaleOption
  */
 export declare type InterpolateType = 'linear' | 'catmull-rom';
 
-/** Narrows a coord system to the cartesian variant. */
-export declare function isCartesian(coordSystem: CoordSystem): coordSystem is CartesianCoordSystem;
-
 /**
- * Type guard that checks if a value is neither null nor undefined.
- */
-export declare function isDefined<T>(value: T | null | undefined): value is T;
-
-/**
- * Type guard for narrowing a `CompiledLayer` to its per-geom flavour. Use at dispatch sites that
- * pick a renderer based on `layer.geom`:
- *
- *   if (isLayerOf(layer, 'line')) renderLine(layer); // layer is CompiledLayerFor<'line'>
- */
-export declare function isLayerOf<G extends GeomName>(layer: CompiledLayer, geom: G): layer is CompiledLayerFor<G>;
-
-export declare function isStackedPosition(position: PositionType): boolean;
-
-/**
- * Compiles each layer through the transforms → stat → group → geom → position adjusters pipeline.
+ * Compiles each layer through the stat → group → geom → position adjusters pipeline.
  */
 declare class LayerCompiler {
-    private readonly transformCompiler;
     private readonly statCompiler;
     private readonly groupCompiler;
     private readonly geomCompiler;
     private readonly positionAdjusterCompiler;
-    private readonly layerValidator;
-    constructor(transformCompiler: TransformCompiler, statCompiler: StatCompiler, groupCompiler: GroupCompiler, geomCompiler: GeomCompiler, positionAdjusterCompiler: PositionAdjusterCompiler, layerValidator: LayerValidator);
+    constructor(statCompiler: StatCompiler, groupCompiler: GroupCompiler, geomCompiler: GeomCompiler, positionAdjusterCompiler: PositionAdjusterCompiler);
     compile(input: LayerCompilerInput): CompiledLayer[];
-    /**
-     * Applies each layer's transforms once and computes its effective mapping.
-     * The resulting data is used for both validation and the stat/group/geom pipeline.
-     */
-    private prepareLayers;
-    /**
-     * Validates each layer against its post-transform dataset and effective mapping.
-     */
-    private validateLayers;
-    private compileLayer;
 }
 
 declare interface LayerCompilerInput {
@@ -2080,17 +1340,6 @@ declare interface LayerInputBase {
     stat?: StatName;
     position?: PositionType;
     yScaleType?: YScaleType;
-    /**
-     * Ordered transforms applied to this layer's view of the data, on top of any
-     * spec-level transforms. Use this when a geom needs a different shape of the
-     * data than its siblings (e.g. a line overlay on top of reshaped stacked bars).
-     */
-    transforms?: TransformInput[];
-    /**
-     * When `false`, the layer is skipped from main hover hit-detection.
-     * @default true
-     */
-    interactive?: boolean;
 }
 
 declare type LayerInputOf<G extends GeomName> = LayerInputBase & {
@@ -2113,8 +1362,6 @@ declare interface LayerSpecBase {
     stat: StatName;
     position: PositionType;
     yScaleType: YScaleType;
-    transforms: TransformInput[];
-    interactive: boolean;
 }
 
 declare type LayerSpecOf<G extends GeomName> = LayerSpecBase & {
@@ -2122,113 +1369,45 @@ declare type LayerSpecOf<G extends GeomName> = LayerSpecBase & {
     params: GeomParamsMap[G];
 };
 
-declare interface LayerValidationInput {
-    layerId: string;
-    geom: GeomName;
-    stat: StatName;
-    /** `spec.mapping` merged with `layer.mapping` */
-    effectiveMapping: AesMapping;
-    /** Layer's dataset after its own transforms have been applied */
-    data: Dataset;
-}
-
 /**
- * Validates a single layer against a set of invariants.
+ * Compiles layout geometry from compiled guides and available dimensions.
  *
- * Checks:
- * 1. All required aesthetics are present (accounting for stat-computed variables).
- * 2. All mapped variables exist in the layer's dataset (after transforms).
+ * All output rects are in container coordinates (origin at the container's top-left).
+ * The renderer converts to SVG-local coordinates where needed by subtracting the plot origin.
  *
- * Returns issues rather than throwing. The caller (LayerCompiler) batches issues across all layers and throws
- * a single SpecValidationError at the end.
- */
-declare class LayerValidator {
-    private readonly geomRegistry;
-    private readonly statRegistry;
-    constructor(geomRegistry: GeomRegistry, statRegistry: StatRegistry);
-    validate(input: LayerValidationInput): ValidationIssue[];
-    /**
-     * Checks that all aesthetics required by the geom are present (accounting for stat-computed variables).
-     */
-    private validateRequiredAesthetics;
-    /**
-     * Checks that every mapped variable in the effective mapping exists in the layer's dataset (after
-     * transforms). Skips aesthetics that will be computed by stats (e.g. `y` when `stat='count'`).
-     */
-    private validateVariableExistence;
-}
-
-/** Outer padding around the whole chart, in pixels. */
-export declare const LAYOUT_PADDING = 24;
-
-/**
- * Compiles layout geometry and final axis ticks. Output rects are in container coordinates.
- *
- * Horizontal axis edge height is candidate-independent (~line-height), so `panel.height` is
- * settled after the first resolve.
- *
- * Here's the pipeline:
- *   1. **Seed**: stamp each axis with a placeholder label so the grid has something to measure.
- *   2. **Resolve v1**: first grid pass; `panel.height` is now final.
- *   3. **Finalize vertical**: pick the densest candidate that fits `panel.height` for left/right
- *      axes; horizontal axes keep their seed.
- *   4. **Resolve v2**: vertical edge widths now reflect final labels, so `panel.width` is final.
- *   5. **Finalize horizontal**: pick the densest candidate that fits `panel.width` for top/bottom
- *      axes. Vertical axes carry over from step 3.
- *   6. **Resolve v3**: final grid pass with all axes finalized.
+ * Uses a two-phase pipeline:
+ *   1. **Measure** — extracts axis/legend/label sizes via the injected measurer.
+ *   2. **Resolve** — builds a single grid and resolves all rects in container coordinates.
  */
 export declare class LayoutCompiler {
     private readonly measurer;
     constructor(measurer: LayoutMeasurer);
-    compile(input: LayoutCompilerInput): LayoutCompileResult;
-    /**
-     * Stamps each axis with a single hardcoded-label placeholder tick. This gives the grid something to measure in
-     * the first pass. The finalize pass replaces it with the real candidate selected for the resolved panel size.
-     */
-    private seedAxis;
-    private finalizeAxis;
-    private resolveLayout;
+    compile(input: LayoutCompilerInput): GraphLayout;
     /**
-     * Measures all graph elements from the formatted guides.
-     * Returns three EdgeSizes records. A size of 0 means the element is absent.
+     * Measures all chart elements from the compiled guides.
+     * Returns three EdgeSizes records — a size of 0 means the element is absent.
      */
     private measureGuides;
 }
 
-/**
- * Full output of {@link LayoutCompiler.compile} — the geometry plus the axes with their final formatted ticks.
- */
-export declare interface LayoutCompileResult {
-    layout: GraphLayout;
-    formattedAxes: FormattedAxis[];
-}
-
 /** Input for the layout compiler. */
-export declare interface LayoutCompilerInput {
-    compiled: CompiledSpec;
-    formattedLegends: FormattedLegend[];
+declare interface LayoutCompilerInput {
+    guides: CompiledGuides;
     containerSize: BoxSize;
     externalMeasurements: ExternalMeasurements;
-    formattingLocale?: Locale;
 }
 
 /** Positions where axes/labels/legends can be placed around the panel. */
 export declare type LayoutEdge = 'top' | 'right' | 'bottom' | 'left';
 
 /** Strategy for measuring chart element sizes in pixels. */
-export declare interface LayoutMeasurer {
+declare interface LayoutMeasurer {
     /** Returns the pixel size for an axis (height for top/bottom, width for left/right). */
-    measureAxis: (axis: FormattedAxis) => number;
+    measureAxis: (axis: CompiledAxisGuide) => number;
     /** Returns the pixel height for an axis label row. */
     measureAxisLabel: () => number;
     /** Returns the pixel size for a legend (height for top/bottom, width for left/right). */
-    measureLegend: (legend: FormattedLegend) => number;
-    /** Returns the size of a single tick label. */
-    measureTickLabel: (label: string) => MeasuredText;
-}
-
-declare interface Legend {
-    position?: 'auto' | 'top' | 'right' | 'none';
+    measureLegend: (legend: CompiledLegendGuide) => number;
 }
 
 /**
@@ -2267,17 +1446,13 @@ declare type LegendDisplay = 'pill' | 'direct' | 'auto';
 export declare interface LegendItem {
     /** Raw data value (e.g., "Apples") */
     value: DataValue;
-    /**
-     * Mapped visual values per aesthetic (e.g., { color: '#ff0000' }).
-     * An array signals multi-swatch rendering — used when a color scale is
-     * collapsed into a single legend item.
-     */
-    visual: Partial<Record<ScaledVisualAestheticKey, string | string[]>>;
+    /** Mapped visual values per aesthetic (e.g., { color: '#ff0000', fill: '#ff0000' }) */
+    visual: Partial<Record<ScaledVisualAestheticKey, string>>;
     /** Normalized y position in [0,1]. Null when display is not 'direct' or no endpoint found. */
     normalizedY: number | null;
 }
 
-export declare type LegendPosition = 'auto' | 'right' | 'left' | 'top' | 'bottom' | 'none';
+declare type LegendPosition = 'auto' | 'right' | 'left' | 'top' | 'bottom' | 'none';
 
 declare function line(options?: GeomOptions<'line'>): LayerInputOf<'line'>;
 
@@ -2299,13 +1474,6 @@ export declare interface LineGeomParams {
     missingValues: MissingValuesType;
 }
 
-declare interface LineOptions {
-    isSmoothLine?: boolean;
-    lineThickness?: number | 'auto';
-    showPoints?: boolean;
-    missingValues?: 'gap' | 'connect' | 'zero';
-}
-
 /**
  * Stroke style for line rendering.
  *
@@ -2315,27 +1483,6 @@ declare interface LineOptions {
  */
 export declare type LineStyleType = 'solid' | 'dashed' | 'dotted';
 
-export declare type Locale = (typeof LOCALES)[number];
-
-/** A BCP-47 string representing a supported locale. */
-declare const LOCALES: readonly ["en-GB", "en-US", "ar", "pt-PT"];
-
-/** The data-space axis a `CartesianCoordSystem` uses as the main (independent) axis. */
-export declare type MainAxis = 'x' | 'y';
-
-/**
- * Create a pipeable mapping spec item.
- *
- * @example
- * createSpec(
- *   data,
- *   transform.reshape({ reshape: ['revenue'], keyName: 'metric', valueName: 'amount' }),
- *   mapping({ x: 'month', y: 'amount', color: 'metric' }),
- *   geom.bar(),
- * )
- */
-export declare function mapping(aes: AesMapping): MappingItem;
-
 /**
  * A pipeable spec item that sets/merges the global aesthetic mapping.
  */
@@ -2429,15 +1576,9 @@ declare interface NumberFormatConfig {
 
 declare type NumericDataValue = number | null;
 
-declare interface NumericValueFormat {
-    type: 'decimal' | 'integer' | 'percentage' | 'duration';
-}
-
 /** A single row of data, mapping every variable name to the value in that row. */
 export declare type Observation = Record<VariableName, DataValue>;
 
-declare type Options = Partial<LineOptions & BarOptions & ScatterOptions & ComboOptions & PieOptions & TableOptions>;
-
 /**
  * A named store for color palettes used by scale compilation.
  *
@@ -2488,10 +1629,6 @@ declare interface PanelConfig {
     };
 }
 
-declare interface PieOptions {
-    pieTotalPosition?: 'center' | 'outside';
-}
-
 /**
  * Pipe a spec through a series of spec items (left-to-right).
  */
@@ -2664,8 +1801,6 @@ declare interface PositionMapperInput {
  */
 export declare type PositionType = 'stack' | 'dodge' | 'identity' | 'fill';
 
-export declare const prefixInternalVariable: (name: string) => string;
-
 declare interface QuantitativeScaleMethods {
     /**
      * Continuous (numeric) scale. Supports `transform`, `reverse`, `nice`, `zero`, `domainMin`, `domainMax`.
@@ -2684,11 +1819,6 @@ declare interface QuantitativeScaleMethods {
     identity: (options?: IdentityScaleOptions) => IdentityScaleInput;
 }
 
-export declare interface RadiusExtent {
-    innerRadius: NumericDataValue;
-    outerRadius: NumericDataValue;
-}
-
 /** A rectangle in pixel coordinates, origin at top-left. */
 export declare interface Rect {
     x: number;
@@ -2697,12 +1827,6 @@ export declare interface Rect {
     height: number;
 }
 
-declare interface ReferenceLines {
-    goalLine?: GoalLine;
-    trendline?: TrendlineType;
-    averageLine?: AverageLine;
-}
-
 /**
  * A typed key-value store for looking up registered implementations by name.
  *
@@ -2731,11 +1855,6 @@ declare class Registry<K extends string, T> {
     has(key: K): boolean;
 }
 
-/***************************************************************
- * Builders
- ***************************************************************/
-declare function reshape(options?: ReshapeOptions): ReshapeTransformInput;
-
 /***************************************************************
  * Reshape Transform
  ***************************************************************/
@@ -2785,12 +1904,6 @@ export declare type ResolvedLegendDisplay = Exclude<LegendDisplay, 'auto'>;
  */
 export declare type ResolvedLegendPosition = Exclude<LegendPosition, 'auto' | 'none'>;
 
-/**
- * Canonical resting `HoverState`. Exported so the renderer-side store can reuse this exact
- * reference instead of maintaining a parallel literal that could drift.
- */
-export declare const RESTING_HOVER_STATE: HoverState;
-
 /** TipTap-compatible rich text node (no tiptap dependency). */
 export declare interface RichTextContent {
     type: string;
@@ -2870,10 +1983,6 @@ declare class ScaleCompiler {
     private readonly registry;
     constructor(registry: ScaleRegistry);
     compile(input: ScaleCompilerInput): CompiledScales;
-    /**
-     * Pre-pass: each scale's source variable must have a data type the scale can handle.
-     */
-    private validateScaleTypeCompatibility;
     /**
      * Walk all layers' mappings and collect data values per scale aesthetic key.
      *
@@ -2947,116 +2056,6 @@ declare type ScaleTransformType = 'linear' | 'log' | 'sqrt';
  */
 declare type ScaleType = 'continuous' | 'discrete' | 'datetime' | 'identity' | 'palette';
 
-declare interface ScatterOptions {
-    pointSize?: number | 'auto';
-}
-
-/**
- * Serialized representation of a command for wire transport and persistence.
- * Only forward commands are serialized — inverses are recomputed at execution time.
- */
-export declare interface SerializedCommand {
-    readonly type: string;
-    readonly params: Record<string, unknown>;
-    readonly metadata: CommandMetadata;
-}
-
-/** Config for styling a specific series. */
-declare interface SeriesStyle {
-    paletteColorId?: string;
-    customColor?: string;
-    fillStyle?: 'solid' | 'hatched';
-    lineStyle?: 'solid' | 'dashed' | 'dotted';
-}
-
-/**
- * Sets the chart background color.
- * When set to null, the renderer falls back to its theme default.
- */
-export declare class SetAppearanceBackgroundCommand implements Command<SetAppearanceBackgroundParams> {
-    readonly type: "set-appearance-background";
-    readonly metadata: CommandMetadata;
-    readonly params: SetAppearanceBackgroundParams;
-    constructor(params: SetAppearanceBackgroundParams, metadata?: Partial<CommandMetadata>);
-    apply(spec: Spec): CommandApplyResult | null;
-}
-
-export declare type SetAppearanceBackgroundParams = {
-    background: string | null;
-};
-
-/**
- * Toggles visibility of the chart's textual content (title, subtitle, caption) as a group.
- * Underlying text values are preserved so toggling back restores them.
- */
-export declare class SetContentVisibilityCommand implements Command<SetContentVisibilityParams> {
-    readonly type: "set-content-visibility";
-    readonly metadata: CommandMetadata;
-    readonly params: SetContentVisibilityParams;
-    constructor(params: SetContentVisibilityParams, metadata?: Partial<CommandMetadata>);
-    apply(spec: Spec): CommandApplyResult | null;
-}
-
-export declare type SetContentVisibilityParams = {
-    isVisible: boolean;
-};
-
-/**
- * Command that swaps the dataset on a spec while preserving layer identity and all other
- * configuration. Enables data-change transitions — existing layer ids are retained, so
- * renderers using id-based keys can morph geoms instead of unmounting them.
- *
- * Accepts either raw `Data` (parsed on apply) or a pre-parsed `Dataset` (used by the revert
- * command). Revert commands are not serialized, so carrying a `Dataset` is safe.
- */
-export declare class SetDataCommand implements Command<SetDataParams> {
-    readonly type: "set-data";
-    readonly metadata: CommandMetadata;
-    readonly params: SetDataParams;
-    constructor(params: SetDataParams, metadata?: Partial<CommandMetadata>);
-    apply(spec: Spec): CommandApplyResult | null;
-}
-
-export declare type SetDataParams = {
-    /** Raw data (will be parsed) or a pre-parsed `Dataset` (used for reverts). */
-    data: Data | Dataset;
-};
-
-/**
- * Controls grid line visibility for both axes simultaneously.
- * Takes independent x/y visibility flags to allow per-axis grid control and proper revert support.
- */
-export declare class SetGridVisibilityCommand implements Command<SetGridVisibilityParams> {
-    readonly type: "set-grid-visibility";
-    readonly metadata: CommandMetadata;
-    readonly params: SetGridVisibilityParams;
-    constructor(params: SetGridVisibilityParams, metadata?: Partial<CommandMetadata>);
-    apply(spec: Spec): CommandApplyResult | null;
-}
-
-export declare type SetGridVisibilityParams = {
-    xIsVisible: boolean | null;
-    yIsVisible: boolean | null;
-};
-
-/**
- * Sets the legend placement relative to the chart (e.g. auto, top, bottom, left, right, none).
- * 'auto' lets the renderer choose the best position; 'none' hides the legend entirely.
- */
-export declare class SetLegendPositionCommand implements Command<SetLegendPositionParams> {
-    readonly type: "set-legend-position";
-    readonly metadata: CommandMetadata;
-    readonly params: SetLegendPositionParams;
-    constructor(params: SetLegendPositionParams, metadata?: Partial<CommandMetadata>);
-    apply(spec: Spec): CommandApplyResult | null;
-}
-
-export declare type SetLegendPositionParams = {
-    position: LegendPosition;
-};
-
-declare function sort(options: SortOptions): SortTransformInput;
-
 /***************************************************************
  * Sort Transform
  ***************************************************************/
@@ -3091,19 +2090,15 @@ declare interface SortTransformInput {
  * // resolved.config   → axes, legend, headline, panel, numberFormat with defaults
  * ```
  */
-export declare interface Spec {
+declare interface Spec {
     /** The dataset backing the visualization. */
     data: Dataset;
-    /** Per-column metadata captured at parse time (inferred value formats). Used by guide compilation to format tick and legend labels. */
-    datasetMetadata: DatasetMetadata;
     /** Global aesthetic mappings (data columns → visual channels). */
     mapping: AesMapping;
     /** Geometry layers to render. Each layer has resolved geom, stat, position, and params. */
     layers: LayerSpec[];
     /** Resolved scale specs — one per aesthetic, all defaults filled, no 'inferred' types remaining. */
     scales: ScaleSpec[];
-    /** Data transforms applied to `data` before layer compilation. */
-    transforms: TransformInput[];
     /** Coordinate system (cartesian, flip, or polar) with fully defaulted params. */
     coords: CoordSpec;
     /** Chart configuration: axes, legend, headline, panel, number formatting. */
@@ -3115,7 +2110,7 @@ export declare interface Spec {
  * This is what commands operate on and what gets stored in undo/redo snapshots.
  */
 export declare interface SpecInput {
-    data: Data;
+    data: Dataset;
     mapping: AesMapping;
     layers: LayerInput[];
     scales: ScaleInput[];
@@ -3127,11 +2122,40 @@ export declare interface SpecInput {
 declare type SpecItem = LayerInput | ScaleInput | CoordInput | ConfigItem | TransformInput | MappingItem;
 
 /**
- * Compiles a raw compiler input or graph config into a resolved Spec.
+ * Validates a resolved spec before compilation.
+ *
+ * Checks:
+ * 1. All required aesthetics are present (accounting for stat-computed variables)
+ * 2. All mapped variables exist in the dataset
+ * 3. Variable data types are compatible with their assigned scale types
+ *
+ * Collects all issues and throws a single {@link SpecValidationError} if any are found.
  */
-export declare class SpecResolver {
-    compile(compilerInput: SpecInput | GraphConfig): Spec;
-    resolveFromInput(input: SpecInput | GraphConfig, dataset: Dataset, datasetMetadata: DatasetMetadata): Spec;
+declare class SpecValidator {
+    private readonly statRegistry;
+    private readonly scaleRegistry;
+    private readonly geomRegistry;
+    constructor(dependencies: {
+        statRegistry: StatRegistry;
+        scaleRegistry: ScaleRegistry;
+        geomRegistry: GeomRegistry;
+    });
+    validate(spec: Spec): Spec;
+    /**
+     * Checks that all aesthetics required by the geom are present in the effective mapping,
+     * accounting for aesthetics that the stat will produce.
+     */
+    private validateRequiredAesthetics;
+    /**
+     * Checks that every mapped variable in the effective mapping exists in the dataset.
+     * Skips aesthetics that will be computed by stats (e.g. y when stat='count').
+     */
+    private validateVariableExistence;
+    /**
+     * Checks that each scale's data type is compatible with its assigned scale type.
+     * Uses the global mapping to find the variable for each scale aesthetic.
+     */
+    private validateScaleTypeCompatibility;
 }
 
 /**
@@ -3178,23 +2202,8 @@ declare class StatRegistry extends Registry<StatName, Stat> {
     constructor();
 }
 
-/**
- * Visual signature of the source geom.
- */
-export declare type SwatchShape = 'square' | 'line' | 'circle' | 'area' | 'slice';
-
 declare type Table = internal.ColumnTable;
 
-declare interface TableOptions {
-    tableColumnRatios?: Record<string, number>;
-}
-
-declare interface TemporalValueFormat {
-    type: 'datetime' | 'time' | 'date' | 'year' | 'quarter' | 'month_year' | 'month' | 'weekly_date_range_with_year' | 'weekly_date_range' | 'day_month';
-    /** Template string representing how values of this type have been formatted. ie. dd-mm-yyyy  */
-    dateFormat?: string;
-}
-
 /** A text value — plain string or structured rich text. */
 export declare type TextContent = string | RichTextContent;
 
@@ -3202,43 +2211,6 @@ export declare interface TextMeasurer {
     measureText: (text: string, font: FontSpec) => MeasuredText;
 }
 
-/** Fully-derived tooltip content. The popover renders directly from this. */
-export declare interface TooltipContent {
-    /** Formatted main-axis value of the primary's observation. `null` for polar. */
-    header: string | null;
-    rows: TooltipRow[];
-}
-
-/**
- * One row in the chart tooltip popover. Pure projection of a `HoverHit` against the layer's
- * compiled scales.
- */
-export declare interface TooltipRow {
-    /**
-     * Resolved color string applied as the row's swatch fill/stroke. `null` only when the chart
-     * has no color scale at all — the popover suppresses the swatch cell in that edge case.
-     */
-    swatchColor: string | null;
-    /** Visual signature of the row's source geom. Drives the swatch shape. */
-    swatchShape: SwatchShape;
-    /** Row label — color value (multi-series) or layer's Y-axis title (single-series). */
-    label: string;
-    /** Formatted Y reading for this hit. */
-    value: string;
-    /** Styling hint: the row whose hit `=== primary`. Never re-orders. */
-    isPrimary: boolean;
-    /** Stable key — `${layerId}:${pointIndex}`. */
-    key: string;
-}
-
-export declare const transform: {
-    reshape: typeof reshape;
-    filter: typeof filter;
-    sort: typeof sort;
-    aggregate: typeof aggregate;
-    constant: typeof constant;
-};
-
 /**
  * Applies spec-level transforms to a dataset by delegating to registered strategies.
  */
@@ -3251,7 +2223,7 @@ declare class TransformCompiler {
 /***************************************************************
  * Transform Input
  ***************************************************************/
-declare type TransformInput = ReshapeTransformInput | FilterTransformInput | SortTransformInput | AggregateTransformInput | ConstantTransformInput;
+declare type TransformInput = ReshapeTransformInput | FilterTransformInput | SortTransformInput | AggregateTransformInput;
 
 /**
  * Built-in transform implementations keyed by transform type.
@@ -3270,43 +2242,6 @@ declare interface TransformStrategy {
 
 declare type TransformType = TransformInput['transformType'];
 
-declare type TrendlineType = 'linear' | 'loess' | 'exponential' | 'logarithmic' | 'quadratic' | 'power' | 'polynomial';
-
-/**
- * Result of an undo/redo operation.
- */
-declare interface UndoRedoResult {
-    /** The new spec after the operation */
-    spec: Spec;
-    /** The original command that was undone/redone */
-    command: Command;
-}
-
-/**
- * Shared validation types used across compiler stages.
- *
- * Each validation stage (e.g. {@link LayerValidator}, the pre-pass in {@link ScaleCompiler}) collects
- * {@link ValidationIssue}s and throws a single {@link SpecValidationError} at the end of its stage.
- */
-declare type ValidationCode = 'UNKNOWN_VARIABLE' | 'INCOMPATIBLE_TYPE' | 'MISSING_AESTHETIC';
-
-declare interface ValidationIssue {
-    code: ValidationCode;
-    message: string;
-    layerId?: string;
-    aesthetic?: string;
-}
-
-declare type ValueFormat = TemporalValueFormat | NumericValueFormat | CurrencyValueFormat | CategoricalValueFormat;
-
-/**
- * Constant mapping - a literal value applied to every observation.
- * Analogous to Vega-Lite's `{datum: X}` / ggplot2's `aes(color = "literal")`.
- */
-declare interface ValueMapping {
-    value: DataValue;
-}
-
 /** A column of a variable in the dataset. */
 declare type Variable = {
     type: DataType;
@@ -3376,12 +2311,6 @@ declare interface XAxisConfig {
     ticks: AxisTicksConfig;
 }
 
-/** Minimal x/y shape — most runtime records satisfy this (HoverCursor, HoverHit, etc.). */
-export declare interface XYPoint {
-    x: number;
-    y: number;
-}
-
 /**
  * Y-axis configuration (after defaults applied)
  */