matterviz 0.4.0 → 0.4.2

package/dist/structure/bonding.js

@@ -1,8 +1,48 @@
 // Bonding algorithms for structure visualization
-import { element_data } from '../element';
+import { default as element_data } from '../element/data';
 import * as math from '../math';
-const element_lookup = new Map(element_data.map((el) => [el.symbol, el]));
+// Shared per-symbol element data lookup (also used by pbc.ts and polyhedra.ts)
+export const element_lookup = new Map(element_data.map((el) => [el.symbol, el]));
 const covalent_radii = new Map(element_data.flatMap((el) => el.covalent_radius === null ? [] : [[el.symbol, el.covalent_radius]]));
+// Majority-occupancy element of a (possibly disordered) site
+export const get_majority_element = (site) => {
+    if (!site?.species?.length)
+        return null;
+    return site.species.reduce((max, spec) => (spec.occu > max.occu ? spec : max)).element;
+};
+// Large low-valent A-site cations whose coordination polyhedra (CN 8-12) tend to
+// obscure the structural framework. VESTA-style figures draw the framework
+// (e.g. TiO6 in BaTiO3, FeO6/PO4 in LiFePO4) and leave these as plain spheres.
+// They still get polyhedra when they are the only qualifying cations (e.g. NaCl)
+// or when force-included via `included_center_elements`. Shared by polyhedra.ts
+// (vertex/center selection) and pbc.ts (phase-2 boundary completion) so the bond
+// graph and the polyhedra it feeds stay consistent.
+const SPECTATOR_CATEGORIES = new Set([`alkali metal`]);
+const HEAVY_ALKALINE_EARTHS = new Set([`Ca`, `Sr`, `Ba`, `Ra`]);
+export const is_spectator_center = (element) => SPECTATOR_CATEGORIES.has(element_lookup.get(element)?.category ?? ``) ||
+    HEAVY_ALKALINE_EARTHS.has(element);
+// True if the composition contains a framework cation: a non-spectator element
+// strictly less electronegative than the most electronegative element present
+// (i.e. one that can coordinate the anions). When true, spectator A-site cations
+// are hidden from coordination polyhedra (compute_polyhedra) and skipped by phase-2
+// boundary completion (find_image_atoms) - sharing this keeps the bond graph and
+// the polyhedra it feeds consistent. Purely ionic binaries (NaCl, Li2O) return
+// false, so the spectator IS the framework and keeps its polyhedra/completions.
+export function has_framework_potential(elements) {
+    const els = [...new Set(elements)]; // dedupe so callers can pass per-site element lists
+    let max_en = -Infinity;
+    for (const el of els) {
+        const en = element_lookup.get(el)?.electronegativity;
+        if (en != null && en > max_en)
+            max_en = en;
+    }
+    return els.some((el) => {
+        if (is_spectator_center(el))
+            return false;
+        const en = element_lookup.get(el)?.electronegativity;
+        return en != null && en < max_en;
+    });
+}
 const is_zero_cell_shift = (cell_shift) => cell_shift === undefined || cell_shift.every((val) => val === 0);
 const format_cell_shift = (cell_shift) => {
     if (cell_shift === undefined || is_zero_cell_shift(cell_shift))
@@ -413,8 +453,6 @@ export function get_bond_render_matrices(bond, bond_thickness) {
         ? [bond.transform_matrix]
         : offsets_and_scales.map(([offset, radius_scale]) => scale_and_offset_bond_matrix(bond.transform_matrix, offset, radius_scale));
 }
-// Get the species with highest occupancy from a site.
-const get_majority_species = (site) => (site.species ?? []).reduce((max_species, species) => (species.occu > max_species.occu ? species : max_species), site.species?.[0] ?? { element: ``, occu: -1 });
 // Helper to extract numeric index from site properties
 function get_orig_idx(site, fallback) {
     const props = site.properties;
@@ -496,12 +534,27 @@ export function compute_bond_transform(pos_1, pos_2) {
         1,
     ]);
 }
