matterviz 0.4.1 → 0.4.2

package/dist/plot/core/data-cleaning.js

@@ -1,402 +1,25 @@
 // Data cleaning utilities for plot data
-// Detects oscillations, enforces physical bounds, and handles multi-dimensional datasets
+// Enforces physical bounds, handles invalid values, and cleans multi-dimensional datasets.
+// Signal-processing primitives (variance, instability detection, smoothing, outlier removal)
+// live in ./data-cleaning-signal and are re-exported here so the public API is unchanged.
 import { apply_gaussian_smearing } from '../../spectral/helpers';
-// Default configuration values
-const DEFAULT_WINDOW_SIZE = 5;
-const DEFAULT_OSCILLATION_THRESHOLD = 3.0;
-const DEFAULT_POLYNOMIAL_ORDER = 2;
-// --- Core Detection Functions ---
-// Compute rolling variance using Welford's online algorithm - O(n)
-// Returns variance for each point based on surrounding window
-export function compute_local_variance(values, window_size) {
-    const len = values.length;
-    if (len === 0)
-        return [];
-    if (len === 1)
-        return [0];
-    const half_window = Math.floor(window_size / 2);
-    const result = Array(len);
-    // Single pass for each index, no slice allocation (avoids O(n × window) allocations)
-    for (let idx = 0; idx < len; idx++) {
-        const start = Math.max(0, idx - half_window);
-        const end = Math.min(len, idx + half_window + 1);
-        // Welford's online variance calculation
-        let [mean, m2, count] = [0, 0, 0];
-        for (let jdx = start; jdx < end; jdx++) {
-            const val = values[jdx];
-            if (!Number.isFinite(val))
-                continue;
-            count++;
-            const delta = val - mean;
-            mean += delta / count;
-            const delta2 = val - mean;
-            m2 += delta * delta2;
-        }
-        result[idx] = count > 1 ? m2 / (count - 1) : 0;
-    }
-    return result;
-}
-// Compute first-order finite differences (discrete derivative)
-function compute_derivatives(values) {
-    if (values.length < 2)
-        return [];
-    const derivs = Array(values.length - 1);
-    for (let idx = 0; idx < values.length - 1; idx++) {
-        derivs[idx] = values[idx + 1] - values[idx];
-    }
-    return derivs;
-}
-// Detect derivative variance spikes (method 1)
-// Returns onset index where derivative variance exceeds threshold
-function detect_derivative_variance(values, window_size, threshold_multiplier) {
-    const derivs = compute_derivatives(values);
-    if (derivs.length < window_size) {
-        return { onset_index: -1, score: 0 };
-    }
-    const local_var = compute_local_variance(derivs, window_size);
-    // Compute baseline variance from first stable portion
-    const baseline_end = Math.min(Math.floor(derivs.length / 4), 50);
-    const baseline_vars = local_var.slice(0, Math.max(baseline_end, window_size));
-    const baseline_median = median(baseline_vars.filter((val) => val > 0));
-    if (baseline_median === 0) {
-        return { onset_index: -1, score: 0 };
-    }
-    // Find first point where variance exceeds threshold
-    let max_score = 0;
-    for (let idx = baseline_end; idx < local_var.length; idx++) {
-        const ratio = local_var[idx] / baseline_median;
-        if (ratio > max_score)
-            max_score = ratio;
-        if (ratio > threshold_multiplier) {
-            return { onset_index: idx + 1, score: ratio }; // +1 to convert from deriv index to value index
-        }
-    }
-    return { onset_index: -1, score: max_score };
-}
-// Detect exponential amplitude growth (method 2)
-// Looks for values growing exponentially from their mean
-function detect_amplitude_growth(values, window_size) {
-    if (values.length < window_size * 3) {
-        return { onset_index: -1, score: 0 };
-    }
-    // Compute running amplitude (deviation from local mean)
-    const amplitudes = [];
-    const half_window = Math.floor(window_size / 2);
-    for (let idx = half_window; idx < values.length - half_window; idx++) {
-        const start = idx - half_window;
-        const end = idx + half_window + 1;
-        const window_len = end - start;
-        // Compute local mean without slice allocation
-        let sum = 0;
-        for (let jdx = start; jdx < end; jdx++)
-            sum += values[jdx];
-        const local_mean = sum / window_len;
-        // Find max deviation without slice allocation
-        let max_deviation = 0;
-        for (let jdx = start; jdx < end; jdx++) {
-            const deviation = Math.abs(values[jdx] - local_mean);
-            if (deviation > max_deviation)
-                max_deviation = deviation;
-        }
-        amplitudes.push(max_deviation);
-    }
-    if (amplitudes.length < 10) {
-        return { onset_index: -1, score: 0 };
-    }
-    // Detect exponential growth by checking if amplitude ratio increases
-    const baseline_amp = median(amplitudes.slice(0, Math.floor(amplitudes.length / 4)));
-    if (baseline_amp === 0) {
-        return { onset_index: -1, score: 0 };
-    }
-    let max_score = 0;
-    for (let idx = Math.floor(amplitudes.length / 4); idx < amplitudes.length; idx++) {
-        const ratio = amplitudes[idx] / baseline_amp;
-        if (ratio > max_score)
-            max_score = ratio;
-        // Exponential growth threshold: amplitude 10x baseline
-        if (ratio > 10) {
-            return { onset_index: idx + half_window, score: ratio / 10 };
-        }
-    }
-    return { onset_index: -1, score: max_score / 10 };
-}
-// Count derivative sign changes per window (method 3)
-// Detects high-frequency oscillations
-function detect_sign_change_frequency(values, window_size, max_changes_per_window = 3) {
-    const derivs = compute_derivatives(values);
-    if (derivs.length < window_size * 2) {
-        return { onset_index: -1, score: 0 };
-    }
-    // Count sign changes in sliding windows
-    const half_window = Math.floor(window_size / 2);
-    let max_score = 0;
-    for (let idx = half_window; idx < derivs.length - half_window; idx++) {
-        const start = idx - half_window;
-        const end = idx + half_window + 1;
-        let sign_changes = 0;
-        // Count sign changes without slice allocation
-        for (let jdx = start + 1; jdx < end; jdx++) {
-            if (derivs[jdx] * derivs[jdx - 1] < 0) {
-                sign_changes++;
-            }
-        }
-        const normalized_score = sign_changes / max_changes_per_window;
-        if (normalized_score > max_score)
-            max_score = normalized_score;
-        if (sign_changes > max_changes_per_window) {
-            return { onset_index: idx + 1, score: normalized_score };
-        }
-    }
-    return { onset_index: -1, score: max_score };
-}
-// Combined detection with configurable weights
-export function detect_instability(x_values, y_values, config = {}) {
-    const window_size = config.window_size ?? DEFAULT_WINDOW_SIZE;
-    const threshold = config.oscillation_threshold ?? DEFAULT_OSCILLATION_THRESHOLD;
-    const weights = {
-        derivative_variance: config.oscillation_weights?.derivative_variance ?? 1.0,
-        amplitude_growth: config.oscillation_weights?.amplitude_growth ?? 1.0,
-        sign_changes: config.oscillation_weights?.sign_changes ?? 1.0,
-    };
-    // Filter out invalid values for detection
-    const valid_indices = [];
-    const valid_y = [];
-    for (let idx = 0; idx < y_values.length; idx++) {
-        if (Number.isFinite(y_values[idx])) {
-            valid_indices.push(idx);
-            valid_y.push(y_values[idx]);
-        }
-    }
-    if (valid_y.length < window_size * 2) {
-        const method_scores = { derivative_variance: 0, amplitude_growth: 0, sign_changes: 0 };
-        const detected = false;
-        return { detected, onset_index: -1, onset_x: NaN, combined_score: 0, method_scores };
-    }
-    // Run all three detection methods
-    const deriv_result = detect_derivative_variance(valid_y, window_size, threshold);
-    const amp_result = detect_amplitude_growth(valid_y, window_size);
-    const sign_result = detect_sign_change_frequency(valid_y, window_size);
-    const method_scores = {
-        derivative_variance: deriv_result.score,
-        amplitude_growth: amp_result.score,
-        sign_changes: sign_result.score,
-    };
-    // Compute weighted combined score
-    const total_weight = weights.derivative_variance + weights.amplitude_growth + weights.sign_changes;
-    const combined_score = total_weight > 0
-        ? (weights.derivative_variance * deriv_result.score +
-            weights.amplitude_growth * amp_result.score +
-            weights.sign_changes * sign_result.score) /
-            total_weight
-        : 0;
-    // Find earliest onset across all methods that exceeded threshold
-    const onset_candidates = [
-        {
-            idx: deriv_result.onset_index,
-            score: deriv_result.score * weights.derivative_variance,
-        },
-        { idx: amp_result.onset_index, score: amp_result.score * weights.amplitude_growth },
-        { idx: sign_result.onset_index, score: sign_result.score * weights.sign_changes },
-    ].filter((candidate) => candidate.idx >= 0);
-    let onset_index = -1;
-    if (onset_candidates.length > 0) {
-        // Take earliest detected onset
-        onset_index = Math.min(...onset_candidates.map((candidate) => candidate.idx));
-        // Map back to original index if we filtered values
-        if (onset_index >= 0 && onset_index < valid_indices.length) {
-            onset_index = valid_indices[onset_index];
-        }
-    }
-    const detected = combined_score >= threshold || onset_index >= 0;
-    const onset_x = onset_index >= 0 && onset_index < x_values.length ? x_values[onset_index] : NaN;
-    return { detected, onset_index, onset_x, combined_score, method_scores };
-}
-// --- Smoothing Functions ---
-// Moving average - O(n)
-export function smooth_moving_average(values, window) {
-    if (values.length === 0 || window <= 1)
-        return [...values];
-    const result = Array(values.length);
-    const half_window = Math.floor(window / 2);
-    for (let idx = 0; idx < values.length; idx++) {
-        const start = Math.max(0, idx - half_window);
-        const end = Math.min(values.length, idx + half_window + 1);
-        let [sum, count] = [0, 0];
-        for (let jdx = start; jdx < end; jdx++) {
-            if (Number.isFinite(values[jdx])) {
-                sum += values[jdx];
-                count++;
-            }
-        }
-        result[idx] = count > 0 ? sum / count : values[idx];
-    }
-    return result;
-}
-// Savitzky-Golay filter coefficients for polynomial smoothing
-// Uses least-squares polynomial fitting in each window
-function compute_savgol_coefficients(window, order) {
-    // Ensure window is odd
-    const half = Math.floor(window / 2);
-    const size = 2 * half + 1;
-    // Build Vandermonde matrix for polynomial fitting
-    const vandermonde = [];
-    for (let idx = -half; idx <= half; idx++) {
-        const row = [];
-        for (let power = 0; power <= order; power++) {
-            row.push(idx ** power);
-        }
-        vandermonde.push(row);
-    }
-    // Compute (V^T V)^-1 V^T using simple pseudoinverse
-    // For smoothing, we only need the first row (constant term coefficients)
-    const vtv = multiply_matrices(transpose(vandermonde), vandermonde);
-    const vtv_inv = invert_matrix(vtv);
-    if (!vtv_inv) {
-        // Fallback to uniform weights
-        return Array(size).fill(1 / size);
-    }
-    const vt = transpose(vandermonde);
-    const coeffs_matrix = multiply_matrices(vtv_inv, vt);
-    // First row gives smoothing coefficients
-    return coeffs_matrix[0];
-}
-// Savitzky-Golay filter (derivative-preserving) - O(n * window)
-export function smooth_savitzky_golay(values, window, polynomial_order = DEFAULT_POLYNOMIAL_ORDER) {
-    if (values.length === 0)
-        return [];
-    // Ensure window is odd and >= polynomial_order + 1
-    let actual_window = window % 2 === 0 ? window + 1 : window;
-    actual_window = Math.max(actual_window, polynomial_order + 2);
-    actual_window = Math.min(actual_window, values.length);
-    if (actual_window < 3)
-        return [...values];
-    const coeffs = compute_savgol_coefficients(actual_window, polynomial_order);
-    const half = Math.floor(actual_window / 2);
-    const result = Array(values.length);
-    // Cache coefficient sum to avoid O(n × window) redundant reductions in loop
-    const coeffs_sum = coeffs.reduce((sum, coeff) => sum + coeff, 0);
-    for (let idx = 0; idx < values.length; idx++) {
-        let [sum, weight_sum] = [0, 0];
-        for (let jdx = 0; jdx < actual_window; jdx++) {
-            const data_idx = idx - half + jdx;
-            if (data_idx >= 0 && data_idx < values.length && Number.isFinite(values[data_idx])) {
-                sum += coeffs[jdx] * values[data_idx];
-                weight_sum += coeffs[jdx];
-            }
-        }
-        result[idx] = weight_sum !== 0 ? (sum / weight_sum) * coeffs_sum : values[idx];
-    }
-    return result;
-}
+import { detect_instability, remove_local_outliers, smooth_moving_average, smooth_savitzky_golay, } from './data-cleaning-signal';
+export * from './data-cleaning-signal';
 // Apply smoothing based on config
 function apply_smoothing(x_values, y_values, config) {
     if (config.type === `moving_avg`) {
         return smooth_moving_average(y_values, config.window);
     }
     else if (config.type === `savgol`) {
-        return smooth_savitzky_golay(y_values, config.window, config.polynomial_order ?? DEFAULT_POLYNOMIAL_ORDER);
+        // pass polynomial_order through: when it's undefined, smooth_savitzky_golay's
+        // default parameter applies (JS defaults also kick in for an explicit undefined)
+        return smooth_savitzky_golay(y_values, config.window, config.polynomial_order);
     }
     else if (config.type === `gaussian`) {
         return apply_gaussian_smearing(x_values, y_values, config.sigma);
     }
     return y_values;
 }
