matterviz 0.4.0 → 0.4.2

package/dist/trajectory/parse/xyz.d.ts

@@ -1,26 +1,14 @@
-import type { ElementSymbol } from '../../element/types';
-import * as math from '../../math';
-import type { TrajectoryType } from '../index';
-export declare function parse_extxyz_columns(comment: string): {
-    species_col: number;
-    pos_col: number;
-    forces_col: number;
-    min_cols: number;
-};
-export declare function parse_extxyz_lattice(comment: string): math.Matrix3x3 | undefined;
+import type { TrajectoryFrame, TrajectoryType } from '../index';
 export declare function parse_xyz_comment_metadata(comment: string): {
     step?: number;
     properties: Record<string, number>;
 };
-type ForceStats = {
-    forces: number[][];
-    force_max: number;
-    force_norm: number;
-};
-export declare function parse_xyz_atom_lines(lines: string[], start: number, num_atoms: number, comment: string, frame_label: string): {
-    elements: ElementSymbol[];
-    positions: number[][];
-    force_stats: ForceStats | null;
-};
+export declare function build_xyz_frame(lines: string[], frame: {
+    start: number;
+    num_atoms: number;
+    comment: string;
+}, opts: {
+    frame_label: string;
+    default_step: number;
+}): TrajectoryFrame;
 export declare function parse_xyz_trajectory(content: string): TrajectoryType;
-export {};

package/dist/trajectory/parse/xyz.js

@@ -1,15 +1,17 @@
 import * as math from '../../math';
-import { coerce_element_symbol, create_trajectory_frame } from '../helpers';
+import { coerce_elem_symbol } from '../../element/helpers';
+import { calc_force_stats, create_trajectory_frame, iter_xyz_frames, } from '../helpers';
+import { traj_warn } from './diagnostics';
 // Resolve species/pos/forces column offsets from an extxyz Properties string of
 // name:type:ncols triples (e.g. "species:S:1:pos:R:3:forces:R:3"), falling back
 // to the conventional "symbol x y z" layout when absent or malformed
-export function parse_extxyz_columns(comment) {
-    const fields = /Properties\s*=\s*"?([^"\s]+)"?/i.exec(comment)?.[1].split(`:`) ?? [];
+function parse_extxyz_columns(comment) {
+    const fields = /Properties\s*=\s*"?(?<properties>[^"\s]+)"?/i.exec(comment)?.[1].split(`:`) ?? [];
     // Well-formed Properties is name:type:ncols triples; a non-multiple of 3 is malformed,
     // so bail to the conventional default rather than trusting a partial layout
     let layout = fields.length % 3 === 0 ? {} : null;
     for (let idx = 0, offset = 0; layout && idx + 3 <= fields.length; idx += 3) {
-        const ncols = parseInt(fields[idx + 2], 10);
+        const ncols = Math.trunc(Number(fields[idx + 2]));
         if (Number.isInteger(ncols) && ncols > 0) {
             layout[fields[idx].toLowerCase()] = { offset, ncols };
             offset += ncols;
@@ -23,8 +25,12 @@ export function parse_extxyz_columns(comment) {
     return { species_col, pos_col, forces_col, min_cols: Math.max(pos_col + 3, species_col + 1) };
 }
 // Parse Lattice="ax ay az bx by bz cx cy cz" from an extxyz comment line
-export function parse_extxyz_lattice(comment) {
-    const vals = /Lattice\s*=\s*"([^"]+)"/i.exec(comment)?.[1].trim().split(/\s+/).map(Number);
+function parse_extxyz_lattice(comment) {
+    const vals = /Lattice\s*=\s*"(?<lattice>[^"]+)"/i
+        .exec(comment)?.[1]
+        .trim()
+        .split(/\s+/)
+        .map(Number);
     if (vals?.length !== 9 || !vals.every(Number.isFinite))
         return undefined;
     return [vals.slice(0, 3), vals.slice(3, 6), vals.slice(6, 9)];
@@ -45,15 +51,15 @@ export function parse_xyz_comment_metadata(comment) {
     for (const [key, pattern] of Object.entries(METADATA_PATTERNS)) {
         const match = pattern.exec(comment);
         if (match)
-            properties[key] = parseFloat(match[1]);
+            properties[key] = Number(match[1]);
     }
-    const step = /(?:^|\s)(?:step|frame|ionic_step)\s*[=:]?\s*(\d+)/i.exec(comment)?.[1];
-    return { step: step ? parseInt(step, 10) : undefined, properties };
+    const step = /(?:^|\s)(?:step|frame|ionic_step)\s*[=:]?\s*(?<step>\d+)/i.exec(comment)?.[1];
+    return { step: step ? Math.trunc(Number(step)) : undefined, properties };
 }
 // Parse num_atoms atom lines starting at lines[start], reading species/pos/forces from
 // their Properties-declared column offsets; invalid atoms are skipped with a warning.
 // force_stats holds raw forces plus max and RMS force magnitudes when forces are present.
-export function parse_xyz_atom_lines(lines, start, num_atoms, comment, frame_label) {
+function parse_xyz_atom_lines(lines, start, num_atoms, comment, frame_label) {
     const { species_col, pos_col, forces_col, min_cols } = parse_extxyz_columns(comment);
     const elements = [];
     const positions = [];
@@ -64,13 +70,13 @@ export function parse_xyz_atom_lines(lines, start, num_atoms, comment, frame_lab
             continue;
         const pos = parts.slice(pos_col, pos_col + 3).map(parseFloat);
         if (!pos.every(Number.isFinite)) {
-            console.warn(`Skipping XYZ atom with invalid coordinates in ${frame_label} at line ${start + idx + 1}`);
+            traj_warn(`Skipping XYZ atom with invalid coordinates in ${frame_label} at line ${start + idx + 1}`);
             continue;
         }
         const symbol = parts[species_col];
-        const element_symbol = coerce_element_symbol(symbol);
+        const element_symbol = coerce_elem_symbol(symbol);
         if (!element_symbol) {
-            console.warn(`Skipping XYZ atom with unknown element symbol "${symbol}" in ${frame_label}`);
+            traj_warn(`Skipping XYZ atom with unknown element symbol "${symbol}" in ${frame_label}`);
             continue;
         }
         elements.push(element_symbol);
@@ -81,36 +87,29 @@ export function parse_xyz_atom_lines(lines, start, num_atoms, comment, frame_lab
                 forces.push(force_vec);
         }
     }
-    if (forces.length === 0)
-        return { elements, positions, force_stats: null };
-    const mags = forces.map((force) => Math.hypot(...force));
-    const force_norm = Math.sqrt(mags.reduce((sum, mag) => sum + mag ** 2, 0) / mags.length);
-    return {
-        elements,
-        positions,
-        force_stats: { forces, force_max: Math.max(...mags), force_norm },
-    };
+    const stats = calc_force_stats(forces);
+    return { elements, positions, force_stats: stats && { forces, ...stats } };
+}
+// Assemble a TrajectoryFrame from the XYZ frame starting at lines[start] (count line,
+// comment line, atom lines). Shared by the eager parser and the indexed frame reader.
+export function build_xyz_frame(lines, frame, opts) {
+    const { start, num_atoms, comment } = frame;
+    const { step, properties } = parse_xyz_comment_metadata(comment);
+    const lattice_matrix = parse_extxyz_lattice(comment);
+    const { elements, positions, force_stats } = parse_xyz_atom_lines(lines, start + 2, num_atoms, comment, opts.frame_label);
+    const metadata = { ...properties, ...force_stats };
+    if (lattice_matrix)
+        metadata.volume = math.calc_lattice_params(lattice_matrix).volume;
+    return create_trajectory_frame(positions, elements, lattice_matrix, lattice_matrix ? [true, true, true] : undefined, step ?? opts.default_step, metadata);
 }
 export function parse_xyz_trajectory(content) {
     const lines = content.trim().split(/\r?\n/);
     const frames = [];
-    let line_idx = 0;
-    while (line_idx < lines.length) {
-        const num_atoms = parseInt(lines[line_idx].trim(), 10);
-        if (isNaN(num_atoms) || num_atoms <= 0 || line_idx + num_atoms + 1 >= lines.length) {
-            line_idx++; // skip blank/invalid lines until the next frame's atom-count line
-            continue;
-        }
-        const comment = lines[line_idx + 1] || ``;
-        const { step, properties } = parse_xyz_comment_metadata(comment);
-        const metadata = { ...properties };
-        const lattice_matrix = parse_extxyz_lattice(comment);
-        if (lattice_matrix)
-            metadata.volume = math.calc_lattice_params(lattice_matrix).volume;
-        const { elements, positions, force_stats } = parse_xyz_atom_lines(lines, line_idx + 2, num_atoms, comment, `frame ${frames.length}`);
-        Object.assign(metadata, force_stats);
-        frames.push(create_trajectory_frame(positions, elements, lattice_matrix, lattice_matrix ? [true, true, true] : undefined, step ?? frames.length, metadata));
-        line_idx += num_atoms + 2;
+    for (const frame of iter_xyz_frames(lines)) {
+        frames.push(build_xyz_frame(lines, frame, {
+            frame_label: `frame ${frames.length}`,
+            default_step: frames.length,
+        }));
     }
     return {
         frames,

package/dist/trajectory/plotting.d.ts

@@ -1,25 +1,23 @@
-import type { DataSeries } from '../plot/core/types';
+import { type TrajPropertyConfig } from '../labels';
+import type { DataSeries, ScaleType } from '../plot/core/types';
 import type { TrajectoryDataExtractor, TrajectoryMetadata, TrajectoryType } from './index';
 export interface PlotSeriesOptions {
-    property_config?: Record<string, {
-        label: string;
-        unit: string;
-    }>;
+    property_config?: Record<string, TrajPropertyConfig>;
     colors?: readonly string[];
     default_visible_properties?: Set<string>;
 }
 export declare function generate_plot_series(trajectory: TrajectoryType, data_extractor: TrajectoryDataExtractor, options?: PlotSeriesOptions): DataSeries[];
-export declare function toggle_series_visibility(series: DataSeries[], target_series_idx: number): DataSeries[];
 export declare function should_hide_plot(trajectory: TrajectoryType | undefined, plot_series: DataSeries[], tolerance?: number): boolean;
 export declare function generate_axis_labels(plot_series: DataSeries[]): {
     y1: string;
     y2: string;
 };
+export declare function generate_axis_scale_types(plot_series: DataSeries[]): {
+    y1: ScaleType;
+    y2: ScaleType;
+};
 interface StreamingPlotOptions {
-    property_config?: Record<string, {
-        label: string;
-        unit: string;
-    }>;
+    property_config?: Record<string, TrajPropertyConfig>;
     colors?: readonly string[];
     default_visible_properties?: Set<string>;
     max_points?: number;

package/dist/trajectory/plotting.js

@@ -1,19 +1,51 @@
 // Plotting utilities for trajectory visualization
 import { PLOT_COLORS } from '../colors';
-import { trajectory_property_config } from '../labels';
+import { SCF_AXIS_GROUP, trajectory_property_config, } from '../labels';
 import { get_coefficient_of_variation } from '../math';
 // Configuration constants
 const ENERGY_UNITS = [`eV`, `eV/atom`, `hartree`, `kcal/mol`, `kJ/mol`];
 const ENERGY_PROPERTIES = [`energy`, `total_energy`, `potential_energy`];
 const FORCE_PROPERTIES = [`force`, `fmax`, `f`];
-const DEFAULT_VISIBLE = new Set([`energy`, `force_max`, `stress_frobenius`]);
+// scf_energy_delta lives in its own axis group (see trajectory_property_config), so
+// listing it here only surfaces it when higher-priority groups (energy/force/stress)
+// don't fill both axes — i.e. single-point SCF convergence views.
+const DEFAULT_VISIBLE = new Set([
+    `energy`,
+    `force_max`,
+    `stress_frobenius`,
+    `scf_energy_delta`,
+]);
+// Shared per-series line/point styling derived from a single color
+const series_color_styles = (color) => ({
+    line_style: { stroke: color, stroke_width: 2 },
+    point_style: { fill: color, stroke: color, stroke_width: 1 },
+});
+// Cache the per-frame walk per trajectory so re-renders that only change visible_properties or
+// labels/config reuse it (legend toggles mutate plot_series directly and skip regeneration, so they
+// don't hit this). Keyed by trajectory identity (WeakMap auto-evicts) and invalidated on extractor
+// or frame identity changes.
+const same_frames = (cached_frames, current_frames) => cached_frames.length === current_frames.length &&
+    cached_frames.every((frame, frame_idx) => frame === current_frames[frame_idx]);
+const stats_cache = new WeakMap();
 // Unified property extraction and series generation
 export function generate_plot_series(trajectory, data_extractor, options = {}) {
     if (!trajectory?.frames?.length)
         return [];
     const { property_config = trajectory_property_config, colors = PLOT_COLORS, default_visible_properties = DEFAULT_VISIBLE, } = options;
-    // Single-pass data extraction with variance detection
-    const property_stats = extract_property_statistics(trajectory, data_extractor);
+    // Single-pass extraction with variance detection, cached per trajectory (see stats_cache above)
+    const cached = stats_cache.get(trajectory);
+    let property_stats;
+    if (cached?.extractor === data_extractor && same_frames(cached.frames, trajectory.frames)) {
+        property_stats = cached.stats;
+    }
+    else {
+        property_stats = extract_property_statistics(trajectory, data_extractor);
+        stats_cache.set(trajectory, {
+            extractor: data_extractor,
+            frames: [...trajectory.frames],
+            stats: property_stats,
+        });
+    }
     // Create all series
     const all_series = create_series_from_stats(property_stats, property_config, colors);
     // Group by units and assign axes/visibility
@@ -32,18 +64,9 @@ function extract_property_statistics(trajectory, data_extractor) {
             if (typeof value !== `number` || key === `Step` || key.startsWith(`constant_`)) {
                 return;
             }
-            if (!property_stats.has(key)) {
-                const stats = { values: [], sum: 0, sum_squares: 0, min: value, max: value };
-                property_stats.set(key, stats);
-            }
-            const stat = property_stats.get(key);
-            if (stat) {
-                stat.values.push(value);
-                stat.sum += value;
-                stat.sum_squares += value * value;
-                stat.min = Math.min(stat.min, value);
-                stat.max = Math.max(stat.max, value);
-            }
+            const stat = property_stats.get(key) ?? { values: [] };
+            property_stats.set(key, stat);
+            stat.values.push(value);
         });
     });
     // Convert to final format with variation detection
@@ -75,22 +98,24 @@ function create_series_from_stats(property_stats, property_config, colors) {
         if (!stat)
             continue;
         const n_values = stat.values.length;
-        const { clean_label, unit } = extract_label_and_unit(key, property_config);
+        const { clean_label, unit, axis_group } = extract_label_and_unit(key, property_config);
         const color = colors[color_idx % colors.length];
+        // shared per-series metadata (consumers only read metadata[0]); one object, not n copies
+        const series_metadata = {
+            series_label: unit ? `${clean_label} (${unit})` : clean_label,
+            property_key: key, // Store original property key for robust lookups
+        };
         all_series.push({
             x: Array.from({ length: n_values }, (_, idx) => idx),
             y: stat.values,
             label: clean_label,
             unit,
+            ...(axis_group ? { axis_group } : {}),
             y_axis: `y1`, // Will be reassigned
             visible: false, // Will be assigned
             markers: n_values < 30 ? `line+points` : `line`,
-            metadata: Array(n_values).fill({
-                series_label: unit ? `${clean_label} (${unit})` : clean_label,
-                property_key: key, // Store original property key for robust lookups
-            }),
-            line_style: { stroke: color, stroke_width: 2 },
-            point_style: { fill: color, radius: 4, stroke: color, stroke_width: 1 },
+            metadata: Array.from({ length: n_values }, () => series_metadata),
+            ...series_color_styles(color),
         });
         color_idx++;
     }
@@ -98,10 +123,10 @@ function create_series_from_stats(property_stats, property_config, colors) {
 }
 // Group series and assign visibility/axes
 function group_and_assign_series(series, default_visible_properties) {
-    // Group by unit
+    // Group by axis_group when set (forces a dedicated axis), else by unit
     const unit_map = new Map();
     for (const srs of series) {
-        const unit = srs.unit ?? `dimensionless`;
+        const unit = srs.axis_group ?? srs.unit ?? `dimensionless`;
         const group = unit_map.get(unit) ?? [];
         group.push(srs);
         unit_map.set(unit, group);
@@ -110,12 +135,12 @@ function group_and_assign_series(series, default_visible_properties) {
     const groups = Array.from(unit_map.entries())
         .map(([unit, group_series]) => {
         const priority = calculate_priority(unit, group_series);
-        const has_default_visible = group_series.some((srs) => {
+        const is_visible = group_series.some((srs) => {
             const metadata = Array.isArray(srs.metadata) ? srs.metadata[0] : srs.metadata;
             const property_key = (metadata?.property_key || srs.label) ?? ``;
             return is_default_visible(property_key, default_visible_properties);
         });
-        return { unit, series: group_series, priority, is_visible: has_default_visible };
+        return { unit, series: group_series, priority, is_visible };
     })
         .sort((a, b) => a.priority - b.priority);
     // Apply 2-group visibility limit
@@ -155,8 +180,9 @@ function apply_group_assignments(series, unit_groups) {
 // Helper functions
 function extract_label_and_unit(key, property_config) {
     const config = property_config[key] || property_config[key.toLowerCase()];
-    if (config)
-        return { clean_label: config.label, unit: config.unit };
+    if (config) {
+        return { clean_label: config.label, unit: config.unit, axis_group: config.axis_group };
+    }
     return {
         clean_label: key.charAt(0).toUpperCase() + key.slice(1).replaceAll('_', ` `),
         unit: ``,
@@ -201,94 +227,6 @@ const is_default_visible = (property_key, default_properties) => {
     }
     return false;
 };
-// Optimized series visibility toggling
-export function toggle_series_visibility(series, target_series_idx) {
-    if (target_series_idx < 0 || target_series_idx >= series.length)
-        return series;
-    const target_series = series[target_series_idx];
-    const new_visibility = !target_series.visible;
-    // Create unit groups from current state
-    const unit_groups = create_unit_groups_from_series(series);
-    const target_group = unit_groups.find((group) => group.series.includes(target_series));
-    if (!target_group)
-        return series;
-    // Start with updating the target series visibility
-    const updated_series = series.map((srs) => srs === target_series ? { ...srs, visible: new_visibility } : { ...srs });
-    // Handle smart group replacement for new groups
-    if (new_visibility && !target_group.is_visible) {
-        const visible_groups = unit_groups.filter((group) => group.is_visible);
-        if (visible_groups.length >= 2) {
-            // Hide lowest priority group (highest priority number)
-            const lowest_priority_group = visible_groups
-                .sort((g1, g2) => g1.priority - g2.priority)
-                .pop(); // Get the last (lowest priority) group
-            if (lowest_priority_group) {
-                lowest_priority_group.is_visible = false;
-                // Also hide the actual series in this group
-                lowest_priority_group.series.forEach((srs1) => {
-                    const series_idx = updated_series.findIndex((srs2) => srs2.label === srs1.label && srs2.unit === srs1.unit);
-                    if (series_idx !== -1) {
-                        updated_series[series_idx] = { ...updated_series[series_idx], visible: false };
-                    }
-                });
-            }
-        }
-        target_group.is_visible = true;
-    }
-    // Recalculate group visibility and reassign axes
-    update_group_visibility_and_axes(updated_series, unit_groups);
-    return updated_series;
-}
-function create_unit_groups_from_series(series) {
-    const unit_map = new Map();
-    for (const srs of series) {
-        const unit = srs.unit ?? `dimensionless`;
-        const group = unit_map.get(unit) ?? [];
-        group.push(srs);
-        unit_map.set(unit, group);
-    }
-    return Array.from(unit_map.entries())
-        .map(([unit, group_series]) => ({
-        unit,
-        series: group_series,
-        priority: calculate_priority(unit, group_series),
-        is_visible: group_series.some((srs) => srs.visible),
-    }))
-        .sort((a, b) => a.priority - b.priority);
-}
-function update_group_visibility_and_axes(series, unit_groups) {
-    // Update group visibility based on series
-    for (const group of unit_groups) {
-        group.is_visible = group.series.some((srs1) => series.find((srs2) => srs2.label === srs1.label && srs2.unit === srs1.unit)?.visible);
-    }
-    // Apply 2-group limit
-    if (unit_groups.filter((unit_group) => unit_group.is_visible).length > 2) {
-        for (const group of unit_groups.filter((unit_group) => unit_group.is_visible).slice(2)) {
-            group.is_visible = false;
-            for (const srs1 of group.series) {
-                const idx = series.findIndex((srs2) => srs2.label === srs1.label && srs2.unit === srs1.unit);
-                if (idx !== -1)
-                    series[idx] = { ...series[idx], visible: false };
-            }
-        }
-    }
-    // Assign axes
-    const final_visible = unit_groups
-        .filter((group) => group.is_visible)
-        .sort((g1, g2) => g1.priority - g2.priority);
-    const axis_map = new Map();
-    if (final_visible.length > 0)
-        axis_map.set(final_visible[0], `y1`);
-    if (final_visible.length === 2)
-        axis_map.set(final_visible[1], `y2`);
-    // Apply to series
-    for (const [idx, srs] of series.entries()) {
-        const group = unit_groups.find((unit_group) => unit_group.series.some((member) => member.label === srs.label && member.unit === srs.unit));
-        if (group && axis_map.has(group)) {
-            series[idx] = { ...srs, y_axis: axis_map.get(group) };
-        }
-    }
-}
 // Utility functions
 export function should_hide_plot(trajectory, plot_series, tolerance = 1e-10) {
     if (!trajectory || trajectory.frames.length <= 1 || plot_series.length === 0) {
@@ -340,14 +278,47 @@ export function generate_axis_labels(plot_series) {
         y2: get_axis_label(plot_series.filter((srs) => srs.y_axis === `y2`)),
     };
 }
+// Log-scale heuristic: a y-axis defaults to log scale when every visible series on
+// it is strictly positive AND their combined values span at least this many decades.
+// SCF convergence residuals (|ΔE|, density rms) span 6+ decades and degenerate into
+// hockey sticks on linear axes; plain energies (large negative) stay linear.
+const LOG_SCALE_MIN_DECADE_SPAN = 3;
+const LOG_SCALE_AXIS_GROUPS = new Set([SCF_AXIS_GROUP]);
+export function generate_axis_scale_types(plot_series) {
+    const scale_for_axis = (axis) => {
+        let min_val = Infinity;
+        let max_val = -Infinity;
+        for (const srs of plot_series) {
+            if (!srs.visible || (srs.y_axis ?? `y1`) !== axis)
+                continue;
+            if (!srs.axis_group || !LOG_SCALE_AXIS_GROUPS.has(srs.axis_group))
+                return `linear`;
+            for (const val of srs.y) {
+                if (!Number.isFinite(val))
+                    continue;
+                if (val < min_val)
+                    min_val = val;
+                if (val > max_val)
+                    max_val = val;
+            }
+        }
+        if (!Number.isFinite(min_val) || min_val <= 0)
+            return `linear`;
+        return max_val / min_val >= 10 ** LOG_SCALE_MIN_DECADE_SPAN ? `log` : `linear`;
+    };
+    return { y1: scale_for_axis(`y1`), y2: scale_for_axis(`y2`) };
+}
 export function generate_streaming_plot_series(metadata_list, options = {}) {
     if (metadata_list.length === 0)
         return [];
     const { property_config = trajectory_property_config, colors = PLOT_COLORS, default_visible_properties = DEFAULT_VISIBLE, max_points = 10_000, // 10,000 plot points provides good visual fidelity while maintaining browser performance
      } = options;
-    const sampled_metadata = metadata_list.length > max_points
-        ? downsample_metadata(metadata_list, max_points)
-        : metadata_list;
+    const ordered_metadata = [...metadata_list]
+        .sort((metadata_a, metadata_b) => metadata_a.frame_number - metadata_b.frame_number)
+        .filter((metadata, idx, sorted_metadata) => idx === 0 || metadata.frame_number !== sorted_metadata[idx - 1].frame_number);
+    const sampled_metadata = ordered_metadata.length > max_points
+        ? downsample_metadata(ordered_metadata, max_points)
+        : ordered_metadata;
     const all_properties = new Set();
     sampled_metadata.forEach((metadata) => {
         Object.keys(metadata.properties).forEach((prop) => all_properties.add(prop));
@@ -358,22 +329,26 @@ export function generate_streaming_plot_series(metadata_list, options = {}) {
     for (const property_key of all_properties) {
         const data_points = sampled_metadata
             .filter((metadata) => property_key in metadata.properties)
-            .map((metadata) => ({ x: metadata.step, y: metadata.properties[property_key] }));
+            .map((metadata) => ({
+            x: metadata.frame_number,
+            y: metadata.properties[property_key],
+        }));
         if (data_points.length < 2)
             continue;
         const is_energy = property_key.toLowerCase() === `energy`;
         if (!is_energy && !has_significant_variation(data_points.map((point) => point.y)))
             continue;
-        const { clean_label, unit } = extract_label_and_unit(property_key, property_config);
+        const { clean_label, unit, axis_group } = extract_label_and_unit(property_key, property_config);
         const is_visible = is_default_visible(property_key, default_visible_properties) || color_idx < 2;
         const color = colors[color_idx % colors.length];
         if (is_visible)
-            visible_props.push({ property: property_key, unit });
+            visible_props.push({ property: property_key, unit, axis_group });
         all_series.push({
             x: data_points.map((point) => point.x),
             y: data_points.map((point) => point.y),
             label: clean_label,
             unit,
+            ...(axis_group ? { axis_group } : {}),
             y_axis: determine_axis_from_groups(property_key, unit, visible_props),
             visible: is_visible,
             markers: data_points.length < 1000 ? `line+points` : `line`,
@@ -381,8 +356,7 @@ export function generate_streaming_plot_series(metadata_list, options = {}) {
                 series_label: unit ? `${clean_label} (${unit})` : clean_label,
                 property_key, // Store original property key for robust lookups
             })),
-            line_style: { stroke: color, stroke_width: 2 },
-            point_style: { fill: color, radius: 4, stroke: color, stroke_width: 1 },
+            ...series_color_styles(color),
         });
         color_idx++;
     }
@@ -411,9 +385,10 @@ function has_significant_variation(values, tolerance = 1e-6) {
     return coefficient_of_variation >= tolerance;
 }
 function determine_axis_from_groups(property, unit, visible_properties) {
-    const mock_series = visible_properties.map(({ property: prop, unit: u }) => ({
+    const mock_series = visible_properties.map(({ property: prop, unit: prop_unit, axis_group }) => ({
         label: prop,
-        unit: u,
+        unit: prop_unit,
+        ...(axis_group ? { axis_group } : {}),
     }));
     const groups = group_and_assign_series(mock_series, new Set([property]));
     const target_group = groups.find((group) => group.series.some((srs) => srs.label === property && srs.unit === unit));

package/dist/utils.d.ts

@@ -1,7 +1,11 @@
+export declare const is_plain_object: (val: unknown) => val is Record<string, unknown>;
+export declare const clamp01: (value: number) => number;
 export declare function merge_nested<T extends Record<string, unknown>>(obj1: T, obj2?: Partial<T>): T;
 export declare const escape_html: (unsafe_string: string) => string;
 export declare const normalize_unicode_minus: (value: string) => string;
 export declare const normalize_scientific_notation: (value: string) => string;
+export declare const parse_num_token: (token: string) => number;
+export declare const parse_leading_num: (line: string) => number;
 export declare const to_error: (value: unknown) => Error;
 export declare function make_change_detector(): (value: unknown) => boolean;
 export declare function decode_url_safe_base64(encoded: string): string | undefined;

package/dist/utils.js

@@ -1,5 +1,7 @@
 // Check if value is a plain object (not array, null, or other types)
-const is_plain_object = (val) => typeof val === `object` && val !== null && !Array.isArray(val);
+export const is_plain_object = (val) => typeof val === `object` && val !== null && !Array.isArray(val);
+// Clamp a number to the [0, 1] range.
+export const clamp01 = (value) => Math.max(0, Math.min(1, value));
 // Merge nested objects (1 level deep).
 export function merge_nested(obj1, obj2) {
     const result = { ...obj1, ...obj2 };
@@ -21,6 +23,11 @@ export const escape_html = (unsafe_string) => unsafe_string
 export const normalize_unicode_minus = (value) => value.replaceAll('−', `-`);
 // Normalize scientific notation variants (d/D exponent, Mathematica *^).
 export const normalize_scientific_notation = (value) => normalize_unicode_minus(value).toLowerCase().replaceAll('d', `e`).replaceAll('*^', `e`);
+// Number(token) that treats blank strings as NaN, not 0 like Number(``) does
+export const parse_num_token = (token) => token.trim() === `` ? NaN : Number(token);
+// Parse a line's first whitespace-separated token: tolerates trailing
+// tokens/comments (`1.0 ! scale` -> 1.0) like parseFloat, blank lines are NaN
+export const parse_leading_num = (line) => parse_num_token(line.trim().split(/\s+/)[0]);
 // Coerce an unknown thrown value into an Error (for typed Promise rejections / error callbacks).
 export const to_error = (value) => value instanceof Error ? value : new Error(String(value));
 export function make_change_detector() {