matterviz 0.4.1 → 0.4.3

package/dist/spectral/helpers.js

@@ -81,7 +81,7 @@ export const IMAGINARY_MODE_NOISE_THRESHOLD = 0.005; // Clamp negatives < 0.5% a
 export function pretty_sym_point(symbol) {
     if (!symbol)
         return ``;
-    // Remove underscores (htmlify maps S0 → S<sub>0</sub> but leaves S_0 as is)
+    // Remove underscores so S_0 and S0 are treated alike
     // Replace common symmetry point names with Greek letters
     // Handle both plain names (GAMMA) and LaTeX notation (\Gamma) from pymatgen
     // Handle subscripts: convert S0 to S₀, K1 to K₁, Γ1 to Γ₁, etc.
@@ -92,7 +92,7 @@ export function pretty_sym_point(symbol) {
         .replaceAll(/\\?DELTA/gi, `Δ`)
         .replaceAll(/\\?SIGMA/gi, `Σ`)
         .replaceAll(/\\?LAMBDA/gi, `Λ`)
-        .replaceAll(/(\p{L})(\d+)/gu, (_, letter, num) => letter +
+        .replaceAll(/(?<letter>\p{L})(?<num>\d+)/gu, (_, letter, num) => letter +
         num
             .split(``)
             .map((digit) => (is_subscript_key(digit) ? SUBSCRIPT_MAP[digit] : digit))
@@ -195,33 +195,24 @@ export function convert_frequencies(frequencies, unit = `THz`) {
 }
 // Normalize DOS densities according to specified mode.
 export function normalize_densities(densities, freqs_or_energies, mode) {
-    if (!mode)
-        return densities;
-    const normalized = [...densities];
     if (mode === `max`) {
-        const max_val = Math.max(...normalized);
-        if (max_val === 0)
-            return normalized;
-        return normalized.map((dens) => dens / max_val);
+        const max_val = Math.max(...densities);
+        return max_val === 0 ? densities : densities.map((dens) => dens / max_val);
     }
-    else if (mode === `sum`) {
-        const sum = normalized.reduce((acc, dens) => acc + dens, 0);
-        if (sum === 0)
-            return normalized;
-        return normalized.map((dens) => dens / sum);
+    if (mode === `sum`) {
+        const sum = densities.reduce((acc, dens) => acc + dens, 0);
+        return sum === 0 ? densities : densities.map((dens) => dens / sum);
     }
-    else if (mode === `integral`) {
+    if (mode === `integral`) {
         if (freqs_or_energies.length < 2)
-            return normalized;
+            return densities;
         const bin_width = freqs_or_energies[1] - freqs_or_energies[0];
-        if (bin_width === 0)
-            return normalized;
-        const sum = normalized.reduce((acc, dens) => acc + dens, 0);
-        if (sum === 0)
-            return normalized;
-        return normalized.map((dens) => dens / (sum * bin_width));
+        const sum = densities.reduce((acc, dens) => acc + dens, 0);
+        if (bin_width === 0 || sum === 0)
+            return densities;
+        return densities.map((dens) => dens / (sum * bin_width));
     }
-    return normalized;
+    return densities;
 }
 // Simple LRU cache for Gaussian smearing results
 // Key: hash of (frequencies, densities, sigma), Value: smeared densities
@@ -255,18 +246,16 @@ function apply_gaussian_smearing_core(freqs_or_energies, densities, sigma) {
     if (sigma <= 0 || orig_sum === 0)
         return densities;
     const smeared = Array(densities.length).fill(0);
-    const truncation_width = 4; // Truncate Gaussian at ±4σ (contribution < 0.01%)
+    const cutoff = 4 * sigma; // Truncate Gaussian at ±4σ (contribution < 0.01%)
+    const inv_two_sigma_sq = 1 / (2 * sigma ** 2);
     for (let idx = 0; idx < freqs_or_energies.length; idx++) {
         const energy = freqs_or_energies[idx];
-        const cutoff = truncation_width * sigma;
         for (let jdx = 0; jdx < freqs_or_energies.length; jdx++) {
-            const e_j = freqs_or_energies[jdx];
-            const delta = Math.abs(energy - e_j);
+            const delta = energy - freqs_or_energies[jdx];
             // Skip points beyond truncation width
-            if (delta > cutoff)
+            if (Math.abs(delta) > cutoff)
                 continue;
-            const gaussian = Math.exp(-((energy - e_j) ** 2) / (2 * sigma ** 2));
-            smeared[idx] += densities[jdx] * gaussian;
+            smeared[idx] += densities[jdx] * Math.exp(-(delta ** 2) * inv_two_sigma_sq);
         }
     }
     // Normalize to preserve integral
@@ -347,35 +336,15 @@ const SPIN_DOWN_KEYS = [`-1`, `Spin.down`];
 export function extract_spin_channels(data) {
     if (Array.isArray(data))
         return { up: data, down: null };
-    if (data && typeof data === `object`) {
-        const record = data;
-        let spin_up = null;
-        let spin_down = null;
-        // Extract spin-up channel
-        for (const key of SPIN_UP_KEYS) {
-            if (key in record) {
-                spin_up = record[key];
-                break;
-            }
-        }
-        // Extract spin-down channel
-        for (const key of SPIN_DOWN_KEYS) {
-            if (key in record) {
-                spin_down = record[key];
-                break;
-            }
-        }
-        // Fall back to first key if no spin-up key found
-        if (spin_up === null) {
-            const keys = Object.keys(record);
-            if (keys.length > 0)
-                spin_up = record[keys[0]];
-        }
-        if (spin_up === null)
-            return null;
-        return { up: spin_up, down: spin_down };
-    }
-    return null;
+    if (!data || typeof data !== `object`)
+        return null;
+    const record = data;
+    const up_key = SPIN_UP_KEYS.find((key) => key in record);
+    const down_key = SPIN_DOWN_KEYS.find((key) => key in record);
+    // No spin-up key: do not fall back to Object.keys()[0] (could be spin-down)
+    if (up_key === undefined)
+        return null;
+    return { up: record[up_key], down: down_key !== undefined ? record[down_key] : null };
 }
 // Convert pymatgen PhononBandStructureSymmLine or BandStructure to matterviz format
 function convert_pymatgen_band_structure(pmg) {
@@ -651,6 +620,8 @@ export function find_qpoint_at_distance(band_struct, target) {
         return null;
     return distance.reduce((closest, dist, idx) => Math.abs(dist - target) < Math.abs(distance[closest] - target) ? idx : closest, 0);
 }
+// Look up a branch's x-range in the plot via its start/end q-point labels
+const branch_x_range = (bs, branch, x_positions) => x_positions[get_segment_key(bs.qpoints[branch.start_index]?.label ?? undefined, bs.qpoints[branch.end_index]?.label ?? undefined)];
 // Rescaled x-position of a q-point index along the band plot path. Inverse of
 // find_qpoint_at_rescaled_x, used to highlight a q-point hovered in the Brillouin zone.
 // Returns null if the index doesn't fall on a plotted (non-discontinuity) branch.
@@ -660,9 +631,7 @@ export function qpoint_x_position(band_struct, qpoint_index, x_positions) {
     for (const branch of band_struct.branches) {
         if (qpoint_index < branch.start_index || qpoint_index > branch.end_index)
             continue;
-        const start_label = band_struct.qpoints[branch.start_index]?.label ?? undefined;
-        const end_label = band_struct.qpoints[branch.end_index]?.label ?? undefined;
-        const range = x_positions[get_segment_key(start_label, end_label)];
+        const range = branch_x_range(band_struct, branch, x_positions);
         if (!range)
             continue;
         const [x_start, x_end] = range;
@@ -682,74 +651,50 @@ export function find_qpoint_at_rescaled_x(band_struct, rescaled_x, x_positions)
         return null;
     // Find which segment contains this x coordinate
     for (const branch of band_struct.branches) {
-        const start_idx = branch.start_index;
-        const end_idx = branch.end_index;
-        const start_label = band_struct.qpoints[start_idx]?.label ?? undefined;
-        const end_label = band_struct.qpoints[end_idx]?.label ?? undefined;
-        const segment_key = get_segment_key(start_label, end_label);
-        const segment_range = x_positions[segment_key];
+        const { start_index: start_idx, end_index: end_idx } = branch;
+        const segment_range = branch_x_range(band_struct, branch, x_positions);
         if (!segment_range)
             continue;
         const [x_start, x_end] = segment_range;
-        // Check if discontinuity (zero-length segment)
-        const is_discontinuity = Math.abs(x_end - x_start) < 1e-6;
-        if (is_discontinuity) {
-            // For discontinuities, check if x is exactly at this point
-            if (Math.abs(rescaled_x - x_start) < 1e-6) {
+        // Discontinuity (zero-length segment): match only if x is exactly at this point
+        if (Math.abs(x_end - x_start) < 1e-6) {
+            if (Math.abs(rescaled_x - x_start) < 1e-6)
                 return start_idx;
-            }
             continue;
         }
         // Check if x is within this segment (with small tolerance for edges)
         if (rescaled_x >= x_start - 1e-6 && rescaled_x <= x_end + 1e-6) {
             // Map from rescaled x back to original distance
-            const segment_distances = band_struct.distance.slice(start_idx, end_idx + 1);
-            const dist_min = segment_distances[0];
-            const dist_max = segment_distances.at(-1) ?? dist_min;
-            const dist_range = dist_max - dist_min;
-            // Handle zero-length segments
-            if (dist_range === 0) {
+            const dist_min = band_struct.distance[start_idx];
+            const dist_range = band_struct.distance[end_idx] - dist_min;
+            if (dist_range === 0)
                 return start_idx;
-            }
             // Inverse of the scaling: x = x_start + ((dist - dist_min) / dist_range) * (x_end - x_start)
-            // Solving for dist: dist = dist_min + ((x - x_start) / (x_end - x_start)) * dist_range
             const normalized_x = (rescaled_x - x_start) / (x_end - x_start);
             const target_dist = dist_min + normalized_x * dist_range;
             // Find closest qpoint in this branch to the target distance
-            let closest_idx = start_idx;
-            let min_diff = Math.abs(band_struct.distance[start_idx] - target_dist);
+            let [closest_idx, min_diff] = [start_idx, Infinity];
             for (let idx = start_idx; idx <= end_idx; idx++) {
                 const diff = Math.abs(band_struct.distance[idx] - target_dist);
-                if (diff < min_diff) {
-                    min_diff = diff;
-                    closest_idx = idx;
-                }
+                if (diff < min_diff)
+                    [closest_idx, min_diff] = [idx, diff];
             }
             return closest_idx;
         }
     }
     // Fallback: find closest labeled point
-    let closest_idx = 0;
-    let min_dist = Infinity;
+    let [closest_idx, min_dist] = [0, Infinity];
     for (const branch of band_struct.branches) {
-        const start_idx = branch.start_index;
-        const end_idx = branch.end_index;
-        const start_label = band_struct.qpoints[start_idx]?.label ?? undefined;
-        const end_label = band_struct.qpoints[end_idx]?.label ?? undefined;
-        const segment_key = get_segment_key(start_label, end_label);
-        const segment_range = x_positions[segment_key];
+        const segment_range = branch_x_range(band_struct, branch, x_positions);
         if (!segment_range)
             continue;
-        const [x_start, x_end] = segment_range;
         for (const [x_pos, idx] of [
-            [x_start, start_idx],
-            [x_end, end_idx],
+            [segment_range[0], branch.start_index],
+            [segment_range[1], branch.end_index],
         ]) {
             const dist = Math.abs(rescaled_x - x_pos);
-            if (dist < min_dist) {
-                min_dist = dist;
-                closest_idx = idx;
-            }
+            if (dist < min_dist)
+                [closest_idx, min_dist] = [idx, dist];
         }
     }
     return closest_idx;
@@ -802,24 +747,15 @@ const shift_dos_energies = (dos, shift) => ({
 // Recursively shifts nested DOS in atom_dos and spd_dos for consistency
 export function shift_to_fermi(dos) {
     const shift = dos.efermi;
-    // Shift root DOS energies using the shared helper
-    const shifted_root = shift_dos_energies(dos, shift);
-    // Shift nested atom_dos if present
-    const atom_dos = dos.atom_dos
-        ? Object.fromEntries(Object.entries(dos.atom_dos).map(([key, nested_dos]) => [
-            key,
-            shift_dos_energies(nested_dos, shift),
-        ]))
-        : undefined;
-    // Shift nested spd_dos if present
-    const spd_dos = dos.spd_dos
-        ? Object.fromEntries(Object.entries(dos.spd_dos).map(([key, nested_dos]) => [
+    const shift_nested = (nested) => nested &&
+        Object.fromEntries(Object.entries(nested).map(([key, nested_dos]) => [
             key,
             shift_dos_energies(nested_dos, shift),
-        ]))
-        : undefined;
+        ]));
+    const atom_dos = shift_nested(dos.atom_dos);
+    const spd_dos = shift_nested(dos.spd_dos);
     return {
-        ...shifted_root,
+        ...shift_dos_energies(dos, shift),
         efermi: 0, // Explicitly set to 0 (shift_dos_energies would give efermi - shift)
         ...(atom_dos && { atom_dos }),
         ...(spd_dos && { spd_dos }),
@@ -916,26 +852,14 @@ export function compute_frequency_range(band_structs, doses, padding_factor = 0.
     const all_freqs = [];
     // Check raw band_structs for electronic markers before normalization
     // (normalized structures always have qpoints, so we can't detect from them)
-    let has_electronic_bs = false;
     // Support both qpoints (phonon) and kpoints (electronic) to detect single vs dict
     const is_single_bs = band_structs &&
         typeof band_structs === `object` &&
         (`qpoints` in band_structs || `kpoints` in band_structs);
-    if (band_structs && typeof band_structs === `object`) {
-        // Single structure check
-        if (is_electronic_band_struct(band_structs)) {
-            has_electronic_bs = true;
-        }
-        else if (!is_single_bs) {
-            // Dict of band structures - check each value
-            for (const bs_val of Object.values(band_structs)) {
-                if (is_electronic_band_struct(bs_val)) {
-                    has_electronic_bs = true;
-                    break;
-                }
-            }
-        }
-    }
+    const has_electronic_bs = band_structs &&
+        typeof band_structs === `object` &&
+        (is_electronic_band_struct(band_structs) ||
+            (!is_single_bs && Object.values(band_structs).some(is_electronic_band_struct)));
     const bs_list = band_structs
         ? is_single_bs
             ? [normalize_band_structure(band_structs)]
@@ -958,7 +882,7 @@ export function compute_frequency_range(band_structs, doses, padding_factor = 0.
             }
         }
     }
-    const dos_list = doses
+    const dos_list = doses && typeof doses === `object`
         ? `densities` in doses
             ? [normalize_dos(doses)]
             : Object.values(doses).map((dos) => normalize_dos(dos))
@@ -981,18 +905,19 @@ export function compute_frequency_range(band_structs, doses, padding_factor = 0.
     }
     if (!Number.isFinite(min_val) || !Number.isFinite(max_val))
         return undefined;
-    const clamp_min = is_phonon &&
-        min_val < 0 && // clamp phonon noise to 0
-        negative_fraction(all_freqs) < IMAGINARY_MODE_NOISE_THRESHOLD;
-    if (clamp_min)
+    // clamp phonon noise to 0
+    if (is_phonon &&
+        min_val < 0 &&
+        negative_fraction(all_freqs) < IMAGINARY_MODE_NOISE_THRESHOLD) {
         min_val = 0;
+    }
     // Calculate padding from (possibly clamped) range for consistency with Bands.svelte
     const padding = (max_val - min_val) * padding_factor;
     return [min_val === 0 ? 0 : min_val - padding, max_val + padding];
 }
 // Parse axis label: "Frequency (THz)" → { name: "Frequency", unit: "THz" }
 function parse_axis_label(label) {
-    const match = /^(.+?)\s*\(([^)]+)\)$/.exec(label);
+    const match = /^(?<name>.+?)\s*\((?<unit>[^)]+)\)$/.exec(label);
     return match ? { name: match[1], unit: match[2] } : { name: label };
 }
 const format_tooltip_line = (name, value, unit) => `${name}: ${value}${unit ? ` ${unit}` : ``}`;

package/dist/state.svelte.js

@@ -1,6 +1,6 @@
 import { AUTO_THEME, COLOR_THEMES, THEME_TYPE } from './theme/index';
 import { DEFAULT_CATEGORY_COLORS, default_element_colors } from './colors';
-import { is_valid_theme_mode } from './theme';
+import { get_theme_preference } from './theme';
 export const selected = $state({
     category: null,
     element: null,
@@ -11,23 +11,10 @@ export const colors = $state({
     category: { ...DEFAULT_CATEGORY_COLORS },
     element: { ...default_element_colors },
 });
-// Theme state with safe initialization
-let initial_theme_mode = AUTO_THEME;
-let initial_system_mode = COLOR_THEMES.light;
-// Safe theme initialization for test environments
-try {
-    if (typeof window !== `undefined` && globalThis.localStorage) {
-        const saved_theme = localStorage.getItem(`matterviz-theme`) ?? ``;
-        initial_theme_mode = is_valid_theme_mode(saved_theme) ? saved_theme : AUTO_THEME;
-    }
-    else {
-        initial_theme_mode = AUTO_THEME;
-        initial_system_mode = COLOR_THEMES.light;
-    }
-}
-catch {
-    // Fallback for test environments or when localStorage is not available
-}
+// Theme state with safe initialization (get_theme_preference handles SSR +
+// missing/invalid localStorage, falling back to AUTO_THEME)
+const initial_theme_mode = get_theme_preference();
+const initial_system_mode = COLOR_THEMES.light;
 export const theme_state = $state({
     mode: initial_theme_mode,
     system_mode: initial_system_mode,

package/dist/structure/Arrow.svelte

@@ -4,7 +4,7 @@
   import { DEFAULTS } from '../settings'
   import { T } from '@threlte/core'
   import type { ComponentProps } from 'svelte'
-  import { Euler, Quaternion, Vector3 } from 'three'
+  import { rotation_from_direction } from './geometry'
 
   let {
     position,
@@ -26,35 +26,22 @@
   } = $props()
 
   const mag = $derived(Math.hypot(...vector))
-  const dir = $derived(
-    mag > math.EPS ? math.scale(vector, 1 / mag) : ([0, 1, 0] as Vec3),
-  )
+  const dir = $derived(mag > math.EPS ? math.scale(vector, 1 / mag) : ([0, 1, 0] as Vec3))
   const vec_len = $derived(mag * scale)
 
   const head_len = $derived(
     arrow_head_length < 0 ? vec_len * -arrow_head_length : arrow_head_length,
   )
   const shaft_len = $derived(Math.max(0, vec_len - head_len * 0.5))
-  const shaft_r = $derived(
-    shaft_radius < 0 ? shaft_len * -shaft_radius : shaft_radius,
-  )
+  const shaft_r = $derived(shaft_radius < 0 ? shaft_len * -shaft_radius : shaft_radius)
   const head_r = $derived(
     arrow_head_radius < 0 ? shaft_len * -arrow_head_radius : arrow_head_radius,
   )
 
   const shaft_pos = $derived(math.add(position, math.scale(dir, shaft_len * 0.5)))
-  const head_pos = $derived(
-    math.add(position, math.scale(dir, shaft_len + head_len * 0.5)),
-  )
+  const head_pos = $derived(math.add(position, math.scale(dir, shaft_len + head_len * 0.5)))
 
-  const rotation = $derived.by((): Vec3 => {
-    if (mag < math.EPS) return [0, 0, 0]
-    const quat = new Quaternion().setFromUnitVectors(
-      new Vector3(0, 1, 0),
-      new Vector3(...dir),
-    )
-    return new Euler().setFromQuaternion(quat).toArray().slice(0, 3) as Vec3
-  })
+  const rotation = $derived(rotation_from_direction(vector))
 </script>
 
 {#if shaft_len > 0.01}

package/dist/structure/ArrowInstances.svelte

@@ -0,0 +1,160 @@
+<script lang="ts">
+  // Instanced arrows (shaft cylinders + head cones) for per-site vector layers
+  // (forces, magnetic moments, ...). Replaces one <Arrow> component per site
+  // (2 meshes + 2 geometries + 2 materials each) with 2 draw calls per layer.
+  // Sizing math mirrors Arrow.svelte so the two render identically.
+  import type { Vec3 } from '../math'
+  import { EPS } from '../math'
+  import { T, useThrelte } from '@threlte/core'
+  import { untrack } from 'svelte'
+  import type { BufferGeometry } from 'three'
+  import {
+    Color,
+    ConeGeometry,
+    CylinderGeometry,
+    InstancedMesh,
+    Matrix4,
+    MeshStandardMaterial,
+    Quaternion,
+    Vector3,
+  } from 'three'
+
+  type ArrowInstance = {
+    position: Vec3
+    vector: Vec3
+    scale: number
+    color: string
+  }
+
+  let {
+    arrows,
+    shaft_radius,
+    arrow_head_radius,
+    arrow_head_length,
+  }: {
+    arrows: ArrowInstance[]
+    shaft_radius: number // negative = relative to shaft length
+    arrow_head_radius: number // negative = relative to shaft length
+    arrow_head_length: number // negative = relative to arrow length
+  } = $props()
+
+  const { invalidate } = useThrelte()
+
+  // Unit primitives scaled per instance: cylinder radius/length via (x=r, y=len, z=r)
+  const shaft_geometry = new CylinderGeometry(1, 1, 1, 12)
+  const head_geometry = new ConeGeometry(1, 1, 12)
+  const shaft_material = new MeshStandardMaterial()
+  const head_material = new MeshStandardMaterial()
+  $effect(() => () => {
+    shaft_geometry.dispose()
+    head_geometry.dispose()
+    shaft_material.dispose()
+    head_material.dispose()
+  })
+
+  const make_mesh = (
+    geometry: BufferGeometry,
+    material: MeshStandardMaterial,
+    count: number,
+  ): InstancedMesh => {
+    const mesh = new InstancedMesh(geometry, material, count)
+    mesh.frustumCulled = false
+    mesh.raycast = () => undefined // arrows are display-only
+    mesh.userData.per_instance_color = true
+    return mesh
+  }
+
+  // Recreate meshes only when the arrow count changes (fixed buffer capacity)
+  let shaft_mesh = $state.raw<InstancedMesh | null>(null)
+  let head_mesh = $state.raw<InstancedMesh | null>(null)
+  $effect(() => {
+    const count = arrows.length
+    const prev = untrack(() => shaft_mesh)
+    if (prev && prev.count === count) return
+    prev?.dispose()
+    untrack(() => head_mesh)?.dispose()
+    if (count === 0) {
+      shaft_mesh = null
+      head_mesh = null
+      return
+    }
+    shaft_mesh = make_mesh(shaft_geometry, shaft_material, count)
+    head_mesh = make_mesh(head_geometry, head_material, count)
+  })
+  // Unmount-only cleanup (a cleanup on the effect above would dispose meshes
+  // on every re-run, including runs that keep them; cleanups run untracked)
+  $effect(() => () => {
+    shaft_mesh?.dispose()
+    head_mesh?.dispose()
+  })
+
+  const up_axis = new Vector3(0, 1, 0)
+  const scratch_dir = new Vector3()
+  const scratch_quat = new Quaternion()
+  const scratch_pos = new Vector3()
+  const scratch_scale = new Vector3()
+  const scratch_matrix = new Matrix4()
+  const scratch_color = new Color()
+
+  $effect(() => {
+    const shafts = shaft_mesh
+    const heads = head_mesh
+    if (!shafts || !heads) return
+    const limit = Math.min(arrows.length, shafts.count)
+    for (let idx = 0; idx < limit; idx++) {
+      const { position, vector, scale, color } = arrows[idx]
+      const mag = Math.hypot(vector[0], vector[1], vector[2])
+      if (mag > EPS) {
+        scratch_dir.set(vector[0] / mag, vector[1] / mag, vector[2] / mag)
+        scratch_quat.setFromUnitVectors(up_axis, scratch_dir)
+      } else {
+        scratch_dir.set(0, 1, 0)
+        scratch_quat.identity()
+      }
+      const vec_len = mag * scale
+      const head_len = arrow_head_length < 0 ? vec_len * -arrow_head_length : arrow_head_length
+      const shaft_len = Math.max(0, vec_len - head_len * 0.5)
+      const shaft_r = shaft_radius < 0 ? shaft_len * -shaft_radius : shaft_radius
+      const head_r = arrow_head_radius < 0 ? shaft_len * -arrow_head_radius : arrow_head_radius
+
+      // Shafts shorter than Arrow.svelte's 0.01 render threshold collapse to zero scale
+      const draw_shaft = shaft_len > 0.01
+      scratch_pos.set(
+        position[0] + scratch_dir.x * shaft_len * 0.5,
+        position[1] + scratch_dir.y * shaft_len * 0.5,
+        position[2] + scratch_dir.z * shaft_len * 0.5,
+      )
+      scratch_scale.set(
+        draw_shaft ? shaft_r : 0,
+        draw_shaft ? shaft_len : 0,
+        draw_shaft ? shaft_r : 0,
+      )
+      shafts.setMatrixAt(idx, scratch_matrix.compose(scratch_pos, scratch_quat, scratch_scale))
+
+      const head_offset = shaft_len + head_len * 0.5
+      scratch_pos.set(
+        position[0] + scratch_dir.x * head_offset,
+        position[1] + scratch_dir.y * head_offset,
+        position[2] + scratch_dir.z * head_offset,
+      )
+      scratch_scale.set(head_r, head_len, head_r)
+      heads.setMatrixAt(idx, scratch_matrix.compose(scratch_pos, scratch_quat, scratch_scale))
+
+      scratch_color.set(color)
+      shafts.setColorAt(idx, scratch_color)
+      heads.setColorAt(idx, scratch_color)
+    }
+    for (const mesh of [shafts, heads]) {
+      mesh.instanceMatrix.needsUpdate = true
+      if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true
+    }
+    invalidate()
+  })
+</script>
+
+{#if shaft_mesh}
+  <T is={shaft_mesh} />
+{/if}
+{#if head_mesh}
+  <T is={head_mesh} />
+{/if}

package/dist/structure/ArrowInstances.svelte.d.ts

@@ -0,0 +1,16 @@
+import type { Vec3 } from '../math';
+type ArrowInstance = {
+    position: Vec3;
+    vector: Vec3;
+    scale: number;
+    color: string;
+};
+type $$ComponentProps = {
+    arrows: ArrowInstance[];
+    shaft_radius: number;
+    arrow_head_radius: number;
+    arrow_head_length: number;
+};
+declare const ArrowInstances: import("svelte").Component<$$ComponentProps, {}, "">;
+type ArrowInstances = ReturnType<typeof ArrowInstances>;
+export default ArrowInstances;