matterviz 0.3.7 → 0.4.1

package/dist/plot/{scales.js → core/scales.js}

@@ -1,5 +1,5 @@
-import * as math from '../math';
-import { get_arcsinh_threshold, get_scale_type_name, is_time_scale } from './types';
+import * as math from '../../math';
+import { get_arcsinh_threshold, get_scale_type_name, is_time_scale, } from './types';
 import { extent, range } from 'd3-array';
 import { scaleLinear, scaleLog, scaleSequential, scaleSequentialLog, scaleTime, } from 'd3-scale';
 import * as d3_sc from 'd3-scale-chromatic';
@@ -33,8 +33,8 @@ export function scale_arcsinh(threshold = 1) {
         // Linear interpolation in transformed space
         if (t_max === t_min)
             return (r_min + r_max) / 2;
-        const t = (t_val - t_min) / (t_max - t_min);
-        return r_min + t * (r_max - r_min);
+        const frac = (t_val - t_min) / (t_max - t_min);
+        return r_min + frac * (r_max - r_min);
     });
     // Domain getter/setter
     scale.domain = function (domain) {
@@ -63,8 +63,8 @@ export function scale_arcsinh(threshold = 1) {
         // Inverse linear interpolation
         if (r_max === r_min)
             return (d_min + d_max) / 2;
-        const t = (value - r_min) / (r_max - r_min);
-        const t_val = t_min + t * (t_max - t_min);
+        const frac = (value - r_min) / (r_max - r_min);
+        const t_val = t_min + frac * (t_max - t_min);
         // Inverse transform
         return sinh_transform(t_val);
     };
@@ -83,9 +83,8 @@ export function scale_arcsinh(threshold = 1) {
     return scale;
 }
 // Generate nice tick values for arcsinh scale
-// Strategy: symmetric around zero when possible, with powers of 10 for large values
-// Note: For small count values (1 or 2) on mixed ranges, zero takes priority as the
-// most important tick. E.g., count=1 yields [0], count=2 yields [0] plus one boundary.
+// Strategy: symmetric around zero when possible, with powers of 10 for large values.
+// On mixed ranges, count=1 yields just [0]; count>=2 yields zero plus symmetric powers per side.
 export function generate_arcsinh_ticks(min, max, threshold = 1, count = 10) {
     // Guard against invalid/non-positive threshold to prevent division issues
     const safe_threshold = Math.max(threshold, Number.EPSILON);
@@ -101,9 +100,10 @@ export function generate_arcsinh_ticks(min, max, threshold = 1, count = 10) {
             .map((tick) => -tick)
             .toReversed();
     }
-    // Mixed range: symmetric ticks around zero (includes_zero is always true here)
-    // For very small counts, we prioritize zero as the most meaningful tick
-    const half_count = Math.floor((count - 1) / 2);
+    // Mixed range: symmetric ticks around zero (includes_zero is always here). Split the budget
+    // across both sides (zero is shared/free) so e.g. count=4 yields ~5 ticks (0, ±a, ±b) rather
+    // than collapsing to 3 — matching how linear/log colorbars render a similar count.
+    const half_count = Math.floor(count / 2);
     const ticks = [0];
     // Add positive ticks
     const pos_ticks = generate_positive_arcsinh_ticks(0, hi, safe_threshold, half_count);
@@ -111,19 +111,6 @@ export function generate_arcsinh_ticks(min, max, threshold = 1, count = 10) {
     // Add negative ticks (mirror of positive)
     const neg_ticks = generate_positive_arcsinh_ticks(0, -lo, safe_threshold, half_count);
     ticks.push(...neg_ticks.filter((tick) => tick > 0).map((tick) => -tick));
-    // For small counts where half_count is 0 or 1, ensure at least some boundary coverage
-    if (half_count <= 1 && count >= 2) {
-        // Add boundaries if not already present and we have room
-        const sorted = dedupe_sort(ticks);
-        if (sorted.length < count) {
-            // Snap the larger-magnitude boundary to a clean power of 10 (raw extremes would render
-            // as long unrounded labels); keeps some coverage for very small tick counts.
-            const boundary = Math.abs(hi) >= Math.abs(lo) ? hi : lo;
-            const nice = Math.sign(boundary) * 10 ** Math.floor(Math.log10(Math.abs(boundary)));
-            if (Number.isFinite(nice) && nice !== 0 && !sorted.includes(nice))
-                ticks.push(nice);
-        }
-    }
     return dedupe_sort(ticks);
 }
 // Generate positive arcsinh ticks (helper)
@@ -133,46 +120,49 @@ function generate_positive_arcsinh_ticks(min, max, threshold, count) {
     if (count <= 0 || max <= min)
         return [];
     const ticks = [];
-    // For values near threshold, use linear-like spacing
-    // For values >> threshold, use log-like spacing (powers of 10)
+    // Small range near threshold: use linear-like spacing
     if (max <= threshold * 2) {
-        // Small range: use linear ticks
         const step = (max - min) / count;
         for (let idx = 0; idx <= count; idx++) {
             const val = min + step * idx;
             if (val >= min && val <= max)
                 ticks.push(val);
         }
+        return dedupe_sort(ticks);
     }
-    else {
-        // Large range: combine linear near zero with powers of 10.
-        // Domain endpoints are intentionally NOT added as ticks: raw extremes render as long
-        // unrounded labels (e.g. 1325.8239811994677). Powers of 10 plus 2x/5x multiples below
-        // already give clean round ticks; pass axis.ticks/axis.format for custom labels.
-        // Add threshold as a tick if in range
-        if (threshold >= min && threshold <= max)
-            ticks.push(threshold);
-        // Add powers of 10 that are in range
-        const min_power = Math.floor(Math.log10(Math.max(min, threshold / 10)));
-        const max_power = Math.ceil(Math.log10(max));
-        for (let power = min_power; power <= max_power; power++) {
-            const val = Math.pow(10, power);
-            if (val >= min && val <= max)
-                ticks.push(val);
-        }
-        // Add intermediate values (2x, 5x) for sparser regions
-        if (ticks.length < count) {
-            for (let power = min_power; power < max_power; power++) {
-                const base = Math.pow(10, power);
-                for (const mult of [2, 5]) {
-                    const val = base * mult;
-                    if (val >= min && val <= max)
-                        ticks.push(val);
-                }
+    // Large range: log-like spacing via powers of 10.
+    // Domain endpoints are intentionally NOT added as ticks: raw extremes render as long
+    // unrounded labels (e.g. 1325.8239811994677). Powers of 10 plus 2x/5x multiples below
+    // already give clean round ticks; pass axis.ticks/axis.format for custom labels.
+    // Add threshold as a tick if in range
+    if (threshold >= min && threshold <= max)
+        ticks.push(threshold);
+    // Add powers of 10 that are in range. Start at the threshold (not a decade below): values
+    // below it sit in arcsinh's near-linear region and map almost onto 0, so sub-threshold powers
+    // (e.g. ±1 when threshold=10) would pile up on the zero tick and overlap.
+    const min_power = Math.floor(Math.log10(Math.max(min, threshold)));
+    const max_power = Math.ceil(Math.log10(max));
+    for (let power = min_power; power <= max_power; power++) {
+        const val = 10 ** power;
+        if (val >= min && val <= max)
+            ticks.push(val);
+    }
+    // Add intermediate values (2x, 5x) for sparser regions
+    if (ticks.length < count) {
+        for (let power = min_power; power < max_power; power++) {
+            const base = 10 ** power;
+            for (const mult of [2, 5]) {
+                const val = base * mult;
+                if (val >= min && val <= max)
+                    ticks.push(val);
             }
         }
     }
-    return dedupe_sort(ticks);
+    const result = dedupe_sort(ticks);
+    // Respect `count`: surplus small powers sit near zero in arcsinh space (their values map almost
+    // onto 0) and crowd the labels. Keep the largest-magnitude ticks — they anchor the range extent
+    // and are the most spread out — dropping near-zero ones first.
+    return result.length > count ? result.slice(-count) : result;
 }
 // Create a scale function based on type, domain, and range
 // Note: Time scales are handled separately via create_time_scale() since ScaleTime
@@ -182,8 +172,13 @@ export function create_scale(scale_type, domain, output_range) {
     const [min_val, max_val] = domain;
     const type_name = get_scale_type_name(scale_type);
     if (type_name === `log`) {
+        // Clamp BOTH ends to the positive floor: panning shifts ranges linearly, so a
+        // log axis panned past zero can arrive with max <= 0 — an unclamped max makes
+        // every scale output (and invert) NaN, blanking the chart and polluting axis
+        // ranges. A clamped degenerate domain just renders flat and stays recoverable.
+        const lo = Math.max(min_val, math.LOG_EPS);
         return scaleLog()
-            .domain([Math.max(min_val, math.LOG_EPS), max_val])
+            .domain([lo, Math.max(max_val, lo)])
             .range(output_range);
     }
     if (type_name === `arcsinh`) {
@@ -229,15 +224,17 @@ options = {}) {
         const ticks = time_scale.ticks(count);
         if (typeof ticks_option === `string`) {
             if (ticks_option === `month`) {
-                return ticks.filter((d) => d.getDate() === 1).map((d) => d.getTime());
+                return ticks
+                    .filter((date) => date.getDate() === 1)
+                    .map((date) => date.getTime());
             }
             if (ticks_option === `year`) {
                 return ticks
-                    .filter((d) => d.getMonth() === 0 && d.getDate() === 1)
-                    .map((d) => d.getTime());
+                    .filter((date) => date.getMonth() === 0 && date.getDate() === 1)
+                    .map((date) => date.getTime());
             }
         }
-        return ticks.map((d) => d.getTime());
+        return ticks.map((date) => date.getTime());
     }
     const type_name = get_scale_type_name(scale_type);
     // Log scale ticks
@@ -284,15 +281,15 @@ export function get_nice_data_range(points, get_value, limits, scale_type, paddi
             const span = data_max - data_min;
             if (is_time) {
                 const padding_ms = span * padding_factor;
-                data_min = data_min - padding_ms;
-                data_max = data_max + padding_ms;
+                data_min -= padding_ms;
+                data_max += padding_ms;
             }
             else if (type_name === `log`) {
                 const log_min = Math.log10(Math.max(data_min, math.LOG_EPS));
                 const log_max = Math.log10(Math.max(data_max, math.LOG_EPS));
                 const log_span = log_max - log_min;
-                data_min = Math.pow(10, log_min - log_span * padding_factor);
-                data_max = Math.pow(10, log_max + log_span * padding_factor);
+                data_min = 10 ** (log_min - log_span * padding_factor);
+                data_max = 10 ** (log_max + log_span * padding_factor);
             }
             else if (type_name === `arcsinh`) {
                 // Arcsinh: apply padding in arcsinh-transformed space
@@ -307,35 +304,33 @@ export function get_nice_data_range(points, get_value, limits, scale_type, paddi
             else {
                 // Linear scale
                 const padding_abs = span * padding_factor;
-                data_min = data_min - padding_abs;
-                data_max = data_max + padding_abs;
+                data_min -= padding_abs;
+                data_max += padding_abs;
             }
+            // Handle single data point case with fixed relative padding
+        }
+        else if (is_time) {
+            const one_day = 86_400_000; // milliseconds in a day
+            data_min -= one_day;
+            data_max += one_day;
+        }
+        else if (type_name === `log`) {
+            data_min = Math.max(math.LOG_EPS, data_min / 1.1); // 10% multiplicative padding
+            data_max *= 1.1;
+        }
+        else if (type_name === `arcsinh`) {
+            // Arcsinh: 10% padding in transformed space
+            // Guard against extremely small thresholds that could cause precision issues
+            const threshold = Math.max(get_arcsinh_threshold(scale_type), Number.EPSILON);
+            const asinh_val = Math.asinh(data_min / threshold);
+            const padding = Math.abs(asinh_val) * 0.1 || 0.1; // Use 0.1 if transformed value is 0 (i.e. data_min = 0)
+            data_min = Math.sinh(asinh_val - padding) * threshold;
+            data_max = Math.sinh(asinh_val + padding) * threshold;
         }
         else {
-            // Handle single data point case with fixed relative padding
-            if (is_time) {
-                const one_day = 86_400_000; // milliseconds in a day
-                data_min = data_min - one_day;
-                data_max = data_max + one_day;
-            }
-            else if (type_name === `log`) {
-                data_min = Math.max(math.LOG_EPS, data_min / 1.1); // 10% multiplicative padding
-                data_max = data_max * 1.1;
-            }
-            else if (type_name === `arcsinh`) {
-                // Arcsinh: 10% padding in transformed space
-                // Guard against extremely small thresholds that could cause precision issues
-                const threshold = Math.max(get_arcsinh_threshold(scale_type), Number.EPSILON);
-                const asinh_val = Math.asinh(data_min / threshold);
-                const padding = Math.abs(asinh_val) * 0.1 || 0.1; // Use 0.1 if transformed value is 0 (i.e. data_min = 0)
-                data_min = Math.sinh(asinh_val - padding) * threshold;
-                data_max = Math.sinh(asinh_val + padding) * threshold;
-            }
-            else {
-                const padding_abs = data_min === 0 ? 1 : Math.abs(data_min * 0.1); // 10% additive padding, or 1 if value is 0
-                data_min = data_min - padding_abs;
-                data_max = data_max + padding_abs;
-            }
+            const padding_abs = data_min === 0 ? 1 : Math.abs(data_min * 0.1); // 10% additive padding, or 1 if value is 0
+            data_min -= padding_abs;
+            data_max += padding_abs;
         }
     }
     // If time or no range after padding, return the (potentially padded) domain directly
@@ -371,20 +366,26 @@ export function generate_log_ticks(min, max, ticks_option) {
     const range_size = max_power - min_power;
     const extended_min_power = range_size <= 2 ? min_power - 1 : min_power - Math.max(1, Math.floor(range_size / 4));
     const extended_max_power = range_size <= 2 ? max_power + 1 : max_power;
-    const powers = range(extended_min_power, extended_max_power + 1).map((power) => Math.pow(10, power));
+    const powers = range(extended_min_power, extended_max_power + 1).map((power) => 10 ** power);
     // For narrow ranges, include intermediate values
     if (max_power - min_power < 3 && typeof ticks_option === `number` && ticks_option > 5) {
         const detailed_ticks = [];
         powers.forEach((power) => {
             detailed_ticks.push(power);
-            if (power * 2 <= Math.pow(10, extended_max_power))
+            if (power * 2 <= 10 ** extended_max_power)
                 detailed_ticks.push(power * 2);
-            if (power * 5 <= Math.pow(10, extended_max_power))
+            if (power * 5 <= 10 ** extended_max_power)
                 detailed_ticks.push(power * 5);
         });
         return detailed_ticks.filter((tick) => tick >= min && tick <= max);
     }
-    return powers.filter((power) => power >= min && power <= max);
+    const filtered_powers = powers.filter((power) => power >= min && power <= max);
+    if (filtered_powers.length >= 2)
+        return filtered_powers;
+    // Sub-decade domains (e.g. after zoom) have <2 powers of 10 — use d3's mantissa log ticks
+    const tick_count = typeof ticks_option === `number` && ticks_option > 0 ? ticks_option : 5;
+    const fallback = scaleLog().domain([min, max]).ticks(tick_count);
+    return fallback.length > 0 ? fallback : filtered_powers;
 }
 // Get custom label for a tick value if provided, otherwise return null
 export function get_tick_label(tick_value, ticks_option) {

package/dist/plot/core/svg.d.ts

@@ -0,0 +1,3 @@
+import type { Vec2 } from '../../math';
+export declare function violin_path(grid_px: readonly number[], half_offsets_px: readonly number[], center: number, side: `both` | `positive` | `negative`, orient: (cross: number, val: number) => Vec2): string;
+export declare function bar_path(x: number, y: number, w: number, h: number, r: number, vertical?: boolean): string;

package/dist/plot/core/svg.js

@@ -0,0 +1,41 @@
+// SVG path and rendering utilities for plot components.
+// Build a closed SVG path for a violin (KDE density) shape.
+// `grid_px` are value-axis pixel positions, `half_offsets_px` the category-axis half-widths
+// (>= 0) at each grid point, `center` the category-axis center pixel. `orient(cross, val)`
+// swaps coordinates for orientation (vertical: [cross, val], horizontal: [val, cross]).
+// `both` mirrors density around the center; `positive`/`negative` draw one half against the
+// center line. Linear interpolation between grid points (no curve overshoot).
+export function violin_path(grid_px, half_offsets_px, center, side, orient) {
+    const n_pts = grid_px.length;
+    if (n_pts === 0)
+        return ``;
+    const pts = [];
+    if (side === `both`) {
+        for (let idx = 0; idx < n_pts; idx++) {
+            pts.push(orient(center + half_offsets_px[idx], grid_px[idx]));
+        }
+        for (let idx = n_pts - 1; idx >= 0; idx--) {
+            pts.push(orient(center - half_offsets_px[idx], grid_px[idx]));
+        }
+    }
+    else {
+        const sign = side === `negative` ? -1 : 1;
+        for (let idx = 0; idx < n_pts; idx++) {
+            pts.push(orient(center + sign * half_offsets_px[idx], grid_px[idx]));
+        }
+        // straight inner edge back along the center line
+        pts.push(orient(center, grid_px[n_pts - 1]));
+        pts.push(orient(center, grid_px[0]));
+    }
+    return `M${pts.map(([x_pos, y_pos]) => `${x_pos},${y_pos}`).join(`L`)}Z`;
+}
+//
+// Generate SVG path for a bar with rounded corners on the "free" end (away from axis).
+// For vertical bars, rounds top corners. For horizontal bars, rounds right corners.
+export function bar_path(x, y, w, h, r, vertical = true) {
+    if (r <= 0)
+        return `M${x},${y}h${w}v${h}h${-w}Z`;
+    return vertical
+        ? `M${x},${y + h}V${y + r}A${r},${r} 0 0 1 ${x + r},${y}H${x + w - r}A${r},${r} 0 0 1 ${x + w},${y + r}V${y + h}Z`
+        : `M${x},${y}H${x + w - r}A${r},${r} 0 0 1 ${x + w},${y + r}V${y + h - r}A${r},${r} 0 0 1 ${x + w - r},${y + h}H${x}Z`;
+}

package/dist/plot/{types.d.ts → core/types.d.ts}

@@ -1,13 +1,18 @@
-import type { D3SymbolName } from '../labels';
-import type { Point2D, Point3D, Vec2, Vec3 } from '../math';
-import type DraggablePane from '../overlays/DraggablePane.svelte';
+import type { PaneProps, PaneToggleProps } from '../../overlays';
+import type { D3ColorSchemeName, D3InterpolateName } from '../../colors';
+import type { D3SymbolName } from '../../labels';
+import type { Point2D, Point3D, Vec2, Vec3 } from '../../math';
 import type { ComponentProps, Snippet } from 'svelte';
 import type { HTMLAttributes } from 'svelte/elements';
 import type { TweenOptions } from 'svelte/motion';
-export type { TweenOptions } from 'svelte/motion';
 import type { Sides } from './layout';
-import type PlotLegend from './PlotLegend.svelte';
+import type PlotLegend from './components/PlotLegend.svelte';
 import type { TicksOption } from './scales';
+export type { TweenOptions } from 'svelte/motion';
+export type { BandwidthOption, BoxHandlerProps, BoxPlotSeries, ViolinKind, ViolinSide, WhiskerMode, } from '../box/box-plot';
+export type { CleaningConfig, CleaningQuality, CleaningResult, InstabilityResult, InvalidValueMode, LocalOutlierConfig, LocalOutlierResult, OscillationWeights, PhysicalBounds, SmoothingConfig, TruncationMode, } from './data-cleaning';
+export type { SankeyData, SankeyHandlerProps, SankeyLink, SankeyLinkColorMode, SankeyLinkHandlerProps, SankeyNode, SankeyNodeAlign, SankeyNodeHandlerProps, SankeyOrientation, } from '../sankey/sankey-types';
+export type { SunburstLabelRotation, SunburstLabelText, SunburstNode, SunburstNodeHandlerProps, SunburstShape, SunburstSort, SunburstValueMode, } from '../sunburst/sunburst';
 export type XyShift = {
     x?: number;
     y?: number;
@@ -18,6 +23,12 @@ export type InitialRanges = {
     initial_y_range: Vec2;
     initial_y2_range: Vec2;
 };
+export type AxisRanges = {
+    x: Vec2;
+    x2: Vec2;
+    y: Vec2;
+    y2: Vec2;
+};
 export type Point<Metadata = Record<string, unknown>> = {
     x: number;
     y: number;
@@ -179,6 +190,16 @@ export interface ArcsinhScaleConfig {
     threshold?: number;
 }
 export type ScaleType = `linear` | `log` | `arcsinh` | `time` | ArcsinhScaleConfig;
+export type ColorScaleConfig = {
+    type?: ScaleType;
+    scheme?: D3ColorSchemeName | D3InterpolateName;
+    value_range?: Vec2;
+};
+export type SizeScaleConfig = {
+    type?: ScaleType;
+    radius_range?: Vec2;
+    value_range?: Vec2;
+};
 export declare const is_scale_type_name: (val: string) => val is ScaleTypeName;
 export declare function get_scale_type_name(scale_type: ScaleType | undefined): ScaleTypeName;
 export declare function get_arcsinh_threshold(scale_type: ScaleType | undefined): number;
@@ -374,8 +395,8 @@ export interface PlotConfig {
 export interface ControlsConfig {
     show?: boolean;
     open?: boolean;
-    toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`];
-    pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
+    toggle_props?: PaneToggleProps;
+    pane_props?: PaneProps;
 }
 export interface PanConfig {
     enabled?: boolean;
@@ -402,21 +423,17 @@ export interface PlotControlsProps extends PlotConfig {
     show_ticks?: boolean;
     controls_title?: string;
     controls_class?: string;
-    toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`];
-    pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
+    toggle_props?: PaneToggleProps;
+    pane_props?: PaneProps;
 }
 export interface BasePlotProps {
-    x_range?: [number | null, number | null];
-    x2_range?: [number | null, number | null];
-    y_range?: [number | null, number | null];
-    y2_range?: [number | null, number | null];
     range_padding?: number;
     padding?: Sides;
     hovered?: boolean;
     show_controls?: boolean;
     controls_open?: boolean;
-    controls_toggle_props?: ComponentProps<typeof DraggablePane>[`toggle_props`];
-    controls_pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
+    controls_toggle_props?: PaneToggleProps;
+    controls_pane_props?: PaneProps;
     fullscreen?: boolean;
     fullscreen_toggle?: boolean;
     change?: (data: Record<string, unknown> | null) => void;
@@ -435,7 +452,7 @@ export type Corner = (typeof CORNER_CELLS)[number];
 export declare const DEFAULT_GRID_STYLE: {
     readonly stroke: "var(--border-color, gray)";
     readonly 'stroke-dasharray': "4";
-    readonly 'stroke-width': "1";
+    readonly 'stroke-width': "0.5";
 };
 export declare const DEFAULT_MARKERS: "line+points";
 export declare const DEFAULT_SERIES_COLORS: readonly ["#4e79a7", "#f28e2c", "#e15759", "#76b7b2", "#59a14f", "#edc949", "#af7aa1", "#ff9da7", "#9c755f", "#bab0ab"];
@@ -544,6 +561,7 @@ export type FillBoundary = {
 } | {
     type: `data`;
     values: readonly number[];
+    x?: readonly number[];
 } | number;
 export interface FillGradient {
     type: `linear` | `radial`;
@@ -566,6 +584,8 @@ export interface FillHoverStyle {
     edge?: FillEdgeStyle;
     cursor?: string;
     scale?: number;
+    stroke?: string;
+    stroke_width?: number;
 }
 export interface FillHandlerEvent {
     event: MouseEvent | KeyboardEvent;
@@ -760,72 +780,3 @@ export type RefPlane = RefPlaneBase & ({
     p2: Vec3;
     p3: Vec3;
 });
-export interface OscillationWeights {
-    derivative_variance?: number;
-    amplitude_growth?: number;
-    sign_changes?: number;
-}
-export type InvalidValueMode = `remove` | `propagate` | `interpolate`;
-export type TruncationMode = `hard_cut` | `mark_unstable`;
-export interface PhysicalBounds {
-    min?: number | ((x: number) => number);
-    max?: number | ((x: number) => number);
-    mode?: `clamp` | `filter` | `null`;
-}
-export type SmoothingConfig = {
-    type: `moving_avg`;
-    window: number;
-} | {
-    type: `savgol`;
-    window: number;
-    polynomial_order?: number;
-} | {
-    type: `gaussian`;
-    sigma: number;
-};
-export interface LocalOutlierConfig {
-    window_half?: number;
-    mad_threshold?: number;
-    max_iterations?: number;
-}
-export interface LocalOutlierResult {
-    kept_indices: number[];
-    removed_indices: number[];
-    iterations_used: number;
-}
-export interface CleaningConfig {
-    oscillation_threshold?: number;
-    oscillation_weights?: OscillationWeights;
-    window_size?: number;
-    invalid_values?: InvalidValueMode;
-    bounds?: PhysicalBounds;
-    smooth?: SmoothingConfig;
-    local_outliers?: LocalOutlierConfig;
-    truncation_mode?: TruncationMode;
-    in_place?: boolean;
-}
-export interface CleaningQuality {
-    points_removed: number;
-    invalid_values_found: number;
-    oscillation_detected: boolean;
-    oscillation_score?: number;
-    bounds_violations: number;
-    outliers_removed?: number;
-    stable_range?: Vec2;
-    truncated_at_x?: number;
-}
-export interface CleaningResult<T = DataSeries> {
-    series: T;
-    quality: CleaningQuality;
-}
-export interface InstabilityResult {
-    detected: boolean;
-    onset_index: number;
-    onset_x: number;
-    combined_score: number;
-    method_scores: {
-        derivative_variance: number;
-        amplitude_growth: number;
-        sign_changes: number;
-    };
-}

package/dist/plot/{types.js → core/types.js}

@@ -51,7 +51,7 @@ export const CORNER_CELLS = [`top-left`, `top-right`, `bottom-left`, `bottom-rig
 export const DEFAULT_GRID_STYLE = {
     stroke: `var(--border-color, gray)`,
     'stroke-dasharray': `4`,
-    'stroke-width': `1`,
+    'stroke-width': `0.5`,
 };
 export const DEFAULT_MARKERS = `line+points`;
 // Default series colors for auto-differentiation (similar to d3 schemeTableau10)

package/dist/plot/{utils → core/utils}/label-placement.d.ts

@@ -1,5 +1,5 @@
-import type { Point2D } from '../../math';
-import type { AxisConfig, DataSeries } from '..';
+import type { Point2D } from '../../../math';
+import type { AxisConfig, DataSeries } from '../..';
 import type { PlotScaleFn } from '../scales';
 import type { LabelPlacementConfig, LabelPlacementWeights } from '../types';
 export interface Rect {
@@ -42,7 +42,7 @@ export interface LeaderLineOptions {
 }
 export declare function parse_font_size(size_str?: string): number;
 export declare function estimate_label_size(text: string, font_size_str?: string): LabelSize;
-export declare function rect_overlap_area(a: Rect, b: Rect): number;
+export declare function rect_overlap_area(rect_a: Rect, rect_b: Rect): number;
 export declare function rect_circle_overlap(rect: Rect, cx: number, cy: number, radius: number): number;
 export declare function segments_intersect(ax1: number, ay1: number, ax2: number, ay2: number, bx1: number, by1: number, bx2: number, by2: number): boolean;
 export declare function segment_rect_intersects(sx1: number, sy1: number, sx2: number, sy2: number, rect: Rect): boolean;

package/dist/plot/{utils → core/utils}/label-placement.js

@@ -34,9 +34,9 @@ export function estimate_label_size(text, font_size_str) {
     };
 }
 // === Geometry helpers ===
-export function rect_overlap_area(a, b) {
-    const ox = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x));
-    const oy = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));
+export function rect_overlap_area(rect_a, rect_b) {
+    const ox = Math.max(0, Math.min(rect_a.x + rect_a.w, rect_b.x + rect_b.w) - Math.max(rect_a.x, rect_b.x));
+    const oy = Math.max(0, Math.min(rect_a.y + rect_a.h, rect_b.y + rect_b.h) - Math.max(rect_a.y, rect_b.y));
     return ox * oy;
 }
 export function rect_circle_overlap(rect, cx, cy, radius) {

package/dist/plot/core/utils/series-visibility.d.ts

@@ -0,0 +1,26 @@
+type VisSeries = {
+    label?: string | null;
+    unit?: string;
+    y_axis?: string;
+    visible?: boolean;
+    x?: unknown;
+    y?: unknown;
+};
+type SeriesSource = [string, string, string, ...unknown[]];
+export type SeriesVisibilitySnapshot = {
+    visibility: boolean[];
+    source: SeriesSource[];
+};
+export declare function have_compatible_units(series1: VisSeries, series2: VisSeries): boolean;
+export declare function toggle_series_visibility<Series extends VisSeries>(series: Series[], series_idx: number): Series[];
+export declare function toggle_group_visibility<Series extends VisSeries>(series: Series[], series_indices: number[]): Series[];
+export declare function handle_legend_double_click<Series extends VisSeries>(series: Series[], idx: number, prev_snapshot: SeriesVisibilitySnapshot | null): {
+    series: Series[];
+    prev_visibility: SeriesVisibilitySnapshot | null;
+};
+export declare function create_legend_visibility<Series extends VisSeries>(get_series: () => Series[], set_series: (series: Series[]) => void): {
+    on_toggle: (series_idx: number) => void;
+    on_group_toggle: (group_name: string, series_indices: number[]) => void;
+    on_double_click: (series_idx: number) => void;
+};
+export {};

package/dist/plot/{utils → core/utils}/series-visibility.js

@@ -1,8 +1,20 @@
+// Length + first/last element: a by-value signature for x/y data. Deliberately NOT
+// array identity: inside components those are $state proxies whose identity changes
+// when the series prop is reassigned (e.g. by the isolate itself), which made the
+// snapshot reject itself and permanently broke restore-from-isolation.
+const data_sig = (arr) => Array.isArray(arr) ? [arr.length, arr[0], arr[arr.length - 1]] : [arr];
 const series_source = (series, length = series.length) => series
     .slice(0, length)
-    .map((srs) => [srs.label ?? ``, srs.unit ?? ``, srs.y_axis ?? ``, srs.x, srs.y]);
+    .map((srs) => [
+    srs.label ?? ``,
+    srs.unit ?? ``,
+    srs.y_axis ?? ``,
+    ...data_sig(srs.x),
+    ...data_sig(srs.y),
+]);
 const same_series_source = (series, snapshot_series) => series.length === snapshot_series.length &&
-    series.every((source, idx) => source.every((part, part_idx) => Object.is(part, snapshot_series[idx][part_idx])));
+    series.every((source, idx) => source.length === snapshot_series[idx].length &&
+        source.every((part, part_idx) => Object.is(part, snapshot_series[idx][part_idx])));
 export function have_compatible_units(series1, series2) {
     if (!series1.unit || !series2.unit)
         return true;
@@ -83,3 +95,18 @@ export function handle_legend_double_click(series, idx, prev_snapshot) {
         prev_visibility: new_prev,
     };
 }
+// Bundle the three legend visibility handlers (click toggle, group toggle,
+// double-click isolate/restore) around a series accessor pair. Owns the
+// isolate/restore snapshot internally so components don't each carry it.
+export function create_legend_visibility(get_series, set_series) {
+    let prev_visibility = null;
+    return {
+        on_toggle: (series_idx) => set_series(toggle_series_visibility(get_series(), series_idx)),
+        on_group_toggle: (_group_name, series_indices) => set_series(toggle_group_visibility(get_series(), series_indices)),
+        on_double_click: (series_idx) => {
+            const result = handle_legend_double_click(get_series(), series_idx, prev_visibility);
+            set_series(result.series);
+            prev_visibility = result.prev_visibility;
+        },
+    };
+}