vmecdash 0.1.0__tar.gz

vmecdash-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hengqian Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vmecdash-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: vmecdash
+Version: 0.1.0
+Summary: Dash and VS Code tooling for inspecting VMEC wout NetCDF equilibria
+Author: Hengqian Liu
+License: MIT
+Project-URL: Homepage, https://github.com/DMCXE/VMECdash
+Project-URL: Repository, https://github.com/DMCXE/VMECdash
+Project-URL: Issues, https://github.com/DMCXE/VMECdash/issues
+Keywords: vmec,stellarator,plasma,equilibrium,netcdf,plotly,fusion
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: plotly>=5.22.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: xarray>=2024.1.0
+Requires-Dist: netCDF4>=1.6.5
+Requires-Dist: jax>=0.4.26
+Requires-Dist: jaxlib>=0.4.26
+Provides-Extra: dash
+Requires-Dist: dash>=2.16.1; extra == "dash"
+Requires-Dist: dash-mantine-components>=0.14.5; extra == "dash"
+Requires-Dist: dash-iconify>=0.1.2; extra == "dash"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# VMECdash
+
+An interactive Dash application for exploring VMEC `wout_*.nc` stellarator equilibria.  
+It reconstructs magnetic surfaces with JAX, renders 1‑D/2‑D/3‑D plots and so on, motivated by the original MATLAB tool **VMECplot.m**.
+
+**Motivation:** Quickly inspect the VMEC equilibrium quantities of interest **without relying on** difficult-for-starter-to-compile programs (such as **libstell**) or memory-heavy commercial software (such as **MATLAB**).
+
+[![VMECdash Screenshot](example/summary.png)](example/summary.png)
+
+---
+## Features
+
+- **File upload** for standard VMEC `wout` NetCDF output.
+- **Summary dashboard** with key scalar diagnostics and highlighted metadata (free/fixed boundary, mgrid file, etc.).
+- **1‑D profiles** for rotational transform, safety factor, pressure, volume derivative, beta metrics, and more.
+- **2‑D visualisations**:
+  - R‑Z cross sections with geometry or interpolated scalar fields.
+  - θ‑ζ flux-surface contours across a field period.
+- **3‑D flux surfaces** with optional coordinate‑free background shading.
+- **Field lines viewer** for $\alpha-\zeta$ coordinates on selected flux
+  - A nice choice for visualising magnetic ripple
+  - 2D plots of $|B|(\alpha, \zeta)$
+  - 1D plots of single period field line traces with different initial $\alpha$ values
+  - Single field line transistions.
+- **JAX acceleration** for geometry reconstruction.
+
+---
+
+## Requirements
+
+Python 3.10+ is recommended. Install dependencies with conda:(optional)
+
+```bash
+conda activate your_env_name
+pip install -r requirements.txt
+```
+
+> **Note for JAX:** If you don't have a GPU/TPU or your gpu is not supported for FP64(like metal), then simply running `pip install jax[cpu]` to  install the CPU-only version is good enough.
+> GPU/TPU wheels require platform-specific instructions from the [JAX documentation](https://github.com/google/jax#pip-installation).
+
+---
+
+## Running the App
+
+```bash
+python VMECdash.py
+```
+
+Dash defaults to `http://127.0.0.1:8050/`. The layout is responsive, so you can resize the browser to focus on plots or the control sidebar.
+
+The packaged entry point is also available after installation:
+
+```bash
+pip install -e ".[dash]"
+vmecdash serve
+```
+
+---
+
+## VS Code Native Preview
+
+VMECdash now includes the first native VS Code integration surface:
+
+- a Dash-free Python backend at `python -m vmecdash.vscode_backend --stdio`;
+- a workspace VS Code extension under `extension/`;
+- a Custom Readonly Editor for `wout*.nc` files;
+- a Webview UI that renders backend Plotly figures with bundled `plotly.min.js`.
+
+For local development, install the Python package in the interpreter VS Code should use:
+
+```bash
+pip install -e .
+```
+
+Then open `extension/` as a VS Code extension development project or package it as a VSIX. In Remote-SSH, install `vmecdash` in the remote Python environment and set `vmecdash.pythonPath` if VS Code does not pick the desired interpreter.
+
+
+---
+
+## Usage Tips
+
+1. **Upload** a VMEC NetCDF file (`wout_*.nc`) via the drag‑and‑drop area in the sidebar.
+2. Use **Visualization Mode** to switch between:
+   - **Summary Dashboard** (shows statistics + multi-panel plots),
+   - **1D Profiles**, **2D Cross Sections**, **2D Flux Surfaces**, and **3D Geometry**.
+3. Adjust **sliders** for toroidal angle (`phi`), flux surface index (`s`), and choose different physical quantities from the dropdowns.
+4. Toggle **Coordinate-free background** in 3‑D mode for clean screenshots.
+5. Click **Download Plot** to export the currently visible figure as a PNG.
+
+The app caches equilibrium metadata, so switching modes or variables is fast.  
+For heavy 2‑D physics overlays, a pre-computation step runs on the server while keeping the UI responsive.
+
+---
+
+## Repository Layout
+
+| Path               | Description                                                      |
+| ------------------ | ---------------------------------------------------------------- |
+| `VMECdash.py`| Main Dash entry point (layout + callbacks).                      |
+| `vmec_jax.py`      | JAX-powered data processor for VMEC equilibria.                  |
+| `views/`           | Modular UI components (overview, profiles, 2D/3D, fieldlines).  |
+| `ui/`              | Shared UI helper components.                                    |
+| `requirements.txt` | Python dependencies.                                             |
+| `example/wout_PO.nc`       | Example VMEC equilibrium (use your own files for new cases).     |
+
+---
+
+## TroubleShooting
+Feel free to open issues or pull requests to add new physical quantities, UI tweaks, or performance optimisations. Enjoy exploring your VMEC equilibria! 
+
+## Next step
+- Add jax-based boozer coordinate transformation.
+- Fast evaulation of EffetiveRipple, GammaC, maybe slow without gpu.

vmecdash-0.1.0/README.md

@@ -0,0 +1,113 @@
+# VMECdash
+
+An interactive Dash application for exploring VMEC `wout_*.nc` stellarator equilibria.  
+It reconstructs magnetic surfaces with JAX, renders 1‑D/2‑D/3‑D plots and so on, motivated by the original MATLAB tool **VMECplot.m**.
+
+**Motivation:** Quickly inspect the VMEC equilibrium quantities of interest **without relying on** difficult-for-starter-to-compile programs (such as **libstell**) or memory-heavy commercial software (such as **MATLAB**).
+
+[![VMECdash Screenshot](example/summary.png)](example/summary.png)
+
+---
+## Features
+
+- **File upload** for standard VMEC `wout` NetCDF output.
+- **Summary dashboard** with key scalar diagnostics and highlighted metadata (free/fixed boundary, mgrid file, etc.).
+- **1‑D profiles** for rotational transform, safety factor, pressure, volume derivative, beta metrics, and more.
+- **2‑D visualisations**:
+  - R‑Z cross sections with geometry or interpolated scalar fields.
+  - θ‑ζ flux-surface contours across a field period.
+- **3‑D flux surfaces** with optional coordinate‑free background shading.
+- **Field lines viewer** for $\alpha-\zeta$ coordinates on selected flux
+  - A nice choice for visualising magnetic ripple
+  - 2D plots of $|B|(\alpha, \zeta)$
+  - 1D plots of single period field line traces with different initial $\alpha$ values
+  - Single field line transistions.
+- **JAX acceleration** for geometry reconstruction.
+
+---
+
+## Requirements
+
+Python 3.10+ is recommended. Install dependencies with conda:(optional)
+
+```bash
+conda activate your_env_name
+pip install -r requirements.txt
+```
+
+> **Note for JAX:** If you don't have a GPU/TPU or your gpu is not supported for FP64(like metal), then simply running `pip install jax[cpu]` to  install the CPU-only version is good enough.
+> GPU/TPU wheels require platform-specific instructions from the [JAX documentation](https://github.com/google/jax#pip-installation).
+
+---
+
+## Running the App
+
+```bash
+python VMECdash.py
+```
+
+Dash defaults to `http://127.0.0.1:8050/`. The layout is responsive, so you can resize the browser to focus on plots or the control sidebar.
+
+The packaged entry point is also available after installation:
+
+```bash
+pip install -e ".[dash]"
+vmecdash serve
+```
+
+---
+
+## VS Code Native Preview
+
+VMECdash now includes the first native VS Code integration surface:
+
+- a Dash-free Python backend at `python -m vmecdash.vscode_backend --stdio`;
+- a workspace VS Code extension under `extension/`;
+- a Custom Readonly Editor for `wout*.nc` files;
+- a Webview UI that renders backend Plotly figures with bundled `plotly.min.js`.
+
+For local development, install the Python package in the interpreter VS Code should use:
+
+```bash
+pip install -e .
+```
+
+Then open `extension/` as a VS Code extension development project or package it as a VSIX. In Remote-SSH, install `vmecdash` in the remote Python environment and set `vmecdash.pythonPath` if VS Code does not pick the desired interpreter.
+
+
+---
+
+## Usage Tips
+
+1. **Upload** a VMEC NetCDF file (`wout_*.nc`) via the drag‑and‑drop area in the sidebar.
+2. Use **Visualization Mode** to switch between:
+   - **Summary Dashboard** (shows statistics + multi-panel plots),
+   - **1D Profiles**, **2D Cross Sections**, **2D Flux Surfaces**, and **3D Geometry**.
+3. Adjust **sliders** for toroidal angle (`phi`), flux surface index (`s`), and choose different physical quantities from the dropdowns.
+4. Toggle **Coordinate-free background** in 3‑D mode for clean screenshots.
+5. Click **Download Plot** to export the currently visible figure as a PNG.
+
+The app caches equilibrium metadata, so switching modes or variables is fast.  
+For heavy 2‑D physics overlays, a pre-computation step runs on the server while keeping the UI responsive.
+
+---
+
+## Repository Layout
+
+| Path               | Description                                                      |
+| ------------------ | ---------------------------------------------------------------- |
+| `VMECdash.py`| Main Dash entry point (layout + callbacks).                      |
+| `vmec_jax.py`      | JAX-powered data processor for VMEC equilibria.                  |
+| `views/`           | Modular UI components (overview, profiles, 2D/3D, fieldlines).  |
+| `ui/`              | Shared UI helper components.                                    |
+| `requirements.txt` | Python dependencies.                                             |
+| `example/wout_PO.nc`       | Example VMEC equilibrium (use your own files for new cases).     |
+
+---
+
+## TroubleShooting
+Feel free to open issues or pull requests to add new physical quantities, UI tweaks, or performance optimisations. Enjoy exploring your VMEC equilibria! 
+
+## Next step
+- Add jax-based boozer coordinate transformation.
+- Fast evaulation of EffetiveRipple, GammaC, maybe slow without gpu.

vmecdash-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vmecdash"
+version = "0.1.0"
+description = "Dash and VS Code tooling for inspecting VMEC wout NetCDF equilibria"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Hengqian Liu" }]
+keywords = ["vmec", "stellarator", "plasma", "equilibrium", "netcdf", "plotly", "fusion"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+  "plotly>=5.22.0",
+  "numpy>=1.24.0",
+  "xarray>=2024.1.0",
+  "netCDF4>=1.6.5",
+  "jax>=0.4.26",
+  "jaxlib>=0.4.26",
+]
+
+[project.optional-dependencies]
+dash = [
+  "dash>=2.16.1",
+  "dash-mantine-components>=0.14.5",
+  "dash-iconify>=0.1.2",
+]
+dev = [
+  "pytest>=8",
+]
+
+[project.scripts]
+vmecdash = "vmecdash.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/DMCXE/VMECdash"
+Repository = "https://github.com/DMCXE/VMECdash"
+Issues = "https://github.com/DMCXE/VMECdash/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["vmecdash*"]
+
+[tool.setuptools.package-data]
+vmecdash = ["py.typed", "dash_app/assets/*.png"]

vmecdash-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vmecdash-0.1.0/tests/test_cross_section_mesh.py

@@ -0,0 +1,158 @@
+import os
+import sys
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+os.environ.setdefault("MPLCONFIGDIR", "/tmp/mpl-codex")
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from vmecdash.core import VMECJaxProcessor
+
+
+EXAMPLE_WOUT = "example/wout_PO.nc"
+PS3_WOUT = Path("/Users/dmcxe/Downloads/wout_PS3_ms_dofs.nc")
+
+
+def _eval_fourier_rows(cos_coeffs, sin_coeffs, xm, xn, theta, phi):
+    theta = np.asarray(theta)
+    angle = np.asarray(xm)[:, None] * theta[None, :] - np.asarray(xn)[:, None] * phi
+    cos_angle = np.cos(angle)
+    sin_angle = np.sin(angle)
+    return np.asarray(cos_coeffs) @ cos_angle + np.asarray(sin_coeffs) @ sin_angle
+
+
+def _simsopt_full_grid_geometry(phi, theta):
+    simsopt_mhd = pytest.importorskip("simsopt.mhd")
+    vmec = simsopt_mhd.Vmec(EXAMPLE_WOUT)
+    splines = simsopt_mhd.vmec_splines(vmec)
+    return simsopt_mhd.vmec_compute_geometry(splines, vmec.s_full_grid, theta, np.array([phi]))
+
+
+def test_cross_section_mesh_half_mesh_fields_match_simsopt_full_grid():
+    """Half-mesh fields are spline-interpolated from VMEC half grid to full nodes."""
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+    phi = 0.37
+    res_u = 32
+    theta_nodes = np.linspace(0.0, 2 * np.pi, res_u + 1)
+    geometry = _simsopt_full_grid_geometry(phi, theta_nodes)
+
+    references = {
+        "modB": geometry.modB[:, :, 0],
+        "jacobian": geometry.sqrt_g_vmec[:, :, 0],
+        "lambda": (geometry.theta_pest - geometry.theta_vmec)[:, :, 0],
+        "B_u": geometry.B_sub_theta_vmec[:, :, 0],
+        "B_v": geometry.B_sub_phi[:, :, 0],
+        "B^u": geometry.B_sup_theta_vmec[:, :, 0],
+        "B^v": geometry.B_sup_phi[:, :, 0],
+    }
+
+    for field, expected in references.items():
+        r_nodes, z_nodes, values = vmec.get_cross_section_mesh(phi, field, res_u=res_u)
+
+        assert r_nodes.shape == (vmec.ns, res_u + 1)
+        assert z_nodes.shape == (vmec.ns, res_u + 1)
+        assert values.shape == (vmec.ns, res_u + 1)
+        np.testing.assert_allclose(values[1:], expected[1:], rtol=1e-10, atol=1e-10)
+        np.testing.assert_allclose(values[0], values[0, 0], rtol=0.0, atol=0.0)
+
+
+def test_cross_section_mesh_full_mesh_evaluates_at_nodes():
+    """Full-mesh fields remain direct Fourier values except for axis single-valuing."""
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+    phi = 0.4
+    res_u = 24
+
+    theta_nodes = np.linspace(0.0, 2 * np.pi, res_u + 1)
+    for field in ("B_s", "j^u", "j^v"):
+        _, _, values = vmec.get_cross_section_mesh(phi, field, res_u=res_u)
+        assert values.shape == (vmec.ns, res_u + 1)
+
+        payload = vmec._field_payload(field)
+        cos_coeffs, sin_coeffs = payload["pair"]
+        direct = _eval_fourier_rows(cos_coeffs, sin_coeffs, payload["xm"], payload["xn"], theta_nodes, phi)
+
+        np.testing.assert_allclose(values[1:], direct[1:], rtol=1e-12, atol=1e-8)
+        np.testing.assert_allclose(values[0], np.mean(direct[0, :-1]), rtol=1e-12, atol=1e-8)
+
+    _, _, j_u_values = vmec.get_cross_section_mesh(phi, "j^u", res_u=res_u)
+    assert np.max(np.abs(j_u_values[0] - j_u_values[1])) > 1.0
+
+
+def test_cross_section_field_renderer_builds_carpet():
+    from vmecdash.renderers.two_d import render_cross_section_field
+    from vmecdash.theme import build_theme
+
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+    fig = render_cross_section_field(vmec, 0.0, "modB", "|B| (Mod B)", build_theme(True, 0))
+
+    trace_types = {trace.type for trace in fig.data}
+    assert "carpet" in trace_types
+    assert "contourcarpet" in trace_types
+    assert len(fig.layout.images) == 0
+
+
+def test_lambda_cross_section_uses_axis_fill_regularization():
+    from vmecdash.renderers.two_d import _carpet_colorscale, _sample_field_color, render_cross_section_field
+    from vmecdash.theme import build_theme
+
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+    _, _, val_nodes = vmec.get_cross_section_mesh(0.0, "lambda", res_u=480)
+    colorscale, reversescale, zmin, zmax = _carpet_colorscale(val_nodes)
+    axis_value = float(np.nanmean(val_nodes[1, :-1]))
+    expected_fill = _sample_field_color(axis_value, colorscale, reversescale, zmin, zmax)
+
+    fig = render_cross_section_field(vmec, 0.0, "lambda", "Lambda", build_theme(True, 0))
+    trace_types = [trace.type for trace in fig.data]
+    sample_trace = next(trace for trace in fig.data if trace.name == "Lambda samples")
+
+    assert trace_types == ["scatter", "scattergl", "scatter"]
+    assert "carpet" not in trace_types
+    assert "contourcarpet" not in trace_types
+    assert not any(trace.name == "Lambda quad fill" for trace in fig.data)
+    assert fig.data[0].fill == "toself"
+    assert fig.data[0].name == "Axis fill"
+    assert fig.data[0].fillcolor == expected_fill
+    assert sample_trace.marker.showscale is True
+    assert sample_trace.marker.cmin == zmin
+    assert sample_trace.marker.cmax == zmax
+    assert sample_trace.marker.size == 6
+    assert len(sample_trace.x) > 0
+    assert len(fig.layout.images) == 0
+
+
+def test_modb_cross_section_keeps_degenerate_axis_in_carpet():
+    from vmecdash.renderers.two_d import render_cross_section_field
+    from vmecdash.theme import build_theme
+
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+    fig = render_cross_section_field(vmec, 0.0, "modB", "|B| (Mod B)", build_theme(True, 0))
+    trace_types = [trace.type for trace in fig.data]
+    contour = next(trace for trace in fig.data if trace.type == "contourcarpet")
+
+    assert trace_types == ["carpet", "contourcarpet", "scatter"]
+    assert np.min(np.asarray(contour.b, dtype=float)) == 0.0
+
+
+def test_ps3_lambda_cross_section_uses_sampled_field():
+    if not PS3_WOUT.exists():
+        pytest.skip("PS3 local smoke fixture is not available")
+
+    from vmecdash.renderers.two_d import render_cross_section_field
+    from vmecdash.theme import build_theme
+
+    vmec = VMECJaxProcessor.from_file(str(PS3_WOUT))
+    fig = render_cross_section_field(vmec, 0.0, "lambda", "Lambda", build_theme(True, 0))
+    trace_types = [trace.type for trace in fig.data]
+    sample_traces = [trace for trace in fig.data if trace.name == "Lambda samples"]
+
+    assert fig.data[0].fill == "toself"
+    assert "contourcarpet" not in trace_types
+    assert "carpet" not in trace_types
+    assert not any(trace.name == "Lambda quad fill" for trace in fig.data)
+    assert len(sample_traces) == 1
+    assert len(sample_traces[0].x) > 0

vmecdash-0.1.0/tests/test_fieldline_numerics.py

@@ -0,0 +1,81 @@
+import importlib.util
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+os.environ.setdefault("MPLCONFIGDIR", os.path.join(tempfile.gettempdir(), "vmecdash-mpl"))
+
+from vmecdash.core import VMECJaxProcessor
+
+
+EXAMPLE_WOUT = "example/wout_PO.nc"
+
+
+class _Var:
+    def __init__(self, values):
+        self.values = values
+
+
+def test_lambda_pair_keeps_lmns_for_stellarator_symmetric_file():
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+    lmnc, lmns = vmec._lambda_pair()
+
+    assert not vmec.lasym
+    assert np.max(np.abs(np.asarray(lmns))) > 0.0
+    assert np.max(np.abs(np.asarray(lmnc))) == 0.0
+
+
+def test_fieldline_axis_index_uses_first_half_mesh_surface():
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+
+    _, _, b_axis = vmec.compute_field_line_properties(0, alpha_points=4, zeta_points=8)
+    _, _, b_first = vmec.compute_field_line_properties(1, alpha_points=4, zeta_points=8)
+
+    assert np.max(np.abs(b_axis)) > 0.0
+    np.testing.assert_allclose(b_axis, b_first, rtol=0.0, atol=0.0)
+
+
+def test_asymmetric_lambda_and_b_sine_pairs_are_preserved():
+    proc = object.__new__(VMECJaxProcessor)
+    proc.lasym = True
+    lmnc = np.array([[1.0, 2.0]])
+    lmns = np.array([[3.0, 4.0]])
+    bmnc = np.array([[5.0, 6.0]])
+    bmns = np.array([[7.0, 8.0]])
+    proc.ds = {"lmnc": _Var(lmnc), "lmns": _Var(lmns), "bmnc": _Var(bmnc), "bmns": _Var(bmns)}
+
+    out_lmnc, out_lmns = proc._lambda_pair()
+    out_bmnc, out_bmns = proc._coeff_pair("bmnc", "bmns")
+
+    np.testing.assert_allclose(out_lmnc, lmnc)
+    np.testing.assert_allclose(out_lmns, lmns)
+    np.testing.assert_allclose(out_bmnc, bmnc)
+    np.testing.assert_allclose(out_bmns, bmns)
+
+
+def test_fieldline_modb_matches_simsopt_reference():
+    if importlib.util.find_spec("simsopt") is None:
+        import pytest
+
+        pytest.skip("simsopt is required for the reference comparison")
+
+    from simsopt.mhd import Vmec, vmec_fieldlines, vmec_splines
+
+    s_idx = 60
+    vmec = VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+    alpha, zeta, b_dash = vmec.compute_field_line_properties(
+        s_idx, alpha_points=12, zeta_points=48, single_line=False
+    )
+
+    simsopt_vmec = Vmec(EXAMPLE_WOUT, verbose=False)
+    splines = vmec_splines(simsopt_vmec)
+    s_half = float(simsopt_vmec.s_half_grid[s_idx - 1])
+    ref = vmec_fieldlines(splines, s_half, alpha, phi1d=zeta, phi_center=0, plot=False)
+
+    np.testing.assert_allclose(b_dash, ref.modB[0], rtol=1e-10, atol=1e-10)

vmecdash-0.1.0/tests/test_view_schema.py

@@ -0,0 +1,94 @@
+import json
+import os
+import sys
+from pathlib import Path
+
+import plotly.graph_objects as go
+
+os.environ.setdefault("MPLCONFIGDIR", "/tmp/mpl-codex")
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from vmecdash import view_schema
+from vmecdash.core import VMECJaxProcessor
+from vmecdash.theme import build_theme
+from vmecdash.vscode_backend import VmecDashBackend, figure_to_jsonable
+
+EXAMPLE_WOUT = "example/wout_PO.nc"
+EXPECTED_VIEWS = ["overview", "1d", "2d", "3d", "fieldline"]
+
+
+def _vmec():
+    return VMECJaxProcessor.from_file(EXAMPLE_WOUT)
+
+
+def _field_map(vmec):
+    return {opt["value"]: opt.get("label", opt["value"]) for opt in vmec.available_fields()}
+
+
+def test_registry_covers_expected_views():
+    assert list(view_schema.VIEWS) == EXPECTED_VIEWS
+
+
+def test_render_view_smoke_for_every_view_with_default_controls():
+    vmec = _vmec()
+    theme = build_theme(True, 0)
+    field_map = _field_map(vmec)
+    for view_id in view_schema.VIEWS:
+        fig = view_schema.render_view(view_id, vmec, {}, theme, field_map)
+        assert isinstance(fig, go.Figure)
+
+
+def test_build_ui_schema_lists_views_and_resolves_ns_tokens():
+    vmec = _vmec()
+    schema = view_schema.build_ui_schema(vmec)
+    assert [v["id"] for v in schema["views"]] == EXPECTED_VIEWS
+
+    twod = next(v for v in schema["views"] if v["id"] == "2d")
+    s_idx = next(c for c in twod["controls"] if c["id"] == "sIdx")
+    assert s_idx["max"] == vmec.ns - 1
+    assert isinstance(s_idx["max"], int)
+    assert s_idx["default"] == vmec.ns - 1
+
+    fieldline = next(v for v in schema["views"] if v["id"] == "fieldline")
+    fl_s = next(c for c in fieldline["controls"] if c["id"] == "fieldlineSIdx")
+    assert fl_s["default"] == max(1, vmec.ns - 1)
+
+
+def test_no_default_drift_between_schema_and_render_fallback():
+    """The default shipped to the Webview must equal the render-time fallback (cv())."""
+    vmec = _vmec()
+    schema = view_schema.build_ui_schema(vmec)
+    for view in schema["views"]:
+        for control in view["controls"]:
+            assert control["default"] == view_schema.cv({}, view["id"], control["id"], vmec)
+
+
+def test_health_features_derived_from_registry():
+    backend = VmecDashBackend()
+    features = backend.health()["features"]
+    assert features == list(view_schema.VIEWS) + ["exportReport"]
+
+
+def test_render_view_serializes_without_nonfinite():
+    vmec = _vmec()
+    theme = build_theme(True, 0)
+    field_map = _field_map(vmec)
+    # lambda cross-section carries NaN/Inf at the axis; the wire writer forbids bare NaN/Inf.
+    fig = view_schema.render_view("2d", vmec, {"type2d": "cross_section", "var2d": "lambda"}, theme, field_map)
+    payload = figure_to_jsonable(fig)
+    json.dumps(payload, allow_nan=False)  # must not raise
+
+
+def test_single_trace_uses_no_webgl_trace():
+    """Single Trace must render with SVG scatter, not Scattergl (webview WebGL-context cap)."""
+    from vmecdash.renderers.fieldline import render_single_trace
+
+    vmec = _vmec()
+    theme = build_theme(True, 0)
+    fig = render_single_trace(vmec, max(1, vmec.ns - 1), 20, 0.0, 64, theme)
+    types = [trace.type for trace in fig.data]
+    assert "scattergl" not in types
+    assert "scatter" in types