-// --- Local Outlier Detection ---
-// Default values for local outlier detection
-const DEFAULT_LOCAL_WINDOW_HALF = 7;
-const DEFAULT_LOCAL_MAD_THRESHOLD = 2.0;
-const DEFAULT_LOCAL_MAX_ITERATIONS = 5;
-// Compute local median within a window, excluding the center point
-// This allows detecting if the center point is an outlier relative to its neighbors
-function compute_local_median_excluding_center(values, center_idx, window_half) {
-    const window_values = [];
-    const start = Math.max(0, center_idx - window_half);
-    const end = Math.min(values.length - 1, center_idx + window_half);
-    for (let idx = start; idx <= end; idx++) {
-        if (idx !== center_idx && Number.isFinite(values[idx])) {
-            window_values.push(values[idx]);
-        }
-    }
-    if (window_values.length === 0)
-        return values[center_idx];
-    return median(window_values);
-}
-// Compute local MAD (median absolute deviation) within a window, excluding center
-function compute_local_mad_excluding_center(values, center_idx, window_half, local_median) {
-    const abs_devs = [];
-    const start = Math.max(0, center_idx - window_half);
-    const end = Math.min(values.length - 1, center_idx + window_half);
-    for (let idx = start; idx <= end; idx++) {
-        if (idx !== center_idx && Number.isFinite(values[idx])) {
-            abs_devs.push(Math.abs(values[idx] - local_median));
-        }
-    }
-    if (abs_devs.length === 0)
-        return 0;
-    return median(abs_devs);
-}
-// Remove local outliers using iterative sliding window MAD-based detection
-// Detects points that deviate significantly from their local neighborhood
-// Returns only the indices to keep, preserving good data before AND after bad regions
-export function remove_local_outliers(y_values, config = {}) {
-    const window_half = config.window_half ?? DEFAULT_LOCAL_WINDOW_HALF;
-    const mad_threshold = config.mad_threshold ?? DEFAULT_LOCAL_MAD_THRESHOLD;
-    const max_iterations = config.max_iterations ?? DEFAULT_LOCAL_MAX_ITERATIONS;
-    const len = y_values.length;
-    if (len === 0) {
-        return { kept_indices: [], removed_indices: [], iterations_used: 0 };
-    }
-    // Need enough neighbors for meaningful local statistics
-    const min_points_needed = window_half * 2 + 1;
-    if (len < min_points_needed) {
-        return {
-            kept_indices: Array.from({ length: len }, (_, idx) => idx),
-            removed_indices: [],
-            iterations_used: 0,
-        };
-    }
-    let kept_mask = Array(len).fill(true);
-    let iterations_used = 0;
-    for (let iter = 0; iter < max_iterations; iter++) {
-        let removed_any = false;
-        const new_kept_mask = [...kept_mask];
-        // Note: Local statistics are computed from original values, not filtered values.
-        // This prevents cascading removals where one outlier's removal dramatically
-        // shifts statistics and causes false positives on neighboring points.
-        for (let idx = 0; idx < len; idx++) {
-            if (!kept_mask[idx])
-                continue; // Already removed
-            if (!Number.isFinite(y_values[idx]))
-                continue; // Skip invalid values
-            const local_median = compute_local_median_excluding_center(y_values, idx, window_half);
-            const local_mad = compute_local_mad_excluding_center(y_values, idx, window_half, local_median);
-            // Cannot compute robust threshold if MAD is zero (all neighbors identical)
-            if (local_mad === 0)
-                continue;
-            const threshold = local_mad * mad_threshold;
-            const deviation = Math.abs(y_values[idx] - local_median);
-            if (deviation > threshold) {
-                new_kept_mask[idx] = false;
-                removed_any = true;
-            }
-        }
-        kept_mask = new_kept_mask;
-        iterations_used = iter + 1;
-        if (!removed_any)
-            break;
-    }
-    const kept_indices = [];
-    const removed_indices = [];
-    for (let idx = 0; idx < len; idx++) {
-        if (kept_mask[idx]) {
-            kept_indices.push(idx);
-        }
-        else {
-            removed_indices.push(idx);
-        }
-    }
-    return { kept_indices, removed_indices, iterations_used };
-}
 // --- Helper Functions ---
 // Handle NaN/Infinity based on mode
 export function handle_invalid_values(values, mode) {
@@ -461,20 +84,19 @@ export function apply_bounds(x_values, y_values, bounds) {
     for (let idx = 0; idx < result.length; idx++) {
         const x_val = x_values[idx];
         const y_val = result[idx];
-        const min_bound = typeof bounds.min === `function` ? bounds.min(x_val) : bounds.min;
-        const max_bound = typeof bounds.max === `function` ? bounds.max(x_val) : bounds.max;
-        let violated = false;
-        if (min_bound !== undefined && y_val < min_bound)
-            violated = true;
-        if (max_bound !== undefined && y_val > max_bound)
-            violated = true;
-        if (violated) {
+        // Resolve bounds once per point; is_in_bounds would redundantly re-resolve them
+        // (costly when min/max are functions of x). NaN compares false on both checks
+        // and thus counts as in-bounds, matching is_in_bounds semantics.
+        const { min: min_bound, max: max_bound } = resolve_physical_bounds(x_val, bounds);
+        const below_min = min_bound !== undefined && y_val < min_bound;
+        const above_max = max_bound !== undefined && y_val > max_bound;
+        if (below_min || above_max) {
             violations++;
             const mode = bounds.mode ?? `clamp`;
             if (mode === `clamp`) {
-                if (min_bound !== undefined && y_val < min_bound)
+                if (below_min)
                     result[idx] = min_bound;
-                if (max_bound !== undefined && y_val > max_bound)
+                if (above_max)
                     result[idx] = max_bound;
             }
             else if (mode === `filter`) {
@@ -497,10 +119,17 @@ export function sync_metadata(metadata, kept_indices) {
 }
 // Filter arrays by kept indices
 const filter_by_indices = (arr, kept_indices) => kept_indices.map((idx) => arr[idx]);
-// Check if value is within bounds (static or x-dependent)
+// Resolve static or x-dependent min/max bounds at a given x value
+function resolve_physical_bounds(x_val, bounds) {
+    return {
+        min: typeof bounds.min === `function` ? bounds.min(x_val) : bounds.min,
+        max: typeof bounds.max === `function` ? bounds.max(x_val) : bounds.max,
+    };
+}
+// Check if value is within bounds (static or x-dependent).
+// NB: NaN values compare false on both checks and therefore count as in-bounds.
 function is_in_bounds(val, x_val, bounds) {
-    const min = typeof bounds.min === `function` ? bounds.min(x_val) : bounds.min;
-    const max = typeof bounds.max === `function` ? bounds.max(x_val) : bounds.max;
+    const { min, max } = resolve_physical_bounds(x_val, bounds);
     if (min !== undefined && val < min)
         return false;
     if (max !== undefined && val > max)
@@ -775,79 +404,3 @@ export function clean_trajectory_props(props, config = {}) {
     }
     return { props: result_props, quality: quality_reports };
 }
-// --- Utility Functions ---
-function median(values) {
-    if (values.length === 0)
-        return 0;
-    const sorted = [...values].sort((a, b) => a - b);
-    const mid = Math.floor(sorted.length / 2);
-    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
-}
-// Simple matrix operations for Savitzky-Golay
-function transpose(matrix) {
-    if (matrix.length === 0)
-        return [];
-    const rows = matrix.length;
-    const cols = matrix[0].length;
-    const result = Array.from({ length: cols }, () => Array(rows).fill(0));
-    for (let row = 0; row < rows; row++) {
-        for (let col = 0; col < cols; col++) {
-            result[col][row] = matrix[row][col];
-        }
-    }
-    return result;
-}
-function multiply_matrices(matrix_a, matrix_b) {
-    const rows_a = matrix_a.length;
-    const cols_a = matrix_a[0]?.length ?? 0;
-    const cols_b = matrix_b[0]?.length ?? 0;
-    const result = Array.from({ length: rows_a }, () => Array(cols_b).fill(0));
-    for (let row = 0; row < rows_a; row++) {
-        for (let col = 0; col < cols_b; col++) {
-            for (let idx_k = 0; idx_k < cols_a; idx_k++) {
-                result[row][col] += matrix_a[row][idx_k] * matrix_b[idx_k][col];
-            }
-        }
-    }
-    return result;
-}
-function invert_matrix(matrix) {
-    const size = matrix.length;
-    if (size === 0 || matrix[0].length !== size)
-        return null;
-    // Create augmented matrix [A | I]
-    const aug = matrix.map((row, idx) => [
-        ...row,
-        ...Array.from({ length: size }, (_, jdx) => (idx === jdx ? 1 : 0)),
-    ]);
-    // Gaussian elimination with partial pivoting
-    for (let col = 0; col < size; col++) {
-        // Find pivot
-        let max_row = col;
-        for (let row = col + 1; row < size; row++) {
-            if (Math.abs(aug[row][col]) > Math.abs(aug[max_row][col])) {
-                max_row = row;
-            }
-        }
-        if (Math.abs(aug[max_row][col]) < 1e-10) {
-            return null; // Singular
-        } // Swap rows
-        ;
-        [aug[col], aug[max_row]] = [aug[max_row], aug[col]];
-        // Eliminate column
-        const pivot = aug[col][col];
-        for (let jdx = 0; jdx < 2 * size; jdx++) {
-            aug[col][jdx] /= pivot;
-        }
-        for (let row = 0; row < size; row++) {
-            if (row !== col) {
-                const factor = aug[row][col];
-                for (let jdx = 0; jdx < 2 * size; jdx++) {
-                    aug[row][jdx] -= factor * aug[col][jdx];
-                }
-            }
-        }
-    }
-    // Extract inverse
-    return aug.map((row) => row.slice(size));
-}

package/dist/plot/core/data-transform.js

@@ -6,11 +6,15 @@ export const get_series_color = (series_idx) => DEFAULT_SERIES_COLORS[series_idx
 export const get_series_symbol = (series_idx) => DEFAULT_SERIES_SYMBOLS[series_idx % DEFAULT_SERIES_SYMBOLS.length];
 // Extract the primary color from a series data object.
 // Checks line stroke, then point fill (handling arrays), with fallback to default blue.
-export const extract_series_color = (series_data) => (series_data.line_style?.stroke ??
-    (Array.isArray(series_data.point_style)
-        ? series_data.point_style[0]?.fill
-        : series_data.point_style?.fill)) || // oxlint-disable-line @typescript-eslint/prefer-nullish-coalescing -- empty fill should use default color
-    `#4A9EFF`;
+export const extract_series_color = (series_data) => {
+    const color = series_data.line_style?.stroke ??
+        (Array.isArray(series_data.point_style)
+            ? series_data.point_style[0]?.fill
+            : series_data.point_style?.fill);
+    if (color)
+        return color;
+    return DEFAULTS.scatter.point.color;
+};
 // Prepare legend data from series array
 export const prepare_legend_data = (series) => series.map((series_data, series_idx) => ({
     series_idx,

package/dist/plot/core/fill-utils.d.ts

@@ -1,5 +1,6 @@
 import type { Vec2 } from '../../math';
-import type { DataSeries, ErrorBand, FillBoundary, FillCurveType, FillGradient, FillRegion } from './types';
+import type { CurveFactory } from 'd3-shape';
+import type { DataSeries, ErrorBand, FillBoundary, FillCurveType, FillGradient, FillRegion, LineCurve } from './types';
 export declare const LOG_EPSILON = 1e-10;
 export interface Pt {
     x: number;
@@ -28,6 +29,7 @@ interface DomainContext {
 }
 export declare function resolve_boundary_points(boundary: FillBoundary, series: readonly DataSeries[], domains: DomainContext, companion?: Pt[] | null): ResolvedBoundary | null;
 export declare function compute_fill_segments(region: FillRegion, series: readonly DataSeries[], domains: DomainContext): FillSegment[];
+export declare const line_curve_factory: (curve: LineCurve | undefined) => CurveFactory;
 export declare function generate_fill_path(upper: readonly Pt[], lower: readonly Pt[], upper_curve?: FillCurveType, lower_curve?: FillCurveType): string;
 export declare function convert_error_band_to_fill_region(error_band: ErrorBand, series: readonly DataSeries[], default_color?: string): FillRegion | null;
 export declare const is_fill_gradient: (fill: string | FillGradient | undefined) => fill is FillGradient;

package/dist/plot/core/fill-utils.js

@@ -1,8 +1,9 @@
 // Fill-between utility functions for ScatterPlot fill regions
 // Each fill edge is traced through its boundary's own points with the same curve the series line
-// uses (curveMonotoneX), so an unclipped fill edge coincides with the line it borders. When an
-// edge is clipped (x_range / partial overlap), the inserted endpoint shifts the neighboring
-// monotone tangent, so the clipped edge can deviate sub-pixel from the full series line.
+// uses (a series edge inherits the series' `line_style.curve`, default monotoneX), so an unclipped
+// fill edge coincides with the line it borders. When an edge is clipped (x_range / partial
+// overlap), inserted endpoints are evaluated on a monotone-cubic approximation: sub-pixel for
+// monotoneX/linear/step, but natural/basis/catmullRom edges can deviate more at the clip points.
 import { curveBasis, curveCardinal, curveCatmullRom, curveLinear, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, line, } from 'd3-shape';
 // Epsilon value for log scale clamping (to avoid log(0) = -Infinity)
 export const LOG_EPSILON = 1e-10;
@@ -145,6 +146,19 @@ const finite_points = (xs, ys) => clean_pts(Array.from({ length: Math.min(xs.len
     x: xs[idx],
     y: ys[idx],
 })));
+// Bridge the public LineCurve vocabulary (series `line_style.curve`) to FillCurveType names so
+// a series fill edge traces with the same curve as its rendered line. Default: monotoneX.
+const LINE_CURVE_TO_FILL = {
+    linear: `linear`,
+    monotone: `monotoneX`,
+    natural: `natural`,
+    step: `step`,
+    basis: `basis`,
+    'catmull-rom': `catmullRom`,
+};
+const line_curve_to_fill = (curve) => 
+// ?? monotoneX guards an unknown string from an untyped (Python/JSON) caller
+(curve ? LINE_CURVE_TO_FILL[curve] : undefined) ?? `monotoneX`;
 // Resolve a boundary to native points + curve in data coordinates. `companion` supplies x
 // positions for boundaries that don't define their own (constant/axis/function/data-without-x).
 export function resolve_boundary_points(boundary, series, domains, companion) {
@@ -157,15 +171,16 @@ export function resolve_boundary_points(boundary, series, domains, companion) {
         points: horizontal(span_xs, y),
         curve: `linear`,
     });
-    // series / function / data edges are traced with monotoneX (matches the series line)
-    const curved_edge = (points) => points.length > 0 ? { points, curve: `monotoneX` } : null;
+    // function / data edges trace with monotoneX by default; a series edge inherits the
+    // series' own line curve so the fill border coincides with the rendered line
+    const curved_edge = (points, curve = `monotoneX`) => (points.length > 0 ? { points, curve } : null);
     if (typeof boundary === `number`)
         return flat_edge(boundary);
     if (boundary.type === `series`) {
         const resolved = resolve_series_ref(boundary, series);
         if (!resolved)
             return null;
-        return curved_edge(finite_points(resolved.x, resolved.y));
+        return curved_edge(finite_points(resolved.x, resolved.y), line_curve_to_fill(resolved.line_style?.curve));
     }
     if (boundary.type === `constant`)
         return flat_edge(boundary.value);
@@ -345,6 +360,10 @@ const CURVE_MAP = {
     natural: curveNatural,
 };
 const get_curve = (curve_type) => CURVE_MAP[curve_type] ?? curveMonotoneX;
+// Resolve a public LineCurve (a series' `line_style.curve`) to its d3 CurveFactory. Single source
+// of truth shared by Line.svelte and PlotMarginals.svelte (composes the LineCurve -> FillCurveType
+// -> CurveFactory maps); unknown/undefined falls back to curveMonotoneX.
+export const line_curve_factory = (curve) => get_curve(line_curve_to_fill(curve));
 const trace = (points, curve_type) => line()
     .x((pt) => pt.x)
     .y((pt) => pt.y)
@@ -378,6 +397,9 @@ export function convert_error_band_to_fill_region(error_band, series, default_co
     return {
         id: error_band.id,
         label: error_band.label,
+        // band edges are data boundaries (default monotoneX); inherit the central series' line
+        // curve so the band traces with the same curve as the line it brackets
+        curve: line_curve_to_fill(resolved.line_style?.curve),
         upper: { type: `data`, x, values: y.map((val, idx) => val + upper_err[idx]) },
         lower: { type: `data`, x, values: y.map((val, idx) => val - lower_err[idx]) },
         fill: error_band.fill ?? default_color ?? `#4e79a7`,

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

@@ -3,6 +3,7 @@ export * from './data-cleaning';
 export * from './fill-utils';
 export * from './interactions';
 export * from './layout';
+export * from './marginals';
 export * from './reference-line';
 export * from './scales';
 export * from './svg';

package/dist/plot/core/index.js

@@ -4,6 +4,7 @@ export * from './data-cleaning';
 export * from './fill-utils';
 export * from './interactions';
 export * from './layout';
+export * from './marginals';
 export * from './reference-line';
 export * from './scales';
 export * from './svg';