rgpot 2.2.1__tar.gz → 2.3.0__tar.gz

{rgpot-2.2.1 → rgpot-2.3.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: rgpot
-Version: 2.2.1
-Summary: Potential energy surfaces for atomistic simulation (LJ + Metatomic dlopen engine)
-Keywords: potential,Lennard-Jones,metatomic,rgpot,potlib,dlopen
+Version: 2.3.0
+Summary: Potential energy surfaces for atomistic simulation (LJ + Metatomic multi-ABI dlopen; nanobind abi3)
+Keywords: potential,Lennard-Jones,metatomic,rgpot,potlib,dlopen,nanobind,abi3
 Author-Email: Rohit Goswami <rgoswami@ieee.org>
 License: MIT
 Classifier: Development Status :: 4 - Beta
@@ -10,6 +10,8 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: C++
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering :: Chemistry
 Classifier: Topic :: Scientific/Engineering :: Physics
 Project-URL: Homepage, https://github.com/OmniPotentRPC/rgpot

rgpot-2.3.0/docs/newsfragments/+pip-nanobind-abi3-multi-torch.added.md

@@ -0,0 +1,4 @@
+Python bindings use **nanobind** with **stable ABI** (abi3 / Py_LIMITED_API 3.12)
+when built on Python >= 3.12 (same policy as pyeonclient). Metatomic engines are
+packed multi-ABI under ``rgpot/lib/torch-X.Y/`` and selected from the installed
+torch major at runtime.

{rgpot-2.2.1 → rgpot-2.3.0}/pixi.toml

@@ -4,7 +4,7 @@ channels = ["conda-forge"]
 description = "RPC based core for potential energy surface functionality."
 name = "rgpot"
 platforms = ["win-64", "linux-64", "osx-64", "osx-arm64"]
-version = "2.2.1"
+version = "2.3.0"
 
 [feature.cigen.tasks]
 # Export every ci/gha/*.ncl workflow (shared pins/steps in ci/gha/lib/).

{rgpot-2.2.1 → rgpot-2.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "rgpot"
-version = "2.2.1"
-description = "Potential energy surfaces for atomistic simulation (LJ + Metatomic dlopen engine)"
+version = "2.3.0"
+description = "Potential energy surfaces for atomistic simulation (LJ + Metatomic multi-ABI dlopen; nanobind abi3)"
 readme = "README.md"
 license = { text = "MIT" }
 authors = [
@@ -17,10 +17,12 @@ classifiers = [
   "License :: OSI Approved :: MIT License",
   "Programming Language :: C++",
   "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: Implementation :: CPython",
   "Topic :: Scientific/Engineering :: Chemistry",
   "Topic :: Scientific/Engineering :: Physics",
 ]
-keywords = ["potential", "Lennard-Jones", "metatomic", "rgpot", "potlib", "dlopen"]
+keywords = ["potential", "Lennard-Jones", "metatomic", "rgpot", "potlib", "dlopen", "nanobind", "abi3"]
 
 [project.urls]
 Homepage = "https://github.com/OmniPotentRPC/rgpot"
@@ -46,7 +48,7 @@ requires = [
   "meson-python>=0.16",
   "meson>=1.3",
   "ninja",
-  "pybind11>=2.11",
+  "nanobind>=2.2",
   "numpy>=1.24",
   # Build-time for libmetatomic_engine.so (same purelib layout at runtime)
   "torch>=2.3",

{rgpot-2.2.1 → rgpot-2.3.0}/python/bind/bind_module.cpp

@@ -1,79 +1,78 @@
 // MIT License
 // Copyright 2023--present rgpot developers
 //
-// Python surface: always-on LJ + MetatomicDlopen frontend (engine .so optional).
+// Python surface: nanobind (stable ABI / abi3 when Python >= 3.12).
+// LJ + MetatomicDlopen frontend (engine .so optional via C ABI).
 
 #include <array>
+#include <cstdint>
+#include <cstring>
 #include <stdexcept>
 #include <string>
 #include <tuple>
 #include <vector>
 
-#include <pybind11/numpy.h>
-#include <pybind11/pybind11.h>
-#include <pybind11/stl.h>
+#include <nanobind/nanobind.h>
+#include <nanobind/ndarray.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
 
 #include "rgpot/LennardJones/LJPot.hpp"
 #include "rgpot/MetatomicPot/MetatomicConfig.hpp"
 #include "rgpot/MetatomicPot/MetatomicDlopen.hpp"
 #include "rgpot/types/AtomMatrix.hpp"
 
-namespace py = pybind11;
+namespace nb = nanobind;
 using rgpot::types::AtomMatrix;
 
+using NpF64 = nb::ndarray<nb::numpy, double, nb::c_contig, nb::device::cpu>;
+using NpI32 = nb::ndarray<nb::numpy, int32_t, nb::c_contig, nb::device::cpu>;
+
 namespace {
 
-AtomMatrix numpy_to_atom_matrix(const py::array_t<double> &arr) {
-  auto buf = arr.unchecked<2>();
-  if (buf.shape(1) != 3) {
+AtomMatrix numpy_to_atom_matrix(const NpF64 &arr) {
+  if (arr.ndim() != 2 || arr.shape(1) != 3) {
     throw std::invalid_argument("positions must have shape (n_atoms, 3)");
   }
-  const auto n = static_cast<size_t>(buf.shape(0));
+  const auto n = static_cast<size_t>(arr.shape(0));
   AtomMatrix mat(n, 3);
-  for (size_t i = 0; i < n; ++i) {
-    for (size_t j = 0; j < 3; ++j) {
-      mat(i, j) = buf(i, j);
-    }
-  }
+  std::memcpy(mat.data(), arr.data(), n * 3 * sizeof(double));
   return mat;
 }
 
-std::vector<int> numpy_to_types(const py::array_t<int> &arr, size_t n_atoms) {
-  auto buf = arr.unchecked<1>();
-  if (static_cast<size_t>(buf.shape(0)) != n_atoms) {
+std::vector<int> numpy_to_types(const NpI32 &arr, size_t n_atoms) {
+  if (arr.ndim() != 1 || static_cast<size_t>(arr.shape(0)) != n_atoms) {
     throw std::invalid_argument("atom_types length must match n_atoms");
   }
   std::vector<int> types(n_atoms);
   for (size_t i = 0; i < n_atoms; ++i) {
-    types[i] = buf(i);
+    types[i] = static_cast<int>(arr.data()[i]);
   }
   return types;
 }
 
-std::array<std::array<double, 3>, 3>
-numpy_to_box(const py::array_t<double> &arr) {
-  auto buf = arr.unchecked<2>();
-  if (buf.shape(0) != 3 || buf.shape(1) != 3) {
+std::array<std::array<double, 3>, 3> numpy_to_box(const NpF64 &arr) {
+  if (arr.ndim() != 2 || arr.shape(0) != 3 || arr.shape(1) != 3) {
     throw std::invalid_argument("box must have shape (3, 3)");
   }
   std::array<std::array<double, 3>, 3> box{};
-  for (size_t i = 0; i < 3; ++i) {
-    for (size_t j = 0; j < 3; ++j) {
-      box[i][j] = buf(i, j);
-    }
-  }
+  const double *p = arr.data();
+  for (size_t i = 0; i < 3; ++i)
+    for (size_t j = 0; j < 3; ++j)
+      box[i][j] = p[i * 3 + j];
   return box;
 }
 
-py::array_t<double> atom_matrix_to_numpy(const AtomMatrix &mat) {
-  auto out = py::array_t<double>({mat.rows(), mat.cols()});
-  auto buf = out.mutable_unchecked<2>();
-  for (size_t i = 0; i < mat.rows(); ++i) {
-    for (size_t j = 0; j < mat.cols(); ++j) {
-      buf(i, j) = mat(i, j);
-    }
-  }
-  return out;
+nb::ndarray<nb::numpy, double, nb::c_contig>
+atom_matrix_to_numpy(const AtomMatrix &mat) {
+  const size_t rows = mat.rows();
+  const size_t cols = mat.cols();
+  double *buf = new double[rows * cols];
+  std::memcpy(buf, mat.data(), rows * cols * sizeof(double));
+  nb::capsule owner(buf, [](void *p) noexcept {
+    delete[] static_cast<double *>(p);
+  });
+  return nb::ndarray<nb::numpy, double, nb::c_contig>(buf, {rows, cols}, owner);
 }
 
 void flat_box(const std::array<std::array<double, 3>, 3> &box, double out[9]) {
@@ -82,9 +81,8 @@ void flat_box(const std::array<std::array<double, 3>, 3> &box, double out[9]) {
       out[i * 3 + j] = box[i][j];
 }
 
-py::tuple evaluate_lj(const py::array_t<double> &positions,
-                      const py::array_t<int> &atom_types,
-                      const py::array_t<double> &box) {
+nb::tuple evaluate_lj(const NpF64 &positions, const NpI32 &atom_types,
+                      const NpF64 &box) {
   if (positions.ndim() != 2 || atom_types.ndim() != 1 || box.ndim() != 2) {
     throw std::invalid_argument(
         "evaluate_lj expects positions (n,3), atom_types (n,), box (3,3)");
@@ -94,12 +92,11 @@ py::tuple evaluate_lj(const py::array_t<double> &positions,
   auto cell = numpy_to_box(box);
   rgpot::LJPot pot;
   auto [energy, forces, variance] = pot(pos, types, cell);
-  return py::make_tuple(energy, atom_matrix_to_numpy(forces), variance);
+  return nb::make_tuple(energy, atom_matrix_to_numpy(forces), variance);
 }
 
-py::tuple evaluate_metatomic_dlopen(const py::array_t<double> &positions,
-                                    const py::array_t<int> &atom_types,
-                                    const py::array_t<double> &box,
+nb::tuple evaluate_metatomic_dlopen(const NpF64 &positions,
+                                    const NpI32 &atom_types, const NpF64 &box,
                                     const std::string &model_path,
                                     const std::string &engine_path,
                                     const std::string &device) {
@@ -132,44 +129,41 @@ py::tuple evaluate_metatomic_dlopen(const py::array_t<double> &positions,
   rgpot::ForceInput in{n, pos.data(), types.data(), flat};
   rgpot::ForceOut out{forces.data(), 0.0, 0.0};
   front.forceImpl(in, &out);
-  return py::make_tuple(out.energy, atom_matrix_to_numpy(forces), out.variance);
+  return nb::make_tuple(out.energy, atom_matrix_to_numpy(forces), out.variance);
 }
 
 } // namespace
 
-PYBIND11_MODULE(_core, m) {
-  m.doc() = "rgpot Python bindings (LJ core + Metatomic dlopen frontend)";
-  m.attr("__version__") = "2.2.1";
+NB_MODULE(_core, m) {
+  m.doc() =
+      "rgpot Python bindings (nanobind): LJ core + Metatomic dlopen frontend. "
+      "Stable ABI (abi3) when built with Python >= 3.12.";
+  m.attr("__version__") = "2.3.0";
   m.attr("has_metatomic_dlopen") = true;
 
-  m.def("evaluate_lj", &evaluate_lj, py::arg("positions"),
-        py::arg("atom_types"), py::arg("box"));
-
-  m.def(
-      "evaluate_metatomic_dlopen", &evaluate_metatomic_dlopen,
-      py::arg("positions"), py::arg("atom_types"), py::arg("box"),
-      py::arg("model_path"), py::arg("engine_path") = "",
-      py::arg("device") = "cpu",
-      R"pbdoc(
-Evaluate forces via MetatomicDlopen (dlopen libmetatomic_engine.so).
+  m.def("evaluate_lj", &evaluate_lj, nb::arg("positions"),
+        nb::arg("atom_types"), nb::arg("box"));
 
-engine_path may be empty to use RGPOT_METATOMIC_ENGINE / package-bundled
-libmetatomic_engine.so on the library path.
-)pbdoc");
+  m.def("evaluate_metatomic_dlopen", &evaluate_metatomic_dlopen,
+        nb::arg("positions"), nb::arg("atom_types"), nb::arg("box"),
+        nb::arg("model_path"), nb::arg("engine_path") = "",
+        nb::arg("device") = "cpu",
+        "Evaluate forces via MetatomicDlopen (dlopen libmetatomic_engine.so). "
+        "engine_path may be empty to use RGPOT_METATOMIC_ENGINE / "
+        "package-bundled multi-ABI engine under rgpot/lib/torch-X.Y/.");
 
-  py::class_<rgpot::LJPot>(m, "LJPot")
-      .def(py::init<>())
+  nb::class_<rgpot::LJPot>(m, "LJPot")
+      .def(nb::init<>())
       .def(
           "__call__",
-          [](rgpot::LJPot &self, const py::array_t<double> &positions,
-             const py::array_t<int> &atom_types,
-             const py::array_t<double> &box) {
+          [](rgpot::LJPot &self, const NpF64 &positions,
+             const NpI32 &atom_types, const NpF64 &box) {
             auto pos = numpy_to_atom_matrix(positions);
             auto types = numpy_to_types(atom_types, pos.rows());
             auto cell = numpy_to_box(box);
             auto [energy, forces, variance] = self(pos, types, cell);
-            return py::make_tuple(energy, atom_matrix_to_numpy(forces),
+            return nb::make_tuple(energy, atom_matrix_to_numpy(forces),
                                   variance);
           },
-          py::arg("positions"), py::arg("atom_types"), py::arg("box"));
+          nb::arg("positions"), nb::arg("atom_types"), nb::arg("box"));
 }

rgpot-2.3.0/python/meson.build

@@ -0,0 +1,154 @@
+# Python package: rgpot — nanobind-only bindings (no pybind11).
+#
+# Policy (match pyeonclient):
+#   * Nanobind only for the public extension.
+#   * Stable ABI (abi3 / Py_LIMITED_API 3.12) on GIL builds with Python >= 3.12.
+#   * Free-threaded (NB_FREE_THREADED) when Py_GIL_DISABLED; no abi3 then.
+#
+# Layout:
+#   rgpot/__init__.py
+#   rgpot/_core*.so | _core*.abi3.so
+#   rgpot/lib/torch-X.Y/libmetatomic_engine.so  (multi-ABI engines, post-pack)
+
+py_mod = import('python')
+py = py_mod.find_installation(pure: false)
+py_dep = py.dependency()
+
+_nb_probe = run_command(
+  py,
+  '-c',
+  '''
+import nanobind, pathlib, sys, sysconfig
+p = pathlib.Path(nanobind.__file__).resolve().parent
+cands = [p / "src" / "nb_combined.cpp", p / "nb_combined.cpp"]
+comb = next(c for c in cands if c.is_file())
+robin = p / "ext" / "robin_map" / "include"
+if not (robin / "tsl" / "robin_map.h").is_file():
+    for alt in (p / "include", pathlib.Path(nanobind.include_dir())):
+        if (alt / "tsl" / "robin_map.h").is_file():
+            robin = alt
+            break
+ft = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+ver = sys.version_info
+print(nanobind.include_dir())
+print(robin)
+print(comb)
+print("1" if ft else "0")
+print(f"{ver.major}.{ver.minor}")
+print(nanobind.__version__)
+''',
+  check: false,
+)
+if _nb_probe.returncode() != 0
+  error(
+    'with_python requires nanobind>=2.2 in the build Python '
+    + '(pip/pixi install nanobind)',
+  )
+endif
+_nb_lines = _nb_probe.stdout().strip().split('\n')
+_nb_include = _nb_lines[0]
+_nb_robin = _nb_lines[1]
+_nb_combined = _nb_lines[2]
+_nb_free_threaded = _nb_lines[3] == '1'
+_nb_version = _nb_lines[5]
+
+message('rgpot python: nanobind @0@'.format(_nb_version))
+message('rgpot python: free-threaded interpreter = @0@'.format(_nb_free_threaded))
+
+# -isystem so abs paths under .pixi/site-packages are allowed
+nanobind_dep = declare_dependency(
+  compile_args: [
+    '-isystem' + _nb_include,
+    '-isystem' + _nb_robin,
+  ],
+)
+
+if not is_variable('rgpot')
+  error('with_python requires the full rgpot library (disable with_rpc_client_only)')
+endif
+if not is_variable('metatomic_dlopen')
+  error('with_python requires MetatomicDlopen (rgpot/MetatomicPot)')
+endif
+
+_py_incs = _incdirs
+_py_rpath = '$ORIGIN:$ORIGIN/../.rgpot.mesonpy.libs:$ORIGIN/lib'
+_py_link = [rgpot, lennard_jones, metatomic_dlopen]
+# Do not link cuh2 into the pip extension (fortcuh2 subproject not in wheel
+# when install --skip-subprojects; LJ + metatomic dlopen are the product).
+
+dl_dep = dependency('dl', required: false)
+if not dl_dep.found()
+  dl_dep = meson.get_compiler('cpp').find_library('dl', required: false)
+endif
+
+_nb_cpp_args = _args + [
+  '-DNB_DOMAIN=rgpot',
+  '-Wno-unused-parameter',
+]
+
+_core_sources = files('bind/bind_module.cpp') + [_nb_combined]
+
+if _nb_free_threaded
+  _nb_cpp_args += ['-DNB_FREE_THREADED']
+  message('rgpot python: FREE_THREADED build; stable ABI skipped')
+  py.extension_module(
+    '_core',
+    sources: _core_sources,
+    dependencies: [py_dep, nanobind_dep, dl_dep] + _deps,
+    include_directories: _py_incs,
+    link_with: _py_link,
+    cpp_args: _nb_cpp_args,
+    install: true,
+    install_rpath: _py_rpath,
+    build_rpath: _py_rpath,
+    subdir: 'rgpot',
+    gnu_symbol_visibility: 'hidden',
+  )
+else
+  _use_abi3 = py.language_version().version_compare('>=3.12')
+  if _use_abi3
+    message('rgpot python: STABLE_ABI build (abi3, Py_LIMITED_API=3.12)')
+    py.extension_module(
+      '_core',
+      sources: _core_sources,
+      dependencies: [py_dep, nanobind_dep, dl_dep] + _deps,
+      include_directories: _py_incs,
+      link_with: _py_link,
+      cpp_args: _nb_cpp_args,
+      install: true,
+      install_rpath: _py_rpath,
+      build_rpath: _py_rpath,
+      subdir: 'rgpot',
+      gnu_symbol_visibility: 'hidden',
+      limited_api: '3.12',
+    )
+  else
+    warning(
+      'rgpot python: Python < 3.12 — version-specific extension '
+      + '(stable ABI requires 3.12+)',
+    )
+    py.extension_module(
+      '_core',
+      sources: _core_sources,
+      dependencies: [py_dep, nanobind_dep, dl_dep] + _deps,
+      include_directories: _py_incs,
+      link_with: _py_link,
+      cpp_args: _nb_cpp_args,
+      install: true,
+      install_rpath: _py_rpath,
+      build_rpath: _py_rpath,
+      subdir: 'rgpot',
+      gnu_symbol_visibility: 'hidden',
+    )
+  endif
+endif
+
+py.install_sources(
+  files('rgpot/__init__.py'),
+  pure: false,
+  subdir: 'rgpot',
+)
+
+if is_variable('metatomic_engine')
+  message('metatomic_engine installs into the wheel; multi-ABI pack via scripts/rgpot_pack_multi_abi_engines.sh')
+endif

rgpot-2.3.0/python/rgpot/__init__.py

@@ -0,0 +1,107 @@
+"""rgpot — potential energy surfaces for atomistic simulation.
+
+Core: Lennard-Jones. Metatomic path uses **dlopen** of a portable
+``libmetatomic_engine.so`` (stable C ABI). Engines are multi-ABI:
+
+  ``rgpot/lib/torch-X.Y/libmetatomic_engine.so``
+
+selected from the installed ``torch`` major (same layout as metatomic-torch).
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from rgpot._core import (
+    LJPot,
+    __version__,
+    evaluate_lj,
+    evaluate_metatomic_dlopen,
+    has_metatomic_dlopen,
+)
+
+
+def _torch_major() -> str | None:
+    """Return installed torch X.Y, or None if torch is not importable."""
+    try:
+        import torch
+
+        v = torch.__version__.split("+", 1)[0]
+        parts = v.split(".")
+        return f"{parts[0]}.{parts[1]}"
+    except Exception:
+        return None
+
+
+def default_metatomic_engine_path() -> str | None:
+    """Return package-bundled engine matching installed torch ABI if possible."""
+    here = Path(__file__).resolve().parent
+    maj = _torch_major()
+    candidates: list[Path] = []
+    # Multi-ABI layout first (rgpot/lib/torch-X.Y/) — preferred product path
+    if maj:
+        candidates.append(here / "lib" / f"torch-{maj}" / "libmetatomic_engine.so")
+    lib_root = here / "lib"
+    if lib_root.is_dir():
+        for d in sorted(lib_root.glob("torch-*")):
+            candidates.append(d / "libmetatomic_engine.so")
+    # Legacy single-engine layouts (last resort)
+    candidates.extend(
+        [
+            here / "lib" / "libmetatomic_engine.so",
+            here.parent / ".rgpot.mesonpy.libs" / "libmetatomic_engine.so",
+            here / "libmetatomic_engine.so",
+        ]
+    )
+
+    for c in candidates:
+        if c.is_file():
+            return str(c)
+
+    env = os.environ.get("RGPOT_METATOMIC_ENGINE") or os.environ.get(
+        "METATOMIC_ENGINE"
+    )
+    if env and Path(env).is_file():
+        return env
+    return None
+
+
+def available_metatomic_engine_abis() -> list[str]:
+    """List torch-X.Y majors for which a bundled engine is present."""
+    here = Path(__file__).resolve().parent / "lib"
+    out: list[str] = []
+    if not here.is_dir():
+        return out
+    for d in sorted(here.glob("torch-*")):
+        if (d / "libmetatomic_engine.so").is_file():
+            out.append(d.name.removeprefix("torch-"))
+    return out
+
+
+def evaluate_metatomic(
+    positions,
+    atom_types,
+    box,
+    *,
+    model_path: str,
+    engine_path: str | None = None,
+    device: str = "cpu",
+):
+    """Force evaluation through MetatomicDlopen (real engine plugin)."""
+    eng = engine_path or default_metatomic_engine_path() or ""
+    return evaluate_metatomic_dlopen(
+        positions, atom_types, box, model_path, eng, device
+    )
+
+
+__all__ = [
+    "LJPot",
+    "evaluate_lj",
+    "evaluate_metatomic",
+    "evaluate_metatomic_dlopen",
+    "default_metatomic_engine_path",
+    "available_metatomic_engine_abis",
+    "has_metatomic_dlopen",
+    "__version__",
+]

{rgpot-2.2.1 → rgpot-2.3.0}/scripts/rgpot_build_wheel.sh

@@ -1,11 +1,10 @@
 #!/usr/bin/env bash
-# Build + repair rgpot wheel so install is portable ($ORIGIN purelib peers).
-# Usage: ./scripts/rgpot_build_wheel.sh
-# Requires torch/metatomic for engine link; sets CMAKE_PREFIX_PATH from torch.
+# Build + multi-ABI engine pack + RPATH repair for portable rgpot wheels.
+# Nanobind abi3 when build Python >= 3.12.
 set -euo pipefail
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 cd "$ROOT"
-python -m pip install -U build meson ninja meson-python pybind11 numpy wheel 2>/dev/null || true
+python -m pip install -U build meson ninja meson-python nanobind numpy wheel 2>/dev/null || true
 rm -rf dist build .mesonpy*
 if python -c "import torch, metatomic.torch" 2>/dev/null; then
   export CMAKE_PREFIX_PATH="$(python -c 'import torch; print(torch.utils.cmake_prefix_path)')${CMAKE_PREFIX_PATH:+:$CMAKE_PREFIX_PATH}"
@@ -16,4 +15,9 @@ else
 fi
 WHL=$(ls -1 dist/rgpot-*.whl | head -1)
 bash "$ROOT/scripts/rgpot_repair_wheel.sh" "$WHL"
+if [[ "${RGPOT_SKIP_MULTI_ABI:-0}" != "1" ]]; then
+  bash "$ROOT/scripts/rgpot_pack_multi_abi_engines.sh" "$WHL" || {
+    echo "WARN multi-ABI pack failed; wheel keeps primary engine only" >&2
+  }
+fi
 echo "WHEEL_OK $WHL"