ace-jax 0.1.0__tar.gz

ace_jax-0.1.0/.gitignore

@@ -0,0 +1,25 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+dist/
+build/
+*.egg-info/
+.uv/
+.jax_cache/
+pace_ref/build/
+pace_ref/.venv/
+bench/scaling/models/
+coupling/build/
+!coupling/julia/build/
+dist-linux/
+# marimo session caches (written by `marimo export`/`edit`); also the docs build output
+__marimo__/
+site/
+# tutorial pages rendered from the notebooks by docs/build_tutorials.py
+docs/user/tutorials/first-fit.md
+docs/user/tutorials/learned-radials.md
+docs/user/tutorials/dataset-and-properties.md
+docs/user/tutorials/basis-and-evidence.md
+docs/user/tutorials/truth-about-the-truth.md
+docs/user/tutorials/*_files/

ace_jax-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Christoph Ortner <christophortner0@gmail.com> and contributors
+
+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.

ace_jax-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.5
+Name: ace-jax
+Version: 0.1.0
+Summary: Fit and evaluate ACE interatomic potentials in Python/JAX
+Project-URL: Homepage, https://github.com/ACEsuit/ace-jax
+Project-URL: Documentation, https://acesuit.github.io/ace-jax/
+Project-URL: Source, https://github.com/ACEsuit/ace-jax
+Project-URL: Issues, https://github.com/ACEsuit/ace-jax/issues
+Project-URL: Changelog, https://github.com/ACEsuit/ace-jax/blob/main/CHANGELOG.md
+Author: ACEsuit contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ace,chemistry,gaussian-process,interatomic-potential,jax,molecular-dynamics
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Requires-Dist: ace-jax-coupling==0.2.0; (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) or (sys_platform == 'darwin' and platform_machine == 'arm64') or (sys_platform == 'win32' and platform_machine == 'AMD64')
+Requires-Dist: ase-extxyz>=0.1.2
+Requires-Dist: ase>=3.22
+Requires-Dist: equinox>=0.11
+Requires-Dist: extxyz>=0.4.6
+Requires-Dist: jax>=0.10.1
+Requires-Dist: lineax>=0.1.1
+Requires-Dist: numpy>=1.24
+Requires-Dist: numpyro>=0.16
+Requires-Dist: optax>=0.2
+Requires-Dist: pyyaml>=6
+Requires-Dist: scipy>=1.10
+Provides-Extra: cuda
+Requires-Dist: jax[cuda12]>=0.10.1; extra == 'cuda'
+Provides-Extra: fast-neighbours
+Requires-Dist: matscipy-neighbours>=1.0; extra == 'fast-neighbours'
+Provides-Extra: gp
+Requires-Dist: blackjax>=1.6; extra == 'gp'
+Description-Content-Type: text/markdown
+
+# ace-jax
+
+[![PyPI](https://img.shields.io/pypi/v/ace-jax)](https://pypi.org/project/ace-jax/)
+[![Docs](https://img.shields.io/github/actions/workflow/status/ACEsuit/ace-jax/docs.yml?branch=main&label=docs)](https://acesuit.github.io/ace-jax/)
+[![Tests](https://img.shields.io/github/actions/workflow/status/ACEsuit/ace-jax/test.yml?branch=main&label=tests)](https://github.com/ACEsuit/ace-jax/actions/workflows/test.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/ACEsuit/ace-jax/blob/main/LICENSE)
+
+Build, fit and evaluate **Atomic Cluster Expansion (ACE)** interatomic
+potentials in Python with [JAX](https://docs.jax.dev), on CPU or GPU, all from
+one `pip install`.
+
+**Documentation: <https://acesuit.github.io/ace-jax/>**: installation,
+quickstart, tutorials, how-to guides, and the CLI and API reference.
+
+## What it does
+
+- **Build a basis and fit it in one command.** `aj fit --order 3 --max-degree 10
+  --train train.xyz --out fit` builds the symmetry-adapted ACE basis and fits it.
+  The `fit.yaml` it writes reproduces the run.
+- **Bayesian fits.** Linear ACE is fitted by Bayesian linear regression, with the
+  energy, force and virial noise levels and the prior scale chosen by maximising
+  the evidence: no hand-tuned weights. A hybrid ACE + Gaussian-process arm adds
+  a calibrated uncertainty ladder (MAP, Laplace, Pathfinder, VI, NUTS), and the
+  linear model has POPS and ARD uncertainties. The radial basis can be learned
+  as part of the fit (`--learn-radial`).
+- **Fast evaluation.** `ACECalculator` and `GPCalculator` are ASE calculators,
+  fast enough for molecular dynamics, with predicted `energy_std` and
+  `forces_std` for GP and ARD models. `export_lammps` deploys a model to LAMMPS
+  through [lammps-jax](https://github.com/abhijeetgangan/lammps-jax).
+- **PACE potentials.** pacemaker `.yace` files load, evaluate and write back.
+- **Data in, data out.** Training data is extended XYZ or a list of `ase.Atoms`
+  (stress labels are converted to virials). `aj eval` writes predictions as
+  extended XYZ, with an RMSE table per config type.
+
+## Install
+
+```bash
+pip install ace-jax
+```
+
+Extras: `"ace-jax[cuda]"` (CUDA 12 JAX), `"ace-jax[gp]"` (the Pathfinder rung)
+and `"ace-jax[fast-neighbours]"` (a C++ neighbour list). Building new bases needs
+the `ace-jax-coupling` wheel, a core dependency available for Linux x86_64 and
+aarch64, macOS arm64 and Windows x64; elsewhere, fit and evaluate from an
+existing basis file. See
+[Installation](https://acesuit.github.io/ace-jax/installation/).
+
+## Quickstart
+
+Fit a linear ACE model to labelled data, check it on a test set, and evaluate it:
+
+```bash
+aj fit --order 3 --max-degree 10 --train train.xyz --test test.xyz \
+    --e0 lsq --m-per-species 0 --opt lbfgs --out fit
+aj eval --model fit/model.npz --data test.xyz --out predictions.xyz
+```
+
+Use the fitted model from Python:
+
+```python
+import jax
+jax.config.update("jax_enable_x64", True)
+
+from ase.build import bulk
+from ace_jax import ACECalculator
+
+atoms = bulk("Si", "diamond", a=5.43, cubic=True)
+atoms.calc = ACECalculator("fit/model.npz")
+print(atoms.get_potential_energy(), atoms.get_forces())
+```
+
+The [Quickstart](https://acesuit.github.io/ace-jax/quickstart/) runs this on a
+small silicon data set, and the
+[tutorials](https://acesuit.github.io/ace-jax/tutorials/) are notebooks that run
+on a laptop CPU, including ones adapted from the
+[MLIP school 2026](https://github.com/ACEsuit/MLIP-school-2026). For coding
+agents, [`skills/ace-jax/SKILL.md`](https://github.com/ACEsuit/ace-jax/blob/main/skills/ace-jax/SKILL.md)
+is a compact usage guide.
+
+## Performance and validation
+
+Fits reproduce ACEfit's design matrix and least-squares solve to 1e-8, and PACE
+evaluation matches the ML-PACE C++ code and python-ace; CI checks both. The
+throughput benchmarks against LAMMPS ML-PACE are in
+[`docs/dev/benchmarks.md`](https://github.com/ACEsuit/ace-jax/blob/main/docs/dev/benchmarks.md).
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/ACEsuit/ace-jax/blob/main/CONTRIBUTING.md)
+for the development setup, tests and the reference-parity jobs, and the
+[changelog](https://github.com/ACEsuit/ace-jax/blob/main/CHANGELOG.md) for
+releases. ace-jax is MIT-licensed and part of [ACEsuit](https://github.com/ACEsuit).

ace_jax-0.1.0/README.md

@@ -0,0 +1,92 @@
+# ace-jax
+
+[![PyPI](https://img.shields.io/pypi/v/ace-jax)](https://pypi.org/project/ace-jax/)
+[![Docs](https://img.shields.io/github/actions/workflow/status/ACEsuit/ace-jax/docs.yml?branch=main&label=docs)](https://acesuit.github.io/ace-jax/)
+[![Tests](https://img.shields.io/github/actions/workflow/status/ACEsuit/ace-jax/test.yml?branch=main&label=tests)](https://github.com/ACEsuit/ace-jax/actions/workflows/test.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](https://github.com/ACEsuit/ace-jax/blob/main/LICENSE)
+
+Build, fit and evaluate **Atomic Cluster Expansion (ACE)** interatomic
+potentials in Python with [JAX](https://docs.jax.dev), on CPU or GPU, all from
+one `pip install`.
+
+**Documentation: <https://acesuit.github.io/ace-jax/>**: installation,
+quickstart, tutorials, how-to guides, and the CLI and API reference.
+
+## What it does
+
+- **Build a basis and fit it in one command.** `aj fit --order 3 --max-degree 10
+  --train train.xyz --out fit` builds the symmetry-adapted ACE basis and fits it.
+  The `fit.yaml` it writes reproduces the run.
+- **Bayesian fits.** Linear ACE is fitted by Bayesian linear regression, with the
+  energy, force and virial noise levels and the prior scale chosen by maximising
+  the evidence: no hand-tuned weights. A hybrid ACE + Gaussian-process arm adds
+  a calibrated uncertainty ladder (MAP, Laplace, Pathfinder, VI, NUTS), and the
+  linear model has POPS and ARD uncertainties. The radial basis can be learned
+  as part of the fit (`--learn-radial`).
+- **Fast evaluation.** `ACECalculator` and `GPCalculator` are ASE calculators,
+  fast enough for molecular dynamics, with predicted `energy_std` and
+  `forces_std` for GP and ARD models. `export_lammps` deploys a model to LAMMPS
+  through [lammps-jax](https://github.com/abhijeetgangan/lammps-jax).
+- **PACE potentials.** pacemaker `.yace` files load, evaluate and write back.
+- **Data in, data out.** Training data is extended XYZ or a list of `ase.Atoms`
+  (stress labels are converted to virials). `aj eval` writes predictions as
+  extended XYZ, with an RMSE table per config type.
+
+## Install
+
+```bash
+pip install ace-jax
+```
+
+Extras: `"ace-jax[cuda]"` (CUDA 12 JAX), `"ace-jax[gp]"` (the Pathfinder rung)
+and `"ace-jax[fast-neighbours]"` (a C++ neighbour list). Building new bases needs
+the `ace-jax-coupling` wheel, a core dependency available for Linux x86_64 and
+aarch64, macOS arm64 and Windows x64; elsewhere, fit and evaluate from an
+existing basis file. See
+[Installation](https://acesuit.github.io/ace-jax/installation/).
+
+## Quickstart
+
+Fit a linear ACE model to labelled data, check it on a test set, and evaluate it:
+
+```bash
+aj fit --order 3 --max-degree 10 --train train.xyz --test test.xyz \
+    --e0 lsq --m-per-species 0 --opt lbfgs --out fit
+aj eval --model fit/model.npz --data test.xyz --out predictions.xyz
+```
+
+Use the fitted model from Python:
+
+```python
+import jax
+jax.config.update("jax_enable_x64", True)
+
+from ase.build import bulk
+from ace_jax import ACECalculator
+
+atoms = bulk("Si", "diamond", a=5.43, cubic=True)
+atoms.calc = ACECalculator("fit/model.npz")
+print(atoms.get_potential_energy(), atoms.get_forces())
+```
+
+The [Quickstart](https://acesuit.github.io/ace-jax/quickstart/) runs this on a
+small silicon data set, and the
+[tutorials](https://acesuit.github.io/ace-jax/tutorials/) are notebooks that run
+on a laptop CPU, including ones adapted from the
+[MLIP school 2026](https://github.com/ACEsuit/MLIP-school-2026). For coding
+agents, [`skills/ace-jax/SKILL.md`](https://github.com/ACEsuit/ace-jax/blob/main/skills/ace-jax/SKILL.md)
+is a compact usage guide.
+
+## Performance and validation
+
+Fits reproduce ACEfit's design matrix and least-squares solve to 1e-8, and PACE
+evaluation matches the ML-PACE C++ code and python-ace; CI checks both. The
+throughput benchmarks against LAMMPS ML-PACE are in
+[`docs/dev/benchmarks.md`](https://github.com/ACEsuit/ace-jax/blob/main/docs/dev/benchmarks.md).
+
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/ACEsuit/ace-jax/blob/main/CONTRIBUTING.md)
+for the development setup, tests and the reference-parity jobs, and the
+[changelog](https://github.com/ACEsuit/ace-jax/blob/main/CHANGELOG.md) for
+releases. ace-jax is MIT-licensed and part of [ACEsuit](https://github.com/ACEsuit).

ace_jax-0.1.0/pyproject.toml

@@ -0,0 +1,145 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ace-jax"
+version = "0.1.0"
+description = "Fit and evaluate ACE interatomic potentials in Python/JAX"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.11"
+authors = [{ name = "ACEsuit contributors" }]
+keywords = ["ace", "interatomic-potential", "jax", "molecular-dynamics", "chemistry", "gaussian-process"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Scientific/Engineering :: Chemistry",
+  "Topic :: Scientific/Engineering :: Physics",
+]
+dependencies = [
+  "jax>=0.10.1",
+  "equinox>=0.11",
+  "numpy>=1.24",
+  "scipy>=1.10",
+  "lineax>=0.1.1",
+  "ase>=3.22",          # core: neighbour-list fallback (eval) + calculators + element data
+  "pyyaml>=6",          # .yace (PACE) model files
+  # training/eval data reader (libAtoms C parser, binary wheels): labels come back
+  # as written, independent of ASE's calculator-key handling (see fit/xyz.py)
+  "extxyz>=0.4.6",
+  # aj eval writes its extxyz output through the ASE plugin (create_calc=False keeps every
+  # label under its own name); 0.1.2 / extxyz 0.4.6 fixed a transposed Lattice on write
+  "ase-extxyz>=0.1.2",
+  # the fit pipeline: the theta-MAP (numpyro SVI) and the L-BFGS / Adam optimisers (optax)
+  "numpyro>=0.16",
+  "optax>=0.2",
+  # coupling tables for new basis shapes (a compiled library, nothing to install
+  # besides the wheel); platform wheels only -- elsewhere fit from an existing .npz
+  "ace-jax-coupling==0.2.0; (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'aarch64')) or (sys_platform == 'darwin' and platform_machine == 'arm64') or (sys_platform == 'win32' and platform_machine == 'AMD64')",
+]
+
+[project.optional-dependencies]
+# The pathfinder rung of the hyperparameter UQ ladder (everything else in `aj fit`,
+# GP arm included, needs only the core dependencies).
+gp = ["blackjax>=1.6"]
+cuda = ["jax[cuda12]>=0.10.1"]
+# Fast neighbour lists; ace-jax uses them when present and falls back to ASE's
+# list otherwise, so they are intentionally NOT core deps.  matscipy-neighbours
+# (preferred: OpenMP CPU, native dense neighbour_matrix) ships as a source
+# distribution: installing it compiles C++ (CMake + a C++17 compiler).  For its
+# GPU backend (graph built on the device, handed to JAX via DLPack):
+#   pip install -C cmake.define.ENABLE_CUDA=ON \
+#       -C cmake.define.CMAKE_CUDA_ARCHITECTURES=<sm> matscipy-neighbours
+fast-neighbours = ["matscipy-neighbours>=1.0"]
+
+[project.scripts]
+ace-jax = "ace_jax.cli:main"
+aj = "ace_jax.cli:main"          # short alias
+
+[project.urls]
+Homepage = "https://github.com/ACEsuit/ace-jax"
+Documentation = "https://acesuit.github.io/ace-jax/"
+Source = "https://github.com/ACEsuit/ace-jax"
+Issues = "https://github.com/ACEsuit/ace-jax/issues"
+Changelog = "https://github.com/ACEsuit/ace-jax/blob/main/CHANGELOG.md"
+
+[dependency-groups]
+# mirrors the `gp` extra so a plain `uv run pytest` can run the GP ladder tests
+dev = [
+  "pytest>=8", "pytest-split>=0.8", "pytest-xdist>=3.5", "numpyro>=0.16", "optax>=0.2", "blackjax>=1.6",
+  # lint + hooks; keep ruff in step with the rev in .pre-commit-config.yaml
+  "ruff==0.16.9", "pre-commit>=4",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ace_jax"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/src/ace_jax", "/README.md", "/LICENSE"]   # anchored: unanchored names match nested READMEs too
+
+[tool.pytest.ini_options]
+pythonpath = ["src", "tests"]
+testpaths = ["tests"]
+# `slow` (real-model ladder, bit-exact goldens) is opt-in: `pytest -m slow`
+addopts = "--durations=15 -m 'not slow'"
+markers = [
+    "slow: heavy integration (real-model MCMC ladder, bit-exact driver goldens); excluded by default -- run with `pytest -m slow`",
+]
+
+[tool.ruff]
+# ~99.9% of src/tests lines are <= 110 already; no formatter is enforced
+# (`ruff format` would rewrite the deliberately dense one-line style).
+line-length = 110
+target-version = "py311"                       # requires-python >= 3.11
+# Not linted: reference generators / experiments that are not part of the package.
+extend-exclude = ["pace_ref", "julia", "docs", "fixtures", ".worktrees"]
+
+[tool.ruff.lint]
+# pycodestyle, pyflakes, bugbear, pyupgrade; NPY guards NumPy-2 removals.
+# No "I" (isort): ruff's isort always splits `import a, b` and re-wraps dense
+# parenthesised imports one-per-line (74 files, +270/-138), and reorders package
+# __init__ imports; that is a restyle, not a fix.
+select = ["E", "F", "W", "B", "UP", "NPY"]
+ignore = [
+  # House style, not bugs: dense `a = ...; b = ...` lines, one-line `if x: y`,
+  # short math names (l, I, O), named lambdas, `import os, sys`.
+  "E701", "E702", "E741", "E731", "E401",
+  # Imports after jax.config.update("jax_enable_x64", ...) / importorskip are deliberate.
+  "E402",
+  # Long lines are tolerated (no formatter); line-length documents the target.
+  "E501",
+  # zip(strict=True) would change behaviour on length mismatch; opt in case by case.
+  "B905",
+]
+
+
+[tool.ruff.lint.per-file-ignores]
+# B023 (closure over a loop variable): every site in these files was reviewed and
+# is a false positive -- the closure is consumed in the same iteration
+# (`jax.tree.map(lambda a: a[i], ds)`, in-loop jit timing).  Listed per file so
+# the rule still guards new files.
+"bench/learn_radial/compare_plots.py" = ["B023"]
+"bench/learn_radial/plots.py" = ["B023"]
+"bench/learn_radial/rmse.py" = ["B023"]
+"bench/learn_radial/rmse_npz.py" = ["B023"]
+"bench/learn_radial/tradeoff.py" = ["B023"]
+"src/ace_jax/fit/hostcache.py" = ["B023"]
+"src/ace_jax/fit/pipeline/predict.py" = ["B023"]
+"src/ace_jax/fit/predict.py" = ["B023"]
+"src/ace_jax/fit/radial_model.py" = ["B023"]
+"src/ace_jax/fit/solve.py" = ["B023"]
+"src/ace_jax/fit/stats.py" = ["B023"]
+"tests/test_ard.py" = ["B023"]
+"tests/test_gp_learn_radial.py" = ["B023"]
+"tests/test_gp_pops_paper.py" = ["B023"]
+"tests/test_gp_rows.py" = ["B023"]
+"tests/test_gp_stats.py" = ["B023"]
+"tests/test_radial_learn_flags.py" = ["B023"]
+"tests/test_rows_chunked.py" = ["B023"]

ace_jax-0.1.0/src/ace_jax/__init__.py

@@ -0,0 +1,28 @@
+"""ace-jax: fit and evaluate ACE interatomic potentials in Python/JAX.
+
+Build a basis (`ace_jax.basis`), fit it (`ace_jax.fit.pipeline`, or `aj fit`) and
+evaluate it (`ACECalculator`, `export_lammps`). Documentation:
+https://acesuit.github.io/ace-jax/
+"""
+import importlib.metadata as _md
+
+try:
+    __version__ = _md.version("ace-jax")
+except _md.PackageNotFoundError:      # a source tree that was never installed
+    __version__ = "0+unknown"
+from .eval import (ACEModel, load, highest_precision, site_descriptors, species_indices,
+                   sparse_graph, dense_graph)
+
+__all__ = ["__version__", "ACEModel", "load", "highest_precision", "site_descriptors", "species_indices",
+           "sparse_graph", "dense_graph", "ACECalculator", "GPCalculator"]
+
+
+def __getattr__(name):
+    # ase-dependent calculators kept out of the core import path
+    if name == "ACECalculator":
+        from .calc.point import ACECalculator
+        return ACECalculator
+    if name == "GPCalculator":
+        from .calc.gp import GPCalculator
+        return GPCalculator
+    raise AttributeError(name)

ace_jax-0.1.0/src/ace_jax/basis/__init__.py

@@ -0,0 +1,15 @@
+"""Build ACE basis definitions from Python (`BasisSpec`, `build_basis`).
+
+Scope now: the SO(3) coupling table (A2B + aa_spec), generated by the
+compiled EquivariantTensors library (ace-jax-coupling) -- see docs/dev/coupling-etshim-spec.md --
+and the algebraic smoothness prior (prior.py, pure numpy, parity-tested against
+julia/smoothness_reference.jl).  Radials / pair basis / embedding stay exported
+(separate follow-up).
+
+prior.py is deliberately numpy-only so the eval/fit path can import it as a
+fallback for exports that lack gamma (cli.py and the bench driver go through
+prior.prior_diagonal, which rebuilds it from the export's meta["nnll"]); the
+coupling shim is the only piece that
+needs the compiled ace-jax-coupling library (a core dependency on supported platforms;
+elsewhere `BasisUnavailable`).  Refitting on an existing model never touches it.
+"""