matterviz 0.4.0 → 0.4.1

package/dist/plot/scatter-3d/ScatterPlot3DScene.svelte

@@ -2,7 +2,6 @@
   lang="ts"
   generics="Metadata extends Record<string, unknown> = Record<string, unknown>"
 >
-  import type { D3ColorSchemeName, D3InterpolateName } from '../../colors'
   import { format_num } from '../../labels'
   import type { Vec2, Vec3 } from '../../math'
   import type {
@@ -13,12 +12,13 @@
     InternalPoint3D,
     RefLine3D,
     RefPlane,
-    ScaleType,
     Scatter3DHandlerEvent,
+    SizeScaleConfig,
     StyleOverrides3D,
     Surface3DConfig,
   } from '../core/types'
-  import { T, useTask, useThrelte } from '@threlte/core'
+  import { bind_renderer } from '../../scene'
+  import { T, useTask } from '@threlte/core'
   import * as extras from '@threlte/extras'
   import { scaleLinear } from 'd3-scale'
   import { type ComponentProps, onDestroy, type Snippet, untrack } from 'svelte'
@@ -31,7 +31,7 @@
   import { normalize_to_scene } from '../core/reference-line'
   import ReferenceLine3D from '../core/components/ReferenceLine3D.svelte'
   import ReferencePlane from '../core/components/ReferencePlane.svelte'
-  import { create_color_scale, create_size_scale } from '../core/scales'
+  import { create_size_scale } from '../core/scales'
   import Surface3D from './Surface3D.svelte'
 
   let {
@@ -45,7 +45,7 @@
     surfaces = [],
     ref_lines = [],
     ref_planes = [],
-    color_scale = { type: `linear`, scheme: `interpolateViridis` },
+    color_scale_fn = () => get_series_color(0),
     size_scale = { type: `linear`, radius_range: [0.05, 0.2] },
     camera_position = [10, 10, 10] as Vec3,
     camera_projection = `perspective` as CameraProjection3D,
@@ -81,16 +81,9 @@
     surfaces?: Surface3DConfig[]
     ref_lines?: RefLine3D[]
     ref_planes?: RefPlane[]
-    color_scale?: {
-      type?: ScaleType
-      scheme?: D3ColorSchemeName | D3InterpolateName
-      value_range?: [number, number]
-    }
-    size_scale?: {
-      type?: ScaleType
-      radius_range?: [number, number]
-      value_range?: [number, number]
-    }
+    // Color scale function for color_values (computed once by the ScatterPlot3D wrapper)
+    color_scale_fn?: (value: number) => string
+    size_scale?: SizeScaleConfig
     camera_position?: Vec3
     camera_projection?: CameraProjection3D
     auto_rotate?: number
@@ -116,10 +109,10 @@
     height?: number
   } = $props()
 
