matterviz 0.1.12 → 0.1.13

package/dist/brillouin/BrillouinZoneInfoPane.svelte

@@ -0,0 +1,115 @@
+<script lang="ts">import { DraggablePane } from '..';
+import { format_num } from '../labels';
+import { analyze_structure_symmetry } from '../symmetry';
+let { pane_open = $bindable(false), structure, bz_data, pane_props = {}, } = $props();
+let sym_data = $state(null);
+$effect(() => {
+    sym_data = null;
+    if (!pane_open || !structure || !(`lattice` in structure))
+        return;
+    analyze_structure_symmetry(structure)
+        .then((data) => (sym_data = data))
+        .catch(console.error);
+});
+let pane_data = $derived.by(() => {
+    if (!structure || !bz_data)
+        return [];
+    const sections = [];
+    // Brillouin Zone section
+    const bz_order_suffix = [`st`, `nd`, `rd`][bz_data.order - 1] ?? `th`;
+    sections.push({
+        title: `Brillouin Zone`,
+        items: [
+            {
+                label: `Order`,
+                value: `${bz_data.order}${bz_order_suffix}`,
+                key: `bz-order`,
+            },
+            {
+                label: `Volume`,
+                value: `${format_num(bz_data.volume, `.3f`)} Å⁻³`,
+                key: `bz-volume`,
+            },
+            {
+                label: `Vertices / Faces`,
+                value: `${bz_data.vertices.length} / ${bz_data.faces.length}`,
+                key: `bz-vertices`,
+            },
+            {
+                label: `Space Group`,
+                value: `${sym_data?.number ?? ``} ${sym_data?.hm_symbol ? `(${sym_data.hm_symbol})` : ``}`.trim(),
+                key: `space-group`,
+            },
+        ],
+    });
+    // Real Lattice section
+    sections.push({
+        title: `Real Lattice`,
+        items: [
+            {
+                label: `a, b, c`,
+                value: `${[structure.lattice.a, structure.lattice.b, structure.lattice.c]
+                    .map((v) => format_num(v, `.3~f`))
+                    .join(`, `)} Å`,
+                key: `real-lattice-abc`,
+            },
+            {
+                label: `α, β, γ`,
+                value: `${[structure.lattice.alpha, structure.lattice.beta, structure.lattice.gamma]
+                    .map((v) => format_num(v, `.2~f`))
+                    .join(`, `)}°`,
+                key: `real-lattice-angles`,
+            },
+        ],
+    });
+    // Reciprocal Lattice section
+    const k_lattice_items = bz_data.k_lattice.map((vec, idx) => ({
+        label: [`b₁`, `b₂`, `b₃`][idx],
+        value: `(${vec.map((x) => format_num(x, `.3~f`)).join(`, `)})`,
+        key: `reciprocal-${[`b1`, `b2`, `b3`][idx]}`,
+    }));
+    sections.push({ title: `Reciprocal Lattice (Å⁻¹)`, items: k_lattice_items });
+    return sections;
+});
+</script>
+
+{#if structure && bz_data}
+  <DraggablePane
+    bind:show={pane_open}
+    closed_icon="Info"
+    open_icon="Cross"
+    toggle_props={{ class: `bz-info-toggle`, title: `Brillouin zone info` }}
+    pane_props={{ ...pane_props, class: `bz-info-pane ${pane_props?.class ?? ``}` }}
+  >
+    {#each pane_data as section, sec_idx (section.title)}
+      {#if sec_idx > 0}<hr />{/if}
+      <section>
+        <h4>{section.title}</h4>
+        {#each section.items as item (item.key ?? item.label)}
+          <div class="info-item">
+            <span>{item.label}</span>
+            <span>{@html item.value}</span>
+          </div>
+        {/each}
+      </section>
+    {/each}
+  </DraggablePane>
+{/if}
+
+<style>
+  section div.info-item {
+    display: flex;
+    justify-content: space-between;
+    gap: 6pt;
+    padding: 1pt;
+    line-height: 1.5;
+  }
+  h4 {
+    margin: 0.5em 0;
+  }
+  hr {
+    border: none;
+    border-top: 1px solid var(--divider-color, rgba(128, 128, 128, 0.2));
+    margin: 0.5em 0;
+  }
+</style>

package/dist/brillouin/BrillouinZoneInfoPane.svelte.d.ts

@@ -0,0 +1,13 @@
+import { DraggablePane } from '..';
+import type { PymatgenStructure } from '../structure';
+import type { ComponentProps } from 'svelte';
+import type { BrillouinZoneData } from './types';
+type $$ComponentProps = {
+    pane_open?: boolean;
+    structure?: PymatgenStructure;
+    bz_data?: BrillouinZoneData;
+    pane_props?: ComponentProps<typeof DraggablePane>[`pane_props`];
+};
+declare const BrillouinZoneInfoPane: import("svelte").Component<$$ComponentProps, {}, "pane_open">;
+type BrillouinZoneInfoPane = ReturnType<typeof BrillouinZoneInfoPane>;
+export default BrillouinZoneInfoPane;

package/dist/brillouin/BrillouinZoneScene.svelte

@@ -0,0 +1,180 @@
+<script lang="ts">import { axis_colors, neg_axis_colors } from '..';
+import { DEFAULTS } from '../settings';
+import { Cylinder, Vector } from '../structure';
+import { T, useThrelte } from '@threlte/core';
+import * as extras from '@threlte/extras';
+import { BufferAttribute, BufferGeometry } from 'three';
+let { bz_data = $bindable(undefined), camera_position = $bindable(undefined), camera_projection = $bindable(`perspective`), surface_color = $bindable(`#4488ff`), surface_opacity = $bindable(0.3), edge_color = $bindable(`#000000`), edge_width = $bindable(0.05), show_vectors = $bindable(true), vector_scale = $bindable(1.0), rotation_damping = DEFAULTS.structure.rotation_damping, max_zoom = DEFAULTS.structure.max_zoom, min_zoom = DEFAULTS.structure.min_zoom, zoom_speed = DEFAULTS.structure.zoom_speed, pan_speed = DEFAULTS.structure.pan_speed, fov = DEFAULTS.structure.fov, initial_zoom = DEFAULTS.structure.initial_zoom, ambient_light = DEFAULTS.structure.ambient_light, directional_light = DEFAULTS.structure.directional_light, gizmo = DEFAULTS.structure.show_gizmo, auto_rotate = DEFAULTS.structure.auto_rotate, camera_is_moving = $bindable(false), scene = $bindable(undefined), camera = $bindable(undefined), } = $props();
+const threlte = useThrelte();
+$effect(() => {
+    scene = threlte.scene;
+    camera = threlte.camera.current;
+});
+extras.interactivity();
+const rotation_target = [0, 0, 0];
+// BZ size for camera positioning: average magnitude of k-vectors
+const bz_size = $derived.by(() => {
+    if (!bz_data?.k_lattice)
+        return 10;
+    const mags = bz_data.k_lattice.map((v) => Math.sqrt(v[0] ** 2 + v[1] ** 2 + v[2] ** 2));
+    return mags.reduce((sum, mag) => sum + mag, 0) / 3;
+});
+const computed_camera_position = $derived.by(() => camera_position || [10, 3, 8].map((x) => x * Math.max(1, bz_size)));
+const gizmo_props = $derived.by(() => ({
+    background: { enabled: false },
+    className: `responsive-gizmo`,
+    ...Object.fromEntries([...axis_colors, ...neg_axis_colors].map(([axis, color, hover]) => [
+        axis,
+        {
+            color,
+            labelColor: `#111`,
+            opacity: axis.startsWith(`n`) ? 0.9 : 0.8,
+            hover: {
+                color: hover,
+                labelColor: `#222`,
+                opacity: axis.startsWith(`n`) ? 1 : 0.9,
+            },
+        },
+    ])),
+    ...(typeof gizmo === `object` ? gizmo : {}),
+    offset: { left: 5, bottom: 5 },
+}));
+const is_ortho = $derived(camera_projection === `orthographic`);
+const orbit_controls_props = $derived({
+    position: [0, 0, 0],
+    target: rotation_target,
+    enableZoom: zoom_speed > 0,
+    zoomSpeed: is_ortho ? zoom_speed * 2 : zoom_speed,
+    enablePan: pan_speed > 0,
+    panSpeed: pan_speed,
+    maxZoom: is_ortho ? max_zoom || 200 : max_zoom,
+    minZoom: is_ortho ? min_zoom || 0.1 : min_zoom,
+    autoRotate: Boolean(auto_rotate),
+    autoRotateSpeed: auto_rotate,
+    enableDamping: Boolean(rotation_damping),
+    dampingFactor: rotation_damping,
+    onstart: () => (camera_is_moving = true),
+    onend: () => (camera_is_moving = false),
+});
+const vector_colors = [`red`, `green`, `blue`];
+const vector_labels = [`b₁`, `b₂`, `b₃`];
+// Create BZ mesh geometry from faces with fan triangulation
+const bz_geometry = $derived.by(() => {
+    if (!bz_data || bz_data.faces.length === 0)
+        return null;
+    const positions = [];
+    const normals = [];
+    for (const face of bz_data.faces) {
+        if (face.length < 3)
+            continue;
+        for (let i = 1; i < face.length - 1; i++) {
+            const indices = [face[0], face[i], face[i + 1]];
+            if (indices.some((idx) => idx < 0 || idx >= bz_data.vertices.length))
+                continue;
+            const [v0, v1, v2] = indices.map((idx) => bz_data.vertices[idx]);
+            positions.push(...v0, ...v1, ...v2);
+            // Compute normal via cross product
+            const [e1, e2] = [[v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]], [
+                    v2[0] - v0[0],
+                    v2[1] - v0[1],
+                    v2[2] - v0[2],
+                ]];
+            const n = [
+                e1[1] * e2[2] - e1[2] * e2[1],
+                e1[2] * e2[0] - e1[0] * e2[2],
+                e1[0] * e2[1] - e1[1] * e2[0],
+            ];
+            const len = Math.sqrt(n[0] ** 2 + n[1] ** 2 + n[2] ** 2);
+            const norm = len > 1e-10 ? n.map((x) => x / len) : [0, 0, 0];
+            normals.push(...norm, ...norm, ...norm);
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute(`position`, new BufferAttribute(new Float32Array(positions), 3));
+    geometry.setAttribute(`normal`, new BufferAttribute(new Float32Array(normals), 3));
+    geometry.computeBoundingSphere();
+    return geometry;
+});
+$effect(() => {
+    return () => bz_geometry?.dispose();
+});
+</script>
+
+{#if camera_projection === `perspective`}
+  <T.PerspectiveCamera makeDefault position={computed_camera_position} {fov}>
+    <extras.OrbitControls {...orbit_controls_props}>
+      {#if gizmo}<extras.Gizmo {...gizmo_props} />{/if}
+    </extras.OrbitControls>
+  </T.PerspectiveCamera>
+{:else}
+  <T.OrthographicCamera
+    makeDefault
+    position={computed_camera_position}
+    zoom={initial_zoom}
+    near={-100}
+  >
+    <extras.OrbitControls {...orbit_controls_props}>
+      {#if gizmo}<extras.Gizmo {...gizmo_props} />{/if}
+    </extras.OrbitControls>
+  </T.OrthographicCamera>
+{/if}
+
+<T.DirectionalLight position={[3, 10, 10]} intensity={directional_light} />
+<T.AmbientLight intensity={ambient_light} />
+
+<T.Group position={rotation_target}>
+  {#if bz_data}
+    <!-- Brillouin zone surface mesh -->
+    {#if bz_geometry}
+      <T.Mesh geometry={bz_geometry}>
+        <T.MeshStandardMaterial
+          color={surface_color}
+          transparent
+          opacity={surface_opacity}
+          side={2}
+          depthWrite={false}
+        />
+      </T.Mesh>
+    {/if}
+
+    <!-- BZ edges -->
+    {#each bz_data.edges as edge_segment (edge_segment.map((v) => v.join(`,`)).join(`-`))}
+      <Cylinder
+        from={edge_segment[0]}
+        to={edge_segment[1]}
+        thickness={edge_width}
+        color={edge_color}
+      />
+    {/each}
+
+    <!-- Reciprocal lattice vectors -->
+    {#if show_vectors && bz_data.k_lattice}
+      {#each bz_data.k_lattice as vec, idx (idx)}
+        {@const scaled_vec = vec.map((x) => x * vector_scale) as Vec3}
+        {@const label_position = scaled_vec.map((x) => x * 1.15) as Vec3}
+        <Vector
+          position={[0, 0, 0]}
+          vector={scaled_vec}
+          color={vector_colors[idx]}
+          scale={1}
+        />
+        <!-- Vector label beyond tip -->
+        <extras.HTML center position={label_position}>
+          <span
+            style:color={vector_colors[idx]}
+            style:font-size="1.2em"
+          >
+            {vector_labels[idx]}
+          </span>
+        </extras.HTML>
+      {/each}
+    {/if}
+  {/if}
+</T.Group>
+
+<style>
+  :global(.brillouin-zone .responsive-gizmo) {
+    width: clamp(70px, 18cqmin, 100px) !important;
+    height: clamp(70px, 18cqmin, 100px) !important;
+  }
+</style>

package/dist/brillouin/BrillouinZoneScene.svelte.d.ts

@@ -0,0 +1,34 @@
+import type { Vec3 } from '..';
+import { type CameraProjection } from '../settings';
+import * as extras from '@threlte/extras';
+import type { ComponentProps } from 'svelte';
+import { type Camera, type Scene } from 'three';
+import type { BrillouinZoneData } from './types';
+type $$ComponentProps = {
+    bz_data?: BrillouinZoneData;
+    camera_position?: Vec3 | undefined;
+    camera_projection?: CameraProjection;
+    surface_color?: string;
+    surface_opacity?: number;
+    edge_color?: string;
+    edge_width?: number;
+    show_vectors?: boolean;
+    vector_scale?: number;
+    rotation_damping?: number;
+    max_zoom?: number;
+    min_zoom?: number;
+    zoom_speed?: number;
+    pan_speed?: number;
+    fov?: number;
+    initial_zoom?: number;
+    ambient_light?: number;
+    directional_light?: number;
+    gizmo?: boolean | ComponentProps<typeof extras.Gizmo>;
+    auto_rotate?: number;
+    camera_is_moving?: boolean;
+    scene?: Scene;
+    camera?: Camera;
+};
+declare const BrillouinZoneScene: import("svelte").Component<$$ComponentProps, {}, "camera" | "camera_position" | "camera_projection" | "scene" | "camera_is_moving" | "surface_color" | "surface_opacity" | "edge_color" | "edge_width" | "show_vectors" | "bz_data" | "vector_scale">;
+type BrillouinZoneScene = ReturnType<typeof BrillouinZoneScene>;
+export default BrillouinZoneScene;

package/dist/brillouin/compute.d.ts

@@ -0,0 +1,7 @@
+import type { Matrix3x3, Vec3 } from '..';
+import type { BrillouinZoneData, ConvexHullData } from './types';
+export declare function reciprocal_lattice(real_lattice: Matrix3x3): Matrix3x3;
+export declare function generate_bz_vertices(k_lattice: Matrix3x3, order?: 1 | 2 | 3, max_planes_by_order?: Record<1 | 2 | 3, number>): Vec3[];
+export declare function compute_convex_hull(vertices: Vec3[], edge_sharp_angle_deg?: number): ConvexHullData;
+export declare function compute_brillouin_zone(k_lattice: Matrix3x3, order?: 1 | 2 | 3, edge_sharp_angle_deg?: number, // Angle threshold for edge extraction (default 5°, increase for fewer edges, decrease for more)
+max_planes_by_order?: Record<number, number>): BrillouinZoneData;

package/dist/brillouin/compute.js

@@ -0,0 +1,215 @@
+// Brillouin zone generation via convex hull
+import * as math from '../math';
+import { Vector3 } from 'three';
+import { ConvexGeometry } from 'three/examples/jsm/geometries/ConvexGeometry.js';
+const normalize = (vec) => {
+    const mag = Math.sqrt(vec[0] ** 2 + vec[1] ** 2 + vec[2] ** 2);
+    return mag < 1e-10 ? [0, 0, 0] : [vec[0] / mag, vec[1] / mag, vec[2] / mag];
+};
+// Compute reciprocal lattice: k = inv(real).T * 2π
+export function reciprocal_lattice(real_lattice) {
+    const inv = math.matrix_inverse_3x3(real_lattice);
+    const transposed = math.transpose_3x3_matrix(inv);
+    return transposed.map((row) => math.scale(row, 2 * Math.PI));
+}
+// Generate k-space grid with size based on BZ order
+function generate_k_space_grid(k_lattice, order) {
+    const points = [];
+    // For order n, we need to include points up to ±n to capture all nearest neighbors
+    const range = Math.max(1, order);
+    for (let idx_i = -range; idx_i <= range; idx_i++) {
+        for (let idx_j = -range; idx_j <= range; idx_j++) {
+            for (let idx_k = -range; idx_k <= range; idx_k++) {
+                const point = math.add(math.scale(k_lattice[0], idx_i), math.scale(k_lattice[1], idx_j), math.scale(k_lattice[2], idx_k));
+                points.push(point);
+            }
+        }
+    }
+    return points;
+}
+const TOL = 1e-8;
+// O(1) duplicate vertex detection using spatial hashing
+class VertexDeduplicator {
+    grid = new Map();
+    cell_size;
+    constructor(cell_size) {
+        this.cell_size = cell_size;
+    }
+    has_duplicate(vertex) {
+        const [base_x, base_y, base_z] = vertex.map((val) => Math.floor(val / this.cell_size));
+        for (let dx = -1; dx <= 1; dx++) {
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dz = -1; dz <= 1; dz++) {
+                    const neighbors = this.grid.get(`${base_x + dx},${base_y + dy},${base_z + dz}`);
+                    if (neighbors?.some((v) => Math.abs(v[0] - vertex[0]) < TOL &&
+                        Math.abs(v[1] - vertex[1]) < TOL &&
+                        Math.abs(v[2] - vertex[2]) < TOL))
+                        return true;
+                }
+            }
+        }
+        return false;
+    }
+    add(vertex) {
+        const key = vertex.map((v) => Math.floor(v / this.cell_size)).join(`,`);
+        const cell = this.grid.get(key);
+        if (cell)
+            cell.push(vertex);
+        else
+            this.grid.set(key, [vertex]);
+    }
+}
+// Find intersection of three Bragg planes by solving N·v = d
+function intersect_planes(p1, p2, p3) {
+    try {
+        const matrix = [p1.normal, p2.normal, p3.normal];
+        const distances = [p1.dist, p2.dist, p3.dist];
+        return math.mat3x3_vec3_multiply(math.matrix_inverse_3x3(matrix), distances);
+    }
+    catch {
+        return null;
+    }
+}
+// Generate BZ vertices for nth-order zone via three-plane intersections
+export function generate_bz_vertices(k_lattice, order = 1, 
+// Maximum number of Bragg planes to consider for each BZ order.
+// Limits the number of three-plane intersections tested (O(n³) operation).
+// Higher values give more accurate zones but increase computation time significantly.
+// Default values: 26 (1st order), 80 (2nd order), 150 (3rd+ order)
+max_planes_by_order = { 1: 26, 2: 80, 3: 150 }) {
+    if (order > 3)
+        order = 3; // Performance limit
+    const k_points = generate_k_space_grid(k_lattice, order);
+    const center_idx = Math.floor(k_points.length / 2);
+    // Determine max planes for this order (default to highest value for orders > 3)
+    const max_planes = max_planes_by_order[order] ?? 150;
+    // Create Bragg planes (perpendicular bisectors of k-points)
+    const planes = k_points
+        .map((pt, idx) => {
+        if (idx === center_idx)
+            return null;
+        const dist_sq = pt[0] ** 2 + pt[1] ** 2 + pt[2] ** 2;
+        return { normal: normalize(pt), dist: Math.sqrt(dist_sq) / 2, dist_sq };
+    })
+        .filter((p) => p !== null)
+        .sort((a, b) => a.dist_sq - b.dist_sq)
+        .slice(0, max_planes);
+    // Pre-compute plane data for fast access
+    const normals = planes.map((p) => p.normal);
+    const distances = planes.map((p) => p.dist);
+    const dedup = new VertexDeduplicator(TOL * 10);
+    const vertices = [];
+    // Test all three-plane intersections
+    for (let idx_i = 0; idx_i < planes.length; idx_i++) {
+        for (let idx_j = idx_i + 1; idx_j < planes.length; idx_j++) {
+            for (let idx_k = idx_j + 1; idx_k < planes.length; idx_k++) {
+                const vertex = intersect_planes(planes[idx_i], planes[idx_j], planes[idx_k]);
+                if (!vertex)
+                    continue;
+                // Count how many planes this vertex is beyond (with early termination)
+                let beyond_count = 0;
+                for (let p_idx = 0; p_idx < normals.length; p_idx++) {
+                    const dot = vertex[0] * normals[p_idx][0] + vertex[1] * normals[p_idx][1] +
+                        vertex[2] * normals[p_idx][2];
+                    if (dot > distances[p_idx] + TOL) {
+                        beyond_count++;
+                        if (beyond_count >= order)
+                            break;
+                    }
+                }
+                // Vertex belongs to nth BZ if it's beyond fewer than n planes
+                if (beyond_count < order && !dedup.has_duplicate(vertex)) {
+                    vertices.push(vertex);
+                    dedup.add(vertex);
+                }
+            }
+        }
+    }
+    return vertices;
+}
+// Build convex hull from vertices and extract topology
+export function compute_convex_hull(vertices, edge_sharp_angle_deg = 5) {
+    if (vertices.length < 4) {
+        throw new Error(`Need ≥4 vertices for convex hull, got ${vertices.length}`);
+    }
+    const geometry = new ConvexGeometry(vertices.map((v) => new Vector3(...v)));
+    const pos = geometry.getAttribute(`position`);
+    const idx = geometry.index;
+    // Deduplicate vertices from Three.js geometry
+    const unique_verts = [];
+    const vert_map = new Map();
+    for (let idx_vertex = 0; idx_vertex < pos.count; idx_vertex++) {
+        const vert = [pos.getX(idx_vertex), pos.getY(idx_vertex), pos.getZ(idx_vertex)];
+        const existing_idx = unique_verts.findIndex((u) => Math.abs(u[0] - vert[0]) < TOL && Math.abs(u[1] - vert[1]) < TOL &&
+            Math.abs(u[2] - vert[2]) < TOL);
+        vert_map.set(idx_vertex, existing_idx === -1 ? (unique_verts.push(vert) - 1) : existing_idx);
+    }
+    // Build faces with deduplicated vertex indices
+    const faces = [];
+    const n_faces = idx ? idx.count / 3 : pos.count / 3;
+    for (let idx_face = 0; idx_face < n_faces; idx_face++) {
+        const tri = idx
+            ? [idx.getX(idx_face * 3), idx.getX(idx_face * 3 + 1), idx.getX(idx_face * 3 + 2)]
+            : [idx_face * 3, idx_face * 3 + 1, idx_face * 3 + 2];
+        faces.push(tri.map((j) => {
+            const mapped = vert_map.get(j);
+            if (mapped === undefined)
+                throw new Error(`Vertex ${j} not mapped`);
+            return mapped;
+        }));
+    }
+    // Compute face normals and build edge-to-face adjacency
+    const face_normals = faces.map((face) => {
+        const [v0, v1, v2] = face.slice(0, 3).map((vi) => unique_verts[vi]);
+        return normalize(math.cross_3d(math.subtract(v1, v0), math.subtract(v2, v0)));
+    });
+    const edge_to_faces = new Map();
+    faces.forEach((face, face_idx) => {
+        face.forEach((v1, idx) => {
+            const v2 = face[(idx + 1) % face.length];
+            const key = v1 < v2 ? `${v1},${v2}` : `${v2},${v1}`;
+            const adj = edge_to_faces.get(key);
+            if (adj)
+                adj.push(face_idx);
+            else
+                edge_to_faces.set(key, [face_idx]);
+        });
+    });
+    // Extract edges: keep boundary edges or sharp angles
+    const cos_threshold = Math.cos((edge_sharp_angle_deg * Math.PI) / 180);
+    const edges = [];
+    for (const [key, adj] of edge_to_faces) {
+        const is_sharp = adj.length === 1 ||
+            (adj.length === 2 &&
+                math.dot(face_normals[adj[0]], face_normals[adj[1]]) < cos_threshold);
+        if (is_sharp)
+            edges.push(key.split(`,`).map(Number));
+    }
+    geometry.dispose();
+    return { vertices: unique_verts, faces, edges };
+}
+// Compute complete Brillouin zone with topology and volume
+export function compute_brillouin_zone(k_lattice, order = 1, edge_sharp_angle_deg = 5, // Angle threshold for edge extraction (default 5°, increase for fewer edges, decrease for more)
+max_planes_by_order = { 1: 26, 2: 80, 3: 150 }) {
+    const vertices = generate_bz_vertices(k_lattice, order, max_planes_by_order);
+    if (vertices.length < 4) {
+        throw new Error(`Insufficient vertices for BZ (got ${vertices.length}, need ≥4)`);
+    }
+    const hull = compute_convex_hull(vertices, edge_sharp_angle_deg);
+    // Compute volume via divergence theorem (sum of signed tetrahedral volumes)
+    const volume = Math.abs(hull.faces.reduce((sum, face) => {
+        if (face.length < 3)
+            return sum;
+        const [v0, v1, v2] = face.slice(0, 3).map((idx) => hull.vertices[idx]);
+        const area_normal = math.scale(math.cross_3d(math.subtract(v1, v0), math.subtract(v2, v0)), 0.5);
+        return sum + math.dot(v0, area_normal) / 3;
+    }, 0));
+    return {
+        order,
+        vertices: hull.vertices,
+        faces: hull.faces,
+        edges: hull.edges.map(([i1, i2]) => [hull.vertices[i1], hull.vertices[i2]]),
+        k_lattice,
+        volume,
+    };
+}

package/dist/brillouin/index.d.ts

@@ -0,0 +1,7 @@
+export { default as BrillouinZone } from './BrillouinZone.svelte';
+export { default as BrillouinZoneControls } from './BrillouinZoneControls.svelte';
+export { default as BrillouinZoneExportPane } from './BrillouinZoneExportPane.svelte';
+export { default as BrillouinZoneInfoPane } from './BrillouinZoneInfoPane.svelte';
+export { default as BrillouinZoneScene } from './BrillouinZoneScene.svelte';
+export * from './compute';
+export * from './types';

package/dist/brillouin/index.js

@@ -0,0 +1,7 @@
+export { default as BrillouinZone } from './BrillouinZone.svelte';
+export { default as BrillouinZoneControls } from './BrillouinZoneControls.svelte';
+export { default as BrillouinZoneExportPane } from './BrillouinZoneExportPane.svelte';
+export { default as BrillouinZoneInfoPane } from './BrillouinZoneInfoPane.svelte';
+export { default as BrillouinZoneScene } from './BrillouinZoneScene.svelte';
+export * from './compute';
+export * from './types';

package/dist/brillouin/types.d.ts

@@ -0,0 +1,23 @@
+import type { Matrix3x3, PymatgenStructure, Vec3 } from '..';
+export type BrillouinZoneData = {
+    order: number;
+    vertices: Vec3[];
+    faces: number[][];
+    edges: Vec3[][];
+    k_lattice: Matrix3x3;
+    volume: number;
+};
+export type BrillouinZoneProps = {
+    structure: PymatgenStructure;
+    bz_order?: number;
+    surface_color?: string;
+    surface_opacity?: number;
+    edge_color?: string;
+    edge_width?: number;
+    show_vectors?: boolean;
+};
+export type ConvexHullData = {
+    vertices: Vec3[];
+    faces: number[][];
+    edges: [number, number][];
+};

package/dist/brillouin/types.js

@@ -0,0 +1 @@
+export {};

package/dist/composition/BarChart.svelte.d.ts

@@ -12,7 +12,7 @@ type BarSegmentData = ChartSegmentData & {
     label_x: number;
     label_y: number;
 };
-interface Props extends SVGAttributes<SVGSVGElement> {
+type $$ComponentProps = SVGAttributes<SVGSVGElement> & {
     composition: CompositionType;
     size?: number;
     bar_height?: number;
@@ -29,7 +29,7 @@ interface Props extends SVGAttributes<SVGSVGElement> {
     segment_content?: Snippet<[BarSegmentData]>;
     interactive?: boolean;
     svg_node?: SVGSVGElement | null;
-}
-declare const BarChart: import("svelte").Component<Props, {}, "svg_node">;
+};
+declare const BarChart: import("svelte").Component<$$ComponentProps, {}, "svg_node">;
 type BarChart = ReturnType<typeof BarChart>;
 export default BarChart;

package/dist/composition/BubbleChart.svelte

@@ -9,19 +9,20 @@ let bubbles = $derived.by(() => {
     const element_entries = Object.entries(composition).filter(([_, amount]) => amount && amount > 0);
     if (element_entries.length === 0)
         return [];
-    // Create hierarchy data structure for D3 pack
     const hierarchy_data = {
         children: element_entries.map(([element, amount]) => ({
             element,
-            amount: amount,
+            amount: amount ?? 0,
             color: element_colors[element] || `#cccccc`,
         })),
     };
     // Use D3's pack layout for proper circle packing
-    const pack_layout = pack()
-        .size([size - 2 * padding, size - 2 * padding])
+    const pack_layout = pack().size([
+        size - 2 * padding,
+        size - 2 * padding,
+    ])
         .padding(padding * 0.1); // Small padding between circles
-    const root = pack_layout(hierarchy(hierarchy_data).sum((d) => d && `amount` in d ? d.amount : 0));
+    const root = pack_layout(hierarchy(hierarchy_data).sum((d) => (`amount` in d ? d.amount : 0)));
     // Get max radius for font scaling
     const max_radius = Math.max(...root.leaves().map((d) => d.r || 0));
     const total_atoms = get_total_atoms(composition);
@@ -39,7 +40,7 @@ let bubbles = $derived.by(() => {
         return {
             element: data.element,
             amount: data.amount,
-            percentage: total_atoms > 0 ? (data.amount / total_atoms) * 100 : 0,
+            fraction: total_atoms > 0 ? data.amount / total_atoms : 0,
             radius,
             x: (node.x || 0) + padding, // Offset by padding
             y: (node.y || 0) + padding,