+// Build a BondPair between two sites (shared by electroneg_ratio and solid_angle)
+const make_bond = (sites, idx_1, idx_2, bond_length, strength) => ({
+    pos_1: sites[idx_1].xyz,
+    pos_2: sites[idx_2].xyz,
+    site_idx_1: idx_1,
+    site_idx_2: idx_2,
+    bond_length,
+    strength,
+    transform_matrix: compute_bond_transform(sites[idx_1].xyz, sites[idx_2].xyz),
+});
+// Pack quantized cell coordinates into one integer key (exact for cell coords in
+// [-512, 511], i.e. structures up to ~1000 cells per axis - far beyond any real
+// case). Integer Map keys avoid per-lookup string building in the hot pair loop.
+// Also used by pbc.ts for its phase-2 boundary-completion grid.
+const CELL_OFFSET = 512;
+export const pack_cell_key = (x, y, z) => (x + CELL_OFFSET) * 1048576 + (y + CELL_OFFSET) * 1024 + (z + CELL_OFFSET);
 // Build spatial grid by dividing 3D space into cubic cells.
 function build_spatial_grid(sites, cell_size) {
     const grid = new Map();
     for (let idx = 0; idx < sites.length; idx++) {
-        const [x, y, z] = sites[idx].xyz.map((coord) => Math.floor(coord / cell_size));
-        const key = `${x},${y},${z}`;
+        const key = pack_cell_key(Math.floor(sites[idx].xyz[0] / cell_size), Math.floor(sites[idx].xyz[1] / cell_size), Math.floor(sites[idx].xyz[2] / cell_size));
         const cell = grid.get(key);
         if (cell)
             cell.push(idx);
@@ -511,23 +564,28 @@ function build_spatial_grid(sites, cell_size) {
     return grid;
 }
 // Get all site indices in 3x3x3 cube of cells around position.
+// Fills and returns a REUSED module-level array (valid until the next call):
+// this runs once per bond center, so per-call allocations would dominate GC
+// pressure when computing bonds for large supercells.
+const scratch_neighbors = [];
 function get_neighbors_from_grid(pos, grid, cell_size) {
     const [cx, cy, cz] = [
         Math.floor(pos[0] / cell_size),
         Math.floor(pos[1] / cell_size),
         Math.floor(pos[2] / cell_size),
     ];
-    const neighbors = [];
+    scratch_neighbors.length = 0;
     for (let dx = -1; dx <= 1; dx++) {
         for (let dy = -1; dy <= 1; dy++) {
             for (let dz = -1; dz <= 1; dz++) {
-                const cell = grid.get(`${cx + dx},${cy + dy},${cz + dz}`);
+                const cell = grid.get(pack_cell_key(cx + dx, cy + dy, cz + dz));
                 if (cell)
-                    neighbors.push(...cell);
+                    for (const site_idx of cell)
+                        scratch_neighbors.push(site_idx);
             }
         }
     }
-    return neighbors;
+    return scratch_neighbors;
 }
 // Setup spatial decomposition for structures with >50 atoms.
 function setup_spatial_grid(sites, cutoff) {
@@ -539,6 +597,23 @@ const get_candidates = (pos, sites, spatial) => spatial
     ? get_neighbors_from_grid(pos, spatial.grid, spatial.cell_size)
     : Array.from({ length: sites.length }, (_, idx) => idx);
 export const BONDING_STRATEGIES = { electroneg_ratio, solid_angle };
+// Memo for the costly neighbor search: WeakMap keyed by structure (GC'd with it), each holding a
+// per-signature (strategy + JSON options) map of results. The multi-side view's 4 panes share one
+// search (identical inputs, one flush); the per-signature map also lets alternating
+// strategies/options on the same structure reuse earlier results instead of thrashing one slot.
+const bond_memo = new WeakMap();
+export function compute_bonds(structure, strategy, options = {}) {
+    const sig = `${strategy}:${JSON.stringify(options)}`;
+    let by_sig = bond_memo.get(structure);
+    const cached = by_sig?.get(sig);
+    if (cached)
+        return cached;
+    const bonds = BONDING_STRATEGIES[strategy](structure, options);
+    if (!by_sig)
+        bond_memo.set(structure, (by_sig = new Map()));
+    by_sig.set(sig, bonds);
+    return bonds;
+}
 // Electronegativity-based bonding with chemical preferences.
 // This algorithm considers electronegativity differences between atoms, metal/nonmetal
 // properties, and distance to determine bond strength. Bonds are only created if the
@@ -551,25 +626,50 @@ metal_nonmetal_bonus = 1.5, // Strength bonus for metal-nonmetal bonds
 similar_electronegativity_bonus = 1.2, // Bonus for similar electronegativity
 same_species_penalty = 0.5, // Penalty for bonds between same element
 strength_threshold = 0.3, // Minimum bond strength to include in results
- } = {}) {
+// Only iterate the first `center_count` sites as bond centers (default: all).
+// Coordination coloring sets this to the original-atom count so appended PBC image
+// atoms are used as neighbors but not iterated as centers — identical coordination
+// for the originals (by translational symmetry), far cheaper when images dominate.
+center_count = Infinity, } = {}) {
     const { sites } = structure;
     if (sites.length < 2)
         return [];
     const bonds = [];
     const min_dist_sq = min_bond_dist ** 2;
-    const closest = new Map();
-    const props = sites.map((site) => {
-        const majority = get_majority_species(site);
-        const elem = majority.element;
-        const data = element_lookup.get(elem);
-        return {
-            element: elem,
-            electroneg: data?.electronegativity ?? 2.0,
-            is_metal: data?.metal ?? false,
-            is_nonmetal: data?.nonmetal ?? false,
-            radius: elem ? covalent_radii.get(elem) : undefined,
-        };
-    });
+    // Per-site properties in flat typed arrays - the pair loop below visits
+    // millions of candidate pairs in large supercells, so object property chains
+    // and Map lookups are replaced with indexed array reads.
+    const n_sites = sites.length;
+    const n_center = Math.min(center_count, n_sites - 1);
+    const electronegs = new Float64Array(n_sites);
+    const radii = new Float64Array(n_sites); // 0 = no covalent radius known
+    const metal_flags = new Uint8Array(n_sites);
+    const nonmetal_flags = new Uint8Array(n_sites);
+    const elem_ids = new Int32Array(n_sites); // same-species check via integer ids
+    const orig_idxs = new Int32Array(n_sites);
+    const elem_id_lookup = new Map();
+    for (let idx = 0; idx < n_sites; idx++) {
+        const elem = get_majority_element(sites[idx]);
+        const data = elem ? element_lookup.get(elem) : undefined;
+        electronegs[idx] = data?.electronegativity ?? 2.0;
+        metal_flags[idx] = data?.metal ? 1 : 0;
+        nonmetal_flags[idx] = data?.nonmetal ? 1 : 0;
+        radii[idx] = (elem ? covalent_radii.get(elem) : undefined) ?? 0;
+        let elem_id = elem_id_lookup.get(elem ?? ``);
+        if (elem_id === undefined) {
+            elem_id = elem_id_lookup.size;
+            elem_id_lookup.set(elem ?? ``, elem_id);
+        }
+        elem_ids[idx] = elem_id;
+        // Valid orig indices always reference a site in this structure; fall back to
+        // the site's own index on malformed orig_*_idx properties so the typed
+        // `closest` array below stays bounded by n_sites
+        const orig_idx = get_orig_idx(sites[idx], idx);
+        orig_idxs[idx] =
+            Number.isInteger(orig_idx) && orig_idx >= 0 && orig_idx < n_sites ? orig_idx : idx;
+    }
+    // Closest normalized bond distance per original atom (typed array instead of Map)
+    const closest = new Float64Array(n_sites).fill(Infinity);
     let max_radius = 0;
     for (const radius of covalent_radii.values()) {
         if (radius > max_radius)
@@ -578,30 +678,45 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
     const max_cutoff = max_radius * 2 * max_distance_ratio;
     const spatial = setup_spatial_grid(sites, max_cutoff);
     const potential_bonds = [];
-    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
+    for (let idx_a = 0; idx_a < n_center; idx_a++) {
+        const radius_a = radii[idx_a];
+        if (radius_a === 0)
+            continue; // no covalent radius -> no pairs (symmetric: idx_b skips too)
         const [x1, y1, z1] = sites[idx_a].xyz;
-        const props_a = props[idx_a];
+        const electroneg_a = electronegs[idx_a];
+        const is_metal_a = metal_flags[idx_a] === 1;
+        const is_nonmetal_a = nonmetal_flags[idx_a] === 1;
+        const elem_id_a = elem_ids[idx_a];
         for (const idx_b of get_candidates(sites[idx_a].xyz, sites, spatial)) {
             if (idx_b <= idx_a)
                 continue;
+            const radius_b = radii[idx_b];
+            if (radius_b === 0)
+                continue;
             const [x2, y2, z2] = sites[idx_b].xyz;
-            const props_b = props[idx_b];
-            const [dx, dy, dz] = [x2 - x1, y2 - y1, z2 - z1];
+            const dx = x2 - x1;
+            const dy = y2 - y1;
+            const dz = z2 - z1;
             const dist_sq = dx * dx + dy * dy + dz * dz;
-            const dist = Math.sqrt(dist_sq);
-            if (dist_sq < min_dist_sq || !props_a.radius || !props_b.radius)
+            if (dist_sq < min_dist_sq)
                 continue;
-            const expected = props_a.radius + props_b.radius;
-            if (dist > expected * max_distance_ratio)
+            // Compare squared distances to defer the sqrt until a pair survives the
+            // cutoff (the vast majority of candidate pairs are rejected here)
+            const expected = radius_a + radius_b;
+            const max_dist = expected * max_distance_ratio;
+            if (dist_sq > max_dist * max_dist)
                 continue;
-            const electroneg_diff = Math.abs(props_a.electroneg - props_b.electroneg);
-            const electroneg_balance = electroneg_diff / (props_a.electroneg + props_b.electroneg);
+            const dist = Math.sqrt(dist_sq);
+            const electroneg_b = electronegs[idx_b];
+            const electroneg_diff = Math.abs(electroneg_a - electroneg_b);
+            const electroneg_balance = electroneg_diff / (electroneg_a + electroneg_b);
+            const is_metal_b = metal_flags[idx_b] === 1;
+            const is_nonmetal_b = nonmetal_flags[idx_b] === 1;
             let bond_strength = 1.0;
-            if (props_a.is_metal && props_b.is_metal) {
+            if (is_metal_a && is_metal_b) {
                 bond_strength *= metal_metal_penalty;
             }
-            else if ((props_a.is_metal && props_b.is_nonmetal) ||
-                (props_a.is_nonmetal && props_b.is_metal)) {
+            else if ((is_metal_a && is_nonmetal_b) || (is_nonmetal_a && is_metal_b)) {
                 bond_strength *= metal_nonmetal_bonus;
                 if (electroneg_diff > electronegativity_threshold)
                     bond_strength *= 1.3;
@@ -612,25 +727,23 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
             const dist_weight = Math.exp(-((dist / expected - 1) ** 2) / 0.18);
             const electroneg_weight = 1.0 - 0.3 * electroneg_balance;
             let strength = bond_strength * dist_weight * electroneg_weight;
-            if (props_a.element === props_b.element)
+            if (elem_id_a === elem_ids[idx_b])
                 strength *= same_species_penalty;
             // If raw strength is already too low, we can skip early
             // (penalty will only reduce it further)
             if (strength <= strength_threshold)
                 continue;
-            // Use helper logic to handle both supercell and image atoms with robust normalization
-            const orig_idx_a = get_orig_idx(sites[idx_a], idx_a);
-            const orig_idx_b = get_orig_idx(sites[idx_b], idx_b);
+            // Use precomputed original-site indices to handle supercell and image atoms
+            const orig_idx_a = orig_idxs[idx_a];
+            const orig_idx_b = orig_idxs[idx_b];
             // Update closest known normalized distance (dist / expected) for original atoms
             // Normalized distance handles atoms of different sizes better than raw distance
             // (e.g. C-H is short but C-C is longer; we don't want C-H to penalize C-C just because H is small)
             const norm_dist = dist / expected;
-            const closest_dist_a = closest.get(orig_idx_a) ?? Infinity;
-            if (norm_dist < closest_dist_a)
-                closest.set(orig_idx_a, norm_dist);
-            const closest_dist_b = closest.get(orig_idx_b) ?? Infinity;
-            if (norm_dist < closest_dist_b)
-                closest.set(orig_idx_b, norm_dist);
+            if (norm_dist < closest[orig_idx_a])
+                closest[orig_idx_a] = norm_dist;
+            if (norm_dist < closest[orig_idx_b])
+                closest[orig_idx_b] = norm_dist;
             potential_bonds.push({
                 site_idx_1: idx_a,
                 site_idx_2: idx_b,
@@ -645,8 +758,8 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
     // Second pass: Apply penalties and filter
     for (const bond of potential_bonds) {
         const { site_idx_1, site_idx_2, dist, expected_dist, base_strength, orig_idx_a, orig_idx_b, } = bond;
-        const closest_dist_a = closest.get(orig_idx_a) ?? Infinity;
-        const closest_dist_b = closest.get(orig_idx_b) ?? Infinity;
+        const closest_dist_a = closest[orig_idx_a];
+        const closest_dist_b = closest[orig_idx_b];
         const norm_dist = dist / expected_dist;
         let strength = base_strength;
         // Apply penalty if this bond is much longer (relative to radii) than the closest known bond
@@ -657,15 +770,7 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
             strength *= Math.exp(-(norm_dist / closest_dist_b - 1) / 0.5);
         }
         if (strength > strength_threshold) {
-            bonds.push({
-                pos_1: sites[site_idx_1].xyz,
-                pos_2: sites[site_idx_2].xyz,
-                site_idx_1,
-                site_idx_2,
-                bond_length: dist,
-                strength,
-                transform_matrix: compute_bond_transform(sites[site_idx_1].xyz, sites[site_idx_2].xyz),
-            });
+            bonds.push(make_bond(sites, site_idx_1, site_idx_2, dist, strength));
         }
     }
     return apply_explicit_bond_metadata(structure, bonds);
@@ -675,7 +780,8 @@ strength_threshold = 0.3, // Minimum bond strength to include in results
 // This algorithm computes bond strength based on the solid angle subtended by atoms
 // and their distance penalty. Bonds are only created if the computed strength exceeds
 // the strength_threshold parameter.
-export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area = 0.05, max_distance = 5.0, min_bond_dist = 0.4, strength_threshold = 0.05, } = {}) {
+export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area = 0.05, max_distance = 5.0, min_bond_dist = 0.4, strength_threshold = 0.05, center_count = Infinity, // see electroneg_ratio: limit bond centers to first N sites
+ } = {}) {
     const { sites } = structure;
     if (sites.length < 2)
         return [];
@@ -683,16 +789,17 @@ export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area =
     const min_dist_sq = min_bond_dist ** 2;
     const max_dist_sq = max_distance ** 2;
     const spatial = setup_spatial_grid(sites, max_distance);
-    for (let idx_a = 0; idx_a < sites.length - 1; idx_a++) {
+    const n_center = Math.min(center_count, sites.length - 1);
+    for (let idx_a = 0; idx_a < n_center; idx_a++) {
         const [x1, y1, z1] = sites[idx_a].xyz;
-        const majority_a = get_majority_species(sites[idx_a]);
-        const radius_a = majority_a.element ? covalent_radii.get(majority_a.element) : undefined;
+        const elem_a = get_majority_element(sites[idx_a]);
+        const radius_a = elem_a ? covalent_radii.get(elem_a) : undefined;
         for (const idx_b of get_candidates(sites[idx_a].xyz, sites, spatial)) {
             if (idx_b <= idx_a)
                 continue;
             const [x2, y2, z2] = sites[idx_b].xyz;
-            const majority_b = get_majority_species(sites[idx_b]);
-            const radius_b = majority_b.element ? covalent_radii.get(majority_b.element) : undefined;
+            const elem_b = get_majority_element(sites[idx_b]);
+            const radius_b = elem_b ? covalent_radii.get(elem_b) : undefined;
             const [dx, dy, dz] = [x2 - x1, y2 - y1, z2 - z1];
             const dist_sq = dx * dx + dy * dy + dz * dz;
             const dist = Math.sqrt(dist_sq);
@@ -708,15 +815,7 @@ export function solid_angle(structure, { min_solid_angle = 0.01, min_face_area =
             const angle_strength = Math.min(bond_solid_angle / (4.0 * Math.PI), 1.0);
             const strength = angle_strength * dist_penalty;
             if (strength > strength_threshold) {
-                bonds.push({
-                    pos_1: sites[idx_a].xyz,
-                    pos_2: sites[idx_b].xyz,
-                    site_idx_1: idx_a,
-                    site_idx_2: idx_b,
-                    bond_length: dist,
-                    strength,
-                    transform_matrix: compute_bond_transform(sites[idx_a].xyz, sites[idx_b].xyz),
-                });
+                bonds.push(make_bond(sites, idx_a, idx_b, dist, strength));
             }
         }
     }

package/dist/structure/edit-history.d.ts

@@ -0,0 +1,6 @@
+export type HistoryStacks<T> = [undo_stack: T[], redo_stack: T[]];
+export declare function push_edit<T>([undo_stack]: HistoryStacks<T>, snapshot: T, max_history: number): HistoryStacks<T>;
+export declare function step_history<T>([undo_stack, redo_stack]: HistoryStacks<T>, direction: `undo` | `redo`, current: T): {
+    stacks: HistoryStacks<T>;
+    restored: T;
+} | null;

package/dist/structure/edit-history.js

@@ -0,0 +1,27 @@
+// Pure undo/redo stack mechanics for Structure.svelte's edit-atoms history.
+// Stacks are treated as immutable (updates return new arrays) so they work with
+// $state.raw holders where only reassignment is reactive. Kept free of
+// component state so the real logic (not a test-local mirror) is unit-testable.
+// Record a new edit: push `snapshot` onto the undo stack (trimming to
+// `max_history` entries) and invalidate the redo stack.
+export function push_edit([undo_stack], snapshot, max_history) {
+    const trimmed = undo_stack.length >= max_history
+        ? undo_stack.slice(undo_stack.length - max_history + 1)
+        : undo_stack;
+    return [[...trimmed, snapshot], []];
+}
+// Step the history in `direction`: pop that stack's top as the state to
+// restore, pushing `current` onto the opposite stack. Returns null when there
+// is nothing to step to (callers should snapshot `current` lazily by checking
+// stack length first if snapshots are expensive).
+export function step_history([undo_stack, redo_stack], direction, current) {
+    const source = direction === `undo` ? undo_stack : redo_stack;
+    const restored = source.at(-1);
+    if (restored === undefined)
+        return null;
+    const remaining = source.slice(0, -1);
+    const stacks = direction === `undo`
+        ? [remaining, [...redo_stack, current]]
+        : [[...undo_stack, current], remaining];
+    return { stacks, restored };
+}

package/dist/structure/export.d.ts

@@ -7,14 +7,35 @@ export declare function has_color_property(mat: Material): mat is Material & {
 export declare function extract_bond_color_for_instance(geometry: BufferGeometry, instance_idx: number): Color | null;
 export declare function clean_geometry_for_export(geometry: BufferGeometry): void;
 export declare function generate_mtl_content(scene: Scene): string;
+export declare function convert_instanced_meshes_to_regular(scene: Scene): Scene;
 export declare function create_structure_filename(structure: AnyStructure | undefined, extension: string): string;
 export declare function structure_to_xyz_str(structure?: AnyStructure): string;
 export declare function structure_to_cif_str(structure?: AnyStructure): string;
 export declare function structure_to_poscar_str(structure?: AnyStructure): string;
 export declare function structure_to_json_str(structure?: AnyStructure): string;
-export declare function export_structure_as_cif(structure?: AnyStructure): void;
-export declare function export_structure_as_poscar(structure?: AnyStructure): void;
-export declare function export_structure_as_xyz(structure?: AnyStructure): void;
-export declare function export_structure_as_json(structure?: AnyStructure): void;
+export declare const STRUCT_TEXT_FORMATS: {
+    readonly json: {
+        readonly to_str: typeof structure_to_json_str;
+        readonly ext: "json";
+        readonly mime: "application/json";
+    };
+    readonly xyz: {
+        readonly to_str: typeof structure_to_xyz_str;
+        readonly ext: "xyz";
+        readonly mime: "text/plain";
+    };
+    readonly cif: {
+        readonly to_str: typeof structure_to_cif_str;
+        readonly ext: "cif";
+        readonly mime: "chemical/x-cif";
+    };
+    readonly poscar: {
+        readonly to_str: typeof structure_to_poscar_str;
+        readonly ext: "poscar";
+        readonly mime: "text/plain";
+    };
+};
+export type StructTextFormat = keyof typeof STRUCT_TEXT_FORMATS;
+export declare function export_structure_as(fmt: StructTextFormat, structure?: AnyStructure): void;
 export declare function export_structure_as_glb(scene: Scene | null, structure: AnyStructure | undefined): void;
 export declare function export_structure_as_obj(scene: Scene | null, structure: AnyStructure | undefined): void;