-  const threlte = useThrelte()
-  $effect(() => {
-    scene = threlte.scene
-    camera = threlte.camera.current
+  // Mirrors scene/camera into bindable props and tags the canvas so export_canvas_as_png can re-render at export DPI
+  bind_renderer((threlte_scene, threlte_camera) => {
+    scene = threlte_scene
+    camera = threlte_camera
   })
 
   extras.interactivity()
@@ -182,24 +175,28 @@
   function sample_surface(
     surface: Surface3DConfig,
   ): { x: number; y: number; z: number }[] {
-    const n = 10
+    const grid_steps = 10
     const pts: { x: number; y: number; z: number }[] = []
     if (surface.type === `grid` && surface.z_fn) {
       const [x0, x1] = surface.x_range ?? [-1, 1]
       const [y0, y1] = surface.y_range ?? [-1, 1]
-      for (let i = 0; i <= n; i++) {
-        for (let j = 0; j <= n; j++) {
-          const x = x0 + (i / n) * (x1 - x0), y = y0 + (j / n) * (y1 - y0)
+      for (let idx_x = 0; idx_x <= grid_steps; idx_x++) {
+        for (let idx_y = 0; idx_y <= grid_steps; idx_y++) {
+          const x = x0 + (idx_x / grid_steps) * (x1 - x0),
+            y = y0 + (idx_y / grid_steps) * (y1 - y0)
           pts.push({ x, y, z: surface.z_fn(x, y) })
         }
       }
     } else if (surface.type === `parametric` && surface.parametric_fn) {
       const [u0, u1] = surface.u_range ?? [0, 1]
       const [v0, v1] = surface.v_range ?? [0, 1]
-      for (let i = 0; i <= n; i++) {
-        for (let j = 0; j <= n; j++) {
+      for (let idx_u = 0; idx_u <= grid_steps; idx_u++) {
+        for (let idx_v = 0; idx_v <= grid_steps; idx_v++) {
           pts.push(
-            surface.parametric_fn(u0 + (i / n) * (u1 - u0), v0 + (j / n) * (v1 - v0)),
+            surface.parametric_fn(
+              u0 + (idx_u / grid_steps) * (u1 - u0),
+              v0 + (idx_v / grid_steps) * (v1 - v0),
+            ),
           )
         }
       }
@@ -209,15 +206,14 @@
     return pts.filter((pt) => isFinite(pt.x) && isFinite(pt.y) && isFinite(pt.z))
   }
 
-  // Compute axis range with D3's nice() for clean boundaries
+  // Compute axis range with D3's nice(); data_min/data_max are the finite extent (Infinity/-Infinity when empty)
   function compute_range(
-    values: number[],
+    [data_min, data_max]: Vec2,
     range?: [number | null, number | null],
   ): Vec2 {
     if (range?.[0] != null && range?.[1] != null) return range as Vec2
-    const valid = values.filter(isFinite)
-    if (valid.length === 0) return [0, 1]
-    let [min, max] = [Math.min(...valid), Math.max(...valid)]
+    if (data_min > data_max) return [0, 1] // no finite values
+    let [min, max] = [data_min, data_max]
     const pad = min === max
       ? (min === 0 ? 1 : Math.abs(min * 0.1))
       : (max - min) * 0.05
@@ -227,49 +223,39 @@
       .domain() as Vec2
   }
 
-  // Collect xyz values from points and surfaces
+  // Collect xyz extents from points and surfaces in one pass (no intermediate arrays)
   let surface_samples = $derived(surfaces.flatMap(sample_surface))
-  let x_range = $derived(
-    compute_range([
-      ...all_points.map((point) => point.x),
-      ...surface_samples.map((point) => point.x),
-    ], x_axis.range),
-  )
-  let y_range = $derived(
-    compute_range([
-      ...all_points.map((point) => point.y),
-      ...surface_samples.map((point) => point.y),
-    ], y_axis.range),
-  )
-  let z_range = $derived(
-    compute_range([
-      ...all_points.map((point) => point.z),
-      ...surface_samples.map((point) => point.z),
-    ], z_axis.range),
-  )
+  let data_extents = $derived.by(() => {
+    const extents = {
+      x: [Infinity, -Infinity] as Vec2,
+      y: [Infinity, -Infinity] as Vec2,
+      z: [Infinity, -Infinity] as Vec2,
+    }
+    for (const points of [all_points, surface_samples]) {
+      for (const pt of points) {
+        for (const axis of [`x`, `y`, `z`] as const) {
+          const val = pt[axis]
+          if (!isFinite(val)) continue
+          const extent = extents[axis]
+          if (val < extent[0]) extent[0] = val
+          if (val > extent[1]) extent[1] = val
+        }
+      }
+    }
+    return extents
+  })
+  let x_range = $derived(compute_range(data_extents.x, x_axis.range))
+  let y_range = $derived(compute_range(data_extents.y, y_axis.range))
+  let z_range = $derived(compute_range(data_extents.z, z_axis.range))
 
   const normalize_x = (value: number) => normalize_to_scene(value, x_range, scene_x)
   const normalize_y = (value: number) => normalize_to_scene(value, y_range, scene_y)
   const normalize_z = (value: number) => normalize_to_scene(value, z_range, scene_z)
 
-  // Color/size scales
-  let all_color_values = $derived(
-    all_points.map((pt) => pt.color_value).filter((val): val is number => val != null),
-  )
-  let auto_color_range: [number, number] = $derived.by(() => {
-    if (all_color_values.length === 0) return [0, 1]
-    let min = all_color_values[0]
-    let max = all_color_values[0]
-    for (const val of all_color_values) {
-      if (val < min) min = val
-      else if (val > max) max = val
-    }
-    return [min, max]
-  })
+  // Size scale (the color scale is computed by the wrapper and passed as a prop)
   let all_size_values = $derived(
     all_points.map((pt) => pt.size_value).filter((val): val is number => val != null),
   )
-  let color_scale_fn = $derived(create_color_scale(color_scale, auto_color_range))
   let size_scale_fn = $derived(create_size_scale(size_scale, all_size_values))
 
   // Process points with normalized positions
@@ -331,83 +317,98 @@
   )
 
   // Series line data for connecting points
-  type SeriesLineData = {
+  type SeriesLineInput = {
     series_idx: number
+    positions: number[]
     color: string
     width: number
     dashed: boolean
+  }
+  type SeriesLineData = SeriesLineInput & {
     line2: Line2
     geometry: LineGeometry
     material: LineMaterial
   }
 
-  // Track previous lines for cleanup
-  let series_lines: SeriesLineData[] = $state([])
-
-  $effect(() => {
-    // Dispose old lines before creating new ones
-    for (const line_data of untrack(() => series_lines)) {
-      line_data.geometry.dispose()
-      line_data.material.dispose()
-    }
-
-    const lines: SeriesLineData[] = []
+  // Per-series fat-line inputs (ordered positions + resolved stroke style) as a derived so
+  // the effect below can diff against previous lines and only rebuild what changed
+  let line_inputs = $derived.by((): SeriesLineInput[] => {
+    const eligible: SeriesLineInput[] = []
+    const positions_by_series = new Map<number, number[]>()
     for (let series_idx = 0; series_idx < series.length; series_idx++) {
       const srs = series[series_idx]
-      if (!srs?.line_style) continue
+      const line_style = srs?.line_style
+      if (!line_style) continue
       if (!(series_visibility[series_idx] ?? srs.visible ?? true)) continue
-
-      // Get points for this series in order
-      const series_points = processed_points
-        .filter((pt) => pt.series_idx === series_idx)
-        .sort((a, b) => a.point_idx - b.point_idx)
-
-      if (series_points.length < 2) continue
-
-      // Create fat line geometry (LineGeometry for Line2)
       const positions: number[] = []
-      for (const pt of series_points) {
-        positions.push(pt.x, pt.y, pt.z)
-      }
-      const geometry = new LineGeometry()
-      geometry.setPositions(positions)
-
-      // Determine line style
-      const line_style = srs.line_style
+      positions_by_series.set(series_idx, positions)
       const color = line_style.stroke ??
         (Array.isArray(srs.point_style)
           ? srs.point_style[0]?.fill
           : srs.point_style?.fill) ??
         get_series_color(series_idx)
-      const line_width = line_style.stroke_width ?? 2
-      const dashed = Boolean(line_style.line_dash)
-
-      // Create LineMaterial for fat lines (linewidth is in pixels when resolution is set)
-      // Use placeholder resolution; the separate resolution effect updates it
-      const material = new LineMaterial({
-        color: new THREE.Color(color).getHex(),
-        linewidth: line_width, // Width in pixels
-        dashed,
-        dashScale: dashed ? 2 : 1,
-        dashSize: 0.1,
-        gapSize: 0.05,
-        resolution: new THREE.Vector2(1, 1),
-      })
-
-      const line2 = new Line2(geometry, material)
-      line2.computeLineDistances()
-
-      lines.push({
+      eligible.push({
         series_idx,
+        positions,
         color,
-        width: line_width,
-        dashed,
-        line2,
-        geometry,
-        material,
+        width: line_style.stroke_width ?? 2,
+        dashed: Boolean(line_style.line_dash),
       })
     }
-    series_lines = lines
+    // processed_points are emitted in (series_idx, point_idx) order, so one ordered pass replaces the old per-series filter + sort
+    for (const pt of processed_points) {
+      positions_by_series.get(pt.series_idx)?.push(pt.x, pt.y, pt.z)
+    }
+    return eligible.filter((input) => input.positions.length >= 6) // >= 2 points
+  })
+
+  const same_line_input = (prev: SeriesLineData, next: SeriesLineInput): boolean =>
+    prev.color === next.color && prev.width === next.width &&
+    prev.dashed === next.dashed &&
+    prev.positions.length === next.positions.length &&
+    prev.positions.every((coord, idx) => coord === next.positions[idx])
+
+  // Track previous lines for reuse/cleanup
+  let series_lines: SeriesLineData[] = $state([])
+
+  $effect(() => {
+    const inputs = line_inputs
+    untrack(() => {
+      const prev_by_idx = new Map(series_lines.map((line) => [line.series_idx, line]))
+      const next_lines = inputs.map((input): SeriesLineData => {
+        const prev = prev_by_idx.get(input.series_idx)
+        if (prev && same_line_input(prev, input)) {
+          prev_by_idx.delete(input.series_idx) // reused - don't dispose below
+          return prev
+        }
+        // Create fat line geometry (LineGeometry for Line2)
+        const geometry = new LineGeometry()
+        geometry.setPositions(input.positions)
+        // Create LineMaterial for fat lines (linewidth is in pixels when resolution
+        // is set). Use placeholder resolution; the separate resolution effect updates it
+        const material = new LineMaterial({
+          color: new THREE.Color(input.color).getHex(),
+          linewidth: input.width, // Width in pixels
+          dashed: input.dashed,
+          dashScale: input.dashed ? 2 : 1,
+          dashSize: 0.1,
+          gapSize: 0.05,
+          resolution: new THREE.Vector2(1, 1),
+        })
+        const line2 = new Line2(geometry, material)
+        line2.computeLineDistances()
+        return { ...input, line2, geometry, material }
+      })
+      // Dispose lines that were replaced or removed
+      for (const stale of prev_by_idx.values()) {
+        stale.geometry.dispose()
+        stale.material.dispose()
+      }
+      // Skip reassignment when every line was reused to avoid invalidating consumers
+      const unchanged = next_lines.length === series_lines.length &&
+        next_lines.every((line, idx) => line === series_lines[idx])
+      if (!unchanged) series_lines = next_lines
+    })
   })
 
   // Update LineMaterial resolution when canvas size changes
@@ -434,7 +435,7 @@
 
   // Generate axis ticks using D3's smart tick generation
   function gen_ticks(
-    range: [number, number],
+    range: Vec2,
     ticks?: AxisConfig3D[`ticks`],
   ): number[] {
     if (Array.isArray(ticks)) return ticks

package/dist/plot/scatter-3d/ScatterPlot3DScene.svelte.d.ts

@@ -1,6 +1,5 @@
-import type { D3ColorSchemeName, D3InterpolateName } from '../../colors';
 import type { Vec3 } from '../../math';
-import type { AxisConfig3D, CameraProjection3D, DataSeries3D, DisplayConfig3D, InternalPoint3D, RefLine3D, RefPlane, ScaleType, Scatter3DHandlerEvent, StyleOverrides3D, Surface3DConfig } from '../core/types';
+import type { AxisConfig3D, CameraProjection3D, DataSeries3D, DisplayConfig3D, InternalPoint3D, RefLine3D, RefPlane, Scatter3DHandlerEvent, SizeScaleConfig, StyleOverrides3D, Surface3DConfig } from '../core/types';
 import * as extras from '@threlte/extras';
 import { type ComponentProps, type Snippet } from 'svelte';
 import type { Camera, Scene } from 'three';
@@ -16,16 +15,8 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         surfaces?: Surface3DConfig[];
         ref_lines?: RefLine3D[];
         ref_planes?: RefPlane[];
-        color_scale?: {
-            type?: ScaleType;
-            scheme?: D3ColorSchemeName | D3InterpolateName;
-            value_range?: [number, number];
-        };
-        size_scale?: {
-            type?: ScaleType;
-            radius_range?: [number, number];
-            value_range?: [number, number];
-        };
+        color_scale_fn?: (value: number) => string;
+        size_scale?: SizeScaleConfig;
         camera_position?: Vec3;
         camera_projection?: CameraProjection3D;
         auto_rotate?: number;
@@ -51,7 +42,7 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         height?: number;
     };
     exports: {};
-    bindings: "camera" | "hovered_point" | "scene" | "orbit_controls";
+    bindings: "scene" | "camera" | "orbit_controls" | "hovered_point";
     slots: {};
     events: {};
 };
@@ -59,7 +50,7 @@ declare class __sveltets_Render<Metadata extends Record<string, unknown> = Recor
     props(): ReturnType<typeof $$render<Metadata>>['props'];
     events(): ReturnType<typeof $$render<Metadata>>['events'];
     slots(): ReturnType<typeof $$render<Metadata>>['slots'];
-    bindings(): "camera" | "hovered_point" | "scene" | "orbit_controls";
+    bindings(): "scene" | "camera" | "orbit_controls" | "hovered_point";
     exports(): {};
 }
 interface $$IsomorphicComponent {

package/dist/plot/scatter-3d/Surface3D.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+  import type { Vec2 } from '../../math'
   import type { Surface3DConfig } from '../core/types'
   import { T } from '@threlte/core'
   import * as THREE from 'three'
@@ -13,9 +14,9 @@
     scene_z = 5,
   }: {
     config: Surface3DConfig
-    x_range?: [number, number]
-    y_range?: [number, number]
-    z_range?: [number, number]
+    x_range?: Vec2
+    y_range?: Vec2
+    z_range?: Vec2
     scene_x?: number
     scene_y?: number
     scene_z?: number
@@ -24,7 +25,7 @@
   // Normalize value to scene coordinates (centered around 0)
   const normalize = (
     value: number,
-    [min_val, max_val]: [number, number],
+    [min_val, max_val]: Vec2,
     scene_size: number,
   ): number => ((value - min_val) / (max_val - min_val || 1) - 0.5) * scene_size
 
@@ -96,7 +97,7 @@
   }
 
   // Parse resolution config into [res_a, res_b]
-  const get_resolution = (): [number, number] =>
+  const get_resolution = (): Vec2 =>
     Array.isArray(config.resolution)
       ? config.resolution
       : [config.resolution ?? 20, config.resolution ?? 20]

package/dist/plot/scatter-3d/Surface3D.svelte.d.ts

@@ -1,9 +1,10 @@
+import type { Vec2 } from '../../math';
 import type { Surface3DConfig } from '../core/types';
 type $$ComponentProps = {
     config: Surface3DConfig;
-    x_range?: [number, number];
-    y_range?: [number, number];
-    z_range?: [number, number];
+    x_range?: Vec2;
+    y_range?: Vec2;
+    z_range?: Vec2;
     scene_x?: number;
     scene_y?: number;
     scene_z?: number;

package/dist/plot/sunburst/Sunburst.svelte

@@ -7,7 +7,7 @@
   import { export_svg_as_png, export_svg_as_svg } from '../../io/export'
   import { format_value } from '../../labels'
   import { FullscreenToggle, set_fullscreen_bg } from '../../layout'
-  import { DEG_TO_RAD } from '../../math'
+  import { DEG_TO_RAD, type Vec2 } from '../../math'
   import type {
     BasePlotProps,
     LegendConfig,
@@ -29,12 +29,8 @@
   } from '../core/layout'
   import type { Sides } from '../core/layout'
   import { create_color_scale } from '../core/scales'
-  import {
-    arc_label_transform,
-    arrow_nav_target,
-    project_arcs,
-    type ScreenArc as ScreenArcOf,
-  } from './render'
+  import { arc_label_transform, arrow_nav_target, project_arcs } from './render'
+  import type { ScreenArc as ScreenArcOf } from './render'
   import { compute_sunburst_layout, type PositionedArc } from './sunburst'
   import { DEFAULTS } from '../../settings'
   import { arc as d3_arc } from 'd3-shape'
@@ -118,7 +114,7 @@
     // inheritance; return null to keep an arc's categorical color
     color_values?: (arc: PositionedArc<Metadata>) => number | null
     color_scale?: D3InterpolateName
-    color_range?: [number, number] // defaults to the metric's [min, max]
+    color_range?: Vec2 // defaults to the metric's [min, max]
     colorbar?: ComponentProps<typeof ColorBar> | null // null hides it
     export_buttons?: boolean // SVG/PNG download buttons in the controls pane
     export_filename?: string
@@ -266,10 +262,10 @@
 
   let arc_gen = $derived(
     d3_arc<ScreenArc>()
-      .startAngle((d) => d.a0)
-      .endAngle((d) => d.a1)
-      .innerRadius((d) => d.r0)
-      .outerRadius((d) => d.r1)
+      .startAngle((screen) => screen.a0)
+      .endAngle((screen) => screen.a1)
+      .innerRadius((screen) => screen.r0)
+      .outerRadius((screen) => screen.r1)
       .padAngle(pad_angle * DEG_TO_RAD)
       .padRadius(radius || 1),
   )
@@ -287,19 +283,19 @@
   )
 
   // Arc centroid in container (pad-offset) pixel space, for tooltip + legend placement
-  const arc_center = (d: ScreenArc): { x: number; y: number } => {
+  const arc_center = (screen: ScreenArc): { x: number; y: number } => {
     if (shape === `icicle`) {
-      return { x: pad.l + (d.a0 + d.a1) / 2, y: pad.t + (d.r0 + d.r1) / 2 }
+      return { x: pad.l + (screen.a0 + screen.a1) / 2, y: pad.t + (screen.r0 + screen.r1) / 2 }
     }
-    const mid_a = (d.a0 + d.a1) / 2
-    const mid_r = (d.r0 + d.r1) / 2
+    const mid_a = (screen.a0 + screen.a1) / 2
+    const mid_r = (screen.r0 + screen.r1) / 2
     return { x: cx + Math.sin(mid_a) * mid_r, y: cy - Math.cos(mid_a) * mid_r }
   }
 
   // Continuous metric coloring: when color_values is given, arcs are colored by their
   // metric on a d3 colormap (arcs returning null keep their categorical color).
   // The user accessor runs exactly once per arc.
-  let metric = $derived.by<{ range: [number, number]; colors: string[] } | null>(() => {
+  let metric = $derived.by<{ range: Vec2; colors: string[] } | null>(() => {
     if (!color_values) return null
     const vals = layout.arcs.map((arc) => {
       const val = arc.depth === 0 ? null : color_values(arc)
@@ -574,10 +570,10 @@
   )
 
   // Label text + placement transform for an arc; null = doesn't fit, hide the label
-  function label_attrs(d: ScreenArc): { transform: string; text: string } | null {
-    const { text, width: text_w } = arc_info[d.arc.node_idx]
+  function label_attrs(screen: ScreenArc): { transform: string; text: string } | null {
+    const { text, width: text_w } = arc_info[screen.arc.node_idx]
     if (!text) return null
-    const transform = arc_label_transform(d, text_w, shape, label_rotation)
+    const transform = arc_label_transform(screen, text_w, shape, label_rotation)
     return transform ? { transform, text } : null
   }
 

package/dist/plot/sunburst/Sunburst.svelte.d.ts

@@ -1,4 +1,5 @@
 import type { D3InterpolateName } from '../../colors';
+import { type Vec2 } from '../../math';
 import type { BasePlotProps, LegendConfig, SunburstLabelRotation, SunburstLabelText, SunburstNode, SunburstNodeHandlerProps, SunburstShape, SunburstSort, SunburstValueMode } from '..';
 import { ColorBar } from '..';
 import type { Sides } from '../core/layout';
@@ -26,7 +27,7 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         show_breadcrumbs?: boolean;
         color_values?: (arc: PositionedArc<Metadata>) => number | null;
         color_scale?: D3InterpolateName;
-        color_range?: [number, number];
+        color_range?: Vec2;
         colorbar?: ComponentProps<typeof ColorBar> | null;
         export_buttons?: boolean;
         export_filename?: string;
@@ -73,7 +74,7 @@ declare function $$render<Metadata extends Record<string, unknown> = Record<stri
         }]>;
     };
     exports: {};
-    bindings: "data" | "show_controls" | "fullscreen" | "hovered" | "controls_open" | "value_mode" | "min_fraction" | "show_labels" | "shape" | "max_depth" | "inner_radius" | "pad_angle" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
+    bindings: "data" | "show_controls" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "shape" | "value_mode" | "max_depth" | "inner_radius" | "pad_angle" | "min_fraction" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
     slots: {};
     events: {};
 };
@@ -81,7 +82,7 @@ declare class __sveltets_Render<Metadata extends Record<string, unknown> = Recor
     props(): ReturnType<typeof $$render<Metadata>>['props'];
     events(): ReturnType<typeof $$render<Metadata>>['events'];
     slots(): ReturnType<typeof $$render<Metadata>>['slots'];
-    bindings(): "data" | "show_controls" | "fullscreen" | "hovered" | "controls_open" | "value_mode" | "min_fraction" | "show_labels" | "shape" | "max_depth" | "inner_radius" | "pad_angle" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
+    bindings(): "data" | "show_controls" | "show_labels" | "fullscreen" | "hovered" | "controls_open" | "shape" | "value_mode" | "max_depth" | "inner_radius" | "pad_angle" | "min_fraction" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs" | "zoom_root_id";
     exports(): {};
 }
 interface $$IsomorphicComponent {

package/dist/plot/sunburst/SunburstControls.svelte.d.ts

@@ -21,6 +21,6 @@ type $$ComponentProps = {
     pane_props?: HTMLAttributes<HTMLDivElement>;
     children?: Snippet;
 };
-declare const SunburstControls: import("svelte").Component<$$ComponentProps, {}, "show_controls" | "controls_open" | "value_mode" | "min_fraction" | "show_labels" | "shape" | "max_depth" | "inner_radius" | "pad_angle" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs">;
+declare const SunburstControls: import("svelte").Component<$$ComponentProps, {}, "show_controls" | "show_labels" | "controls_open" | "shape" | "value_mode" | "max_depth" | "inner_radius" | "pad_angle" | "min_fraction" | "label_rotation" | "label_text" | "zoom_on_click" | "show_breadcrumbs">;
 type SunburstControls = ReturnType<typeof SunburstControls>;
 export default SunburstControls;

package/dist/plot/sunburst/sunburst.js

@@ -7,11 +7,14 @@
 import { hsl } from 'd3-color';
 import { hierarchy, partition } from 'd3-hierarchy';
 import { DEFAULT_SERIES_COLORS } from '../core/types';
+import { DEFAULTS } from '../../settings';
 // Compute normalized arc extents, resolved colors and breadcrumbs for a node tree.
 // Never mutates user data: d3-hierarchy wraps inputs in HierarchyNodes and all derived
 // fields (value overrides, ids, colors) are written onto the returned arcs only.
 export function compute_sunburst_layout(data, opts = {}) {
-    const { value_mode = `leaf-sum`, sort = `none`, level_lighten = 0, min_fraction = 0, other_label = `Other`, } = opts;
+    const { 
+    // value_mode/min_fraction fallbacks derive from DEFAULTS.sunburst to prevent drift
+    value_mode = DEFAULTS.sunburst.value_mode, sort = `none`, level_lighten = 0, min_fraction = DEFAULTS.sunburst.min_fraction, other_label = `Other`, } = opts;
     // Fresh object each call (not a shared constant) so callers can't corrupt each other
     if (Array.isArray(data) ? data.length === 0 : !data) {
         return { arcs: [], root: null, max_depth: 0 };

package/dist/rdf/RdfPlot.svelte.d.ts

@@ -22,6 +22,6 @@ type $$ComponentProps = {
     drag_dropped?: Crystal[];
     dragging?: boolean;
 } & ComponentProps<typeof ScatterPlot>;
-declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "loading" | "error_msg" | "dragging" | "drag_dropped">;
+declare const RdfPlot: import("svelte").Component<$$ComponentProps, {}, "loading" | "dragging" | "error_msg" | "drag_dropped">;
 type RdfPlot = ReturnType<typeof RdfPlot>;
 export default RdfPlot;

package/dist/sanitize.js

@@ -75,21 +75,32 @@ const stringify_html_input = (html) => {
         return ``;
     }
 };
+// Memoize by input: two DOMPurify passes per call are costly when a component re-sanitizes
+// many cells on every render (e.g. HeatmapTable). Sanitization is deterministic for the
+// fixed config, so caching is output-identical.
+const sanitize_cache = new Map();
 // Sanitize HTML string, allowing only safe formatting tags and links.
 // Two-pass: happy-dom promotes dangerous children when a non-allowed parent is
 // stripped (e.g. <div><script>…</script></div> → <script>…</script>). The first
 // pass explicitly removes dangerous tags so they can't survive promotion.
 export function sanitize_html(html) {
     const str = stringify_html_input(html);
+    const cached = sanitize_cache.get(str);
+    if (cached !== undefined)
+        return cached;
     const dp = get_purify();
     if (!dp)
-        return str;
+        return str; // no DOM (SSR): return as-is, don't cache
     // oxfmt-ignore
     const safe = dp.sanitize(str, { ADD_ATTR: [`target`], FORBID_TAGS: [
             `script`, `style`, `iframe`, `object`, `embed`, `form`, `input`, `textarea`,
             `select`, `button`, `meta`, `link`, `base`, `template`, `noscript`,
         ] });
-    return dp.sanitize(safe, { ALLOWED_TAGS: SAFE_TAGS, ALLOWED_ATTR: SAFE_ATTRS });
+    const result = dp.sanitize(safe, { ALLOWED_TAGS: SAFE_TAGS, ALLOWED_ATTR: SAFE_ATTRS });
+    if (sanitize_cache.size >= 4096)
+        sanitize_cache.clear(); // bound memory (rarely hit)
+    sanitize_cache.set(str, result);
+    return result;
 }
 export const compact_formula = (formula) => formula.replaceAll(/\s+/g, ``);
 // Sanitize a chemical formula with optional subscript formatting