Compress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Python agentaianthropicclaude-codecompressioncontext-engineeringcontext-windowcursorfastapilangchainllmmcpopenaiprompt-engineeringproxypythonragtoken-optimizationtokenstypescript
fix(build): enable Intel macOS pip installs via ort-load-dynamic (#1538)
Rob Francis32ce99e4b4a7
diff --git a/.github/workflows/release.yml b/.github/workflows/release.ymlindex adda68d3c..2ac4de954 100644--- a/.github/workflows/release.yml+++ b/.github/workflows/release.yml@@ -247,15 +247,14 @@ jobs:- os: ubuntu-24.04-armtarget: aarch64-unknown-linux-gnumanylinux: 2_28- # NOTE: `macos-15-intel` (x86_64-apple-darwin) is intentionally- # NOT in the matrix. `ort-sys 2.0.0-rc.12` (transitive via our- # ML compression backend) does not provide prebuilt ONNX Runtime- # binaries for `x86_64-apple-darwin`, and building ORT from- # source would add CMake + ~5 minutes per build. Apple Silicon- # macOS is fully covered below; Intel-mac users install the- # platform-independent sdist (also produced by this matrix).- # Tracked as a follow-up: switch to `ort-tract` or upstream a- # request for x86_64 macOS prebuilts.+ # Intel macOS x86_64. `ort-sys 2.0.0-rc.12` does not ship+ # prebuilt ONNX Runtime binaries for this triple, so+ # `headroom-core/Cargo.toml` selects `ort-load-dynamic` (same+ # as Windows) and `headroom/_ort.py` pins `ORT_DYLIB_PATH` to+ # the pip `onnxruntime` dylib at import time.+ - os: macos-15-intel+ target: x86_64-apple-darwin+ manylinux: ""- os: macos-14target: aarch64-apple-darwinmanylinux: ""@@ -267,8 +266,9 @@ jobs:# or crates.io). `manylinux` is meaningless on Windows (that tag# is Linux-only) — leave it empty. The ONNX Runtime story is# already handled: `crates/headroom-core/Cargo.toml` selects- # `ort-load-dynamic` under `cfg(windows)`, so the wheel does not- # bundle/link DirectML SDK libs and loads ORT at runtime instead.+ # `ort-load-dynamic` under `cfg(windows)` and Intel macOS, so+ # the wheel does not bundle/link platform ORT SDK libs and loads+ # ORT at runtime instead.- os: windows-latesttarget: x86_64-pc-windows-msvcmanylinux: ""@@ -507,11 +507,11 @@ jobs:# runners (PR #376) host the container.- { runner: ubuntu-24.04-arm, image: "quay.io/pypa/manylinux_2_28_aarch64", python: "3.11", wheel_target: aarch64-unknown-linux-gnu, wheel_artifact: wheels-ubuntu-24.04-arm-aarch64-unknown-linux-gnu, glibc_label: "2.28-floor" }- { runner: ubuntu-24.04-arm, image: "ubuntu:22.04", python: "3.12", wheel_target: aarch64-unknown-linux-gnu, wheel_artifact: wheels-ubuntu-24.04-arm-aarch64-unknown-linux-gnu, glibc_label: "2.35" }- # macOS arm64 — runs natively on the host runner; no- # container. Apple Silicon is the only macOS target we- # ship today (Intel macOS dropped in PR #371 — ort-sys- # has no x86_64-apple-darwin prebuilts).+ # macOS arm64 — runs natively on the host runner; no container.- { runner: macos-14, image: "", python: "3.13", wheel_target: aarch64-apple-darwin, wheel_artifact: wheels-macos-14-aarch64-apple-darwin, glibc_label: "" }+ # macOS x86_64 (Intel) — `ort-load-dynamic`; see build-wheels+ # matrix comment for rationale.+ - { runner: macos-15-intel, image: "", python: "3.12", wheel_target: x86_64-apple-darwin, wheel_artifact: wheels-macos-15-intel-x86_64-apple-darwin, glibc_label: "" }# Windows x86_64 — runs natively on the host runner; no# container. `image: ""` routes this row past the Linux docker# path; a dedicated PowerShell step below installs + imports the@@ -680,16 +680,21 @@ jobs:if: matrix.image == '' && runner.os == 'macOS'env:PYTHON_VERSION: ${{ matrix.python }}+ WHEEL_TARGET: ${{ matrix.wheel_target }}run: |set -epy_tag=cp$(echo "$PYTHON_VERSION" | tr -d .)- # macOS wheels are tagged macosx_*_arm64 (Apple Silicon only).- whl=$(find dist -maxdepth 1 -type f -name "headroom_ai-*-${py_tag}-${py_tag}-macosx_*_arm64.whl" -print -quit)+ case "$WHEEL_TARGET" in+ aarch64-apple-darwin) mac_arch=arm64 ;;+ x86_64-apple-darwin) mac_arch=x86_64 ;;+ *) echo "ERROR: unknown macOS wheel target $WHEEL_TARGET" >&2; exit 1 ;;+ esac+ whl=$(find dist -maxdepth 1 -type f -name "headroom_ai-*-${py_tag}-${py_tag}-macosx_*_${mac_arch}.whl" -print -quit)if [ -z "$whl" ]; then# Stable-ABI (abi3) fallback — see the Linux path above. A# cp3<floor>-abi3 wheel installs on any CPython >= floor.py_minor=${PYTHON_VERSION#*.}- abi3=$(find dist -maxdepth 1 -type f -name "headroom_ai-*-abi3-macosx_*_arm64.whl" -print -quit)+ abi3=$(find dist -maxdepth 1 -type f -name "headroom_ai-*-abi3-macosx_*_${mac_arch}.whl" -print -quit)if [ -n "$abi3" ]; thenabi3_base=${abi3##*/}abi3_floor=${abi3_base#*-cp3}@@ -699,7 +704,7 @@ jobs:fifiif [ -z "$whl" ]; then- echo "ERROR: no macOS wheel matching python=$PYTHON_VERSION"+ echo "ERROR: no macOS wheel matching python=$PYTHON_VERSION arch=$mac_arch target=$WHEEL_TARGET"find dist -maxdepth 1 -type f -exec basename {} \;exit 1fidiff --git a/.github/workflows/rust.yml b/.github/workflows/rust.ymlindex 2c2857133..32cb1c146 100644--- a/.github/workflows/rust.yml+++ b/.github/workflows/rust.yml@@ -75,14 +75,11 @@ jobs:- os: macos-14target: aarch64-apple-darwinmaturin-target: aarch64-apple-darwin- # macOS x86_64 (Intel) is NOT in this matrix.- # `fastembed` → `ort` → `ort-sys` does not publish prebuilt ONNX- # Runtime binaries for `x86_64-apple-darwin`; building from source- # in CI is a multi-hour cmake job. Apple Silicon has been the- # default macOS target since 2020 and is sufficient for the wheels- # we ship. If a customer needs Intel macOS, build from source- # locally (the toolchain works; only prebuilt distribution skips- # this target).+ - os: macos-15-intel+ target: x86_64-apple-darwin+ maturin-target: x86_64-apple-darwin+ # Intel macOS uses `ort-load-dynamic` (no prebuilt ORT from ort-sys);+ # Apple Silicon bundles ORT via `ort-download-binaries-rustls-tls`.steps:- uses: actions/checkout@v6- uses: actions/setup-python@v6diff --git a/README.md b/README.mdindex 34de0b3dd..f46bd7a12 100644--- a/README.md+++ b/README.md@@ -380,8 +380,8 @@ winget install Rustlang.Rustup && rustup default stableRestart your shell, then `pip install "headroom-ai[all]"`. A prebuilt wheel avoids the Rustbuild entirely where available: `pip install --only-binary headroom-ai headroom-ai`. Prebuiltwheels are published for Windows (`win_amd64`), Linux (`x86_64` / `aarch64`), and macOS-(Apple Silicon), so installs on those platforms never need a local Rust toolchain — the-Rust-first dance above is only for the platform-independent sdist fallback (e.g. Intel macOS).+(Apple Silicon and Intel), so installs on those platforms never need a local Rust toolchain — the+Rust-first dance above is only for the platform-independent sdist fallback when no wheel matches.Two runtime assets are fetched over TLS; if they are blocked, trust your corporate CA via`REQUESTS_CA_BUNDLE` / `SSL_CERT_FILE` / `CURL_CA_BUNDLE`:diff --git a/crates/headroom-core/Cargo.toml b/crates/headroom-core/Cargo.tomlindex a5705ba8a..360346e89 100644--- a/crates/headroom-core/Cargo.toml+++ b/crates/headroom-core/Cargo.toml@@ -122,13 +122,25 @@ redis = { version = "0.27", optional = true, default-features = false }# cycling through the proxy crate. Tiny crate (no I/O, just types).http = "1"-[target.'cfg(not(windows))'.dependencies]+[target.'cfg(all(not(windows), not(all(target_os = "macos", target_arch = "x86_64"))))'.dependencies]fastembed = { version = "5", default-features = false, features = ["hf-hub-rustls-tls","ort-download-binaries-rustls-tls","image-models",] }+[target.'cfg(all(target_os = "macos", target_arch = "x86_64"))'.dependencies]+# `ort-sys 2.0.0-rc.12` does not ship prebuilt ONNX Runtime binaries for+# `x86_64-apple-darwin`. Building ORT from source in CI would add CMake and+# several minutes per wheel. Load the pip `onnxruntime` dylib at runtime+# instead (same approach as Windows below). `headroom/_ort.py` pins+# `ORT_DYLIB_PATH` before `headroom._core` imports.+fastembed = { version = "5", default-features = false, features = [+ "hf-hub-rustls-tls",+ "ort-load-dynamic",+ "image-models",+] }+[target.'cfg(windows)'.dependencies]# `ort-download-binaries-*` emits DirectML link libs on Windows (`DXCORE`,# `DXGI`, `D3D12`, `DirectML`). Users installing `headroom-ai[all]` fromdiff --git a/headroom/_ort.py b/headroom/_ort.pyindex 00a55d83c..09b6d84fd 100644--- a/headroom/_ort.py+++ b/headroom/_ort.py@@ -1,31 +1,37 @@-"""Pin the ONNX Runtime dylib for the Rust core on Windows.+"""Pin the ONNX Runtime dylib for the Rust core on dynamic-ORT platforms.Why this module exists-----------------------On Windows, ``headroom._core`` consumers of the ``ort`` crate (magika-content detection, fastembed embeddings) are built with-``ort-load-dynamic``: the native ``onnxruntime.dll`` is resolved at-*runtime*. Unless ``ORT_DYLIB_PATH`` is set, ort falls back to a bare-``LoadLibrary("onnxruntime.dll")`` and the Windows DLL search order-applies — and ``C:\\Windows\\System32`` wins.+On Windows and Intel macOS (``x86_64-apple-darwin``), ``headroom._core``+consumers of the ``ort`` crate (magika content detection, fastembed+embeddings) are built with ``ort-load-dynamic``: the native ONNX Runtime+library is resolved at *runtime*.-Windows 11 24H2+ ships ``System32\\onnxruntime.dll`` as part of Windows-ML (observed: 1.17.2603 "os-germanium"). Initializing an ort 2.x-session against that OS build does not fail — it deadlocks-indefinitely at 0% CPU, which the tiered detection fallback cannot-catch (a hang is not an ``Err``). Reproduced and bracketed with-``scripts/diag_magika_windows.py``: the identical session inits in-~400ms when ``ORT_DYLIB_PATH`` points at the ``onnxruntime`` pip-package's DLL (which ``headroom-ai[proxy]`` already depends on).+Windows: unless ``ORT_DYLIB_PATH`` is set, ort falls back to a bare+``LoadLibrary("onnxruntime.dll")`` and the Windows DLL search order+applies — and ``C:\\Windows\\System32`` wins. Windows 11 24H2+ ships+``System32\\onnxruntime.dll`` as part of Windows ML (observed:+1.17.2603 "os-germanium"). Initializing an ort 2.x session against that+OS build does not fail — it deadlocks indefinitely at 0% CPU, which the+tiered detection fallback cannot catch (a hang is not an ``Err``).+Reproduced and bracketed with ``scripts/diag_magika_windows.py``: the+identical session inits in ~400ms when ``ORT_DYLIB_PATH`` points at the+``onnxruntime`` pip package's DLL (which ``headroom-ai[proxy]`` already+depends on).++Intel macOS: ``ort-sys 2.0.0-rc.12`` does not ship prebuilt ONNX Runtime+binaries for ``x86_64-apple-darwin``, so the wheel/sdist build uses+``ort-load-dynamic`` and expects a pip-installed ``onnxruntime`` dylib+at runtime (same contract as Windows).The fix: before anything can import ``headroom._core``, resolve the-pip-installed ``onnxruntime\\capi\\onnxruntime.dll`` and export it via+pip-installed ``onnxruntime`` native library and export it via``ORT_DYLIB_PATH``. ``headroom/__init__.py`` calls this hook, whichguarantees ordering for every package-level consumer.Behavior contract------------------- Windows-only; a no-op everywhere else.+- Active on Windows and Intel macOS only; a no-op elsewhere.- Respects a pre-set ``ORT_DYLIB_PATH`` (user override wins).- Locates the ``onnxruntime`` package via ``find_spec`` WITHOUTimporting it (importing would load its native code; this hook must@@ -41,6 +47,7 @@ from __future__ import annotationsimport importlib.utilimport loggingimport os+import platformimport sysfrom pathlib import Path@@ -54,11 +61,12 @@ _pinned: object = _UNSETdef ensure_ort_dylib_pinned() -> str | None:- """Export ``ORT_DYLIB_PATH`` for the Rust core's ort runtime (Windows).+ """Export ``ORT_DYLIB_PATH`` for the Rust core's ort runtime.Returns the effective dylib path (pinned now or already present in- the environment), or ``None`` when no pin applies (non-Windows, or- no ``onnxruntime`` package to point at). Idempotent and exception-free.+ the environment), or ``None`` when no pin applies (platforms that+ bundle ORT at build time, or no ``onnxruntime`` package to point at).+ Idempotent and exception-free."""global _pinnedif _pinned is not _UNSET:@@ -67,8 +75,23 @@ def ensure_ort_dylib_pinned() -> str | None:return _pinned # type: ignore[return-value]+def _needs_ort_dylib_pin() -> bool:+ if sys.platform.startswith("win"):+ return True+ return sys.platform == "darwin" and platform.machine() == "x86_64"+++def _resolve_ort_native_library(capi_dir: Path) -> Path | None:+ if sys.platform.startswith("win"):+ candidate = capi_dir / "onnxruntime.dll"+ return candidate if candidate.is_file() else None++ matches = sorted(capi_dir.glob("libonnxruntime*.dylib"))+ return matches[0] if matches else None++def _resolve_and_pin() -> str | None:- if not sys.platform.startswith("win"):+ if not _needs_ort_dylib_pin():return Nonetry:@@ -80,26 +103,26 @@ def _resolve_and_pin() -> str | None:spec = importlib.util.find_spec("onnxruntime")if spec is None or not spec.origin:logger.debug(- "onnxruntime package not found; %s left unset. The Rust ML detection "- "may pick up the Windows ML System32 onnxruntime.dll, which is known "- "to deadlock ort init on Windows 11 24H2+ (it then degrades to non-ML "- "tiers via HEADROOM_MAGIKA_INIT_TIMEOUT_SECS). Install onnxruntime or "- "set %s explicitly.",+ "onnxruntime package not found; %s left unset. Rust ML detection "+ "needs a pip-installed onnxruntime on this platform (install "+ "headroom-ai[proxy] or set %s explicitly).",_ENV_VAR,_ENV_VAR,)return None- dll = Path(spec.origin).parent / "capi" / "onnxruntime.dll"- if not dll.is_file():+ native = _resolve_ort_native_library(Path(spec.origin).parent / "capi")+ if native is None:logger.debug(- "onnxruntime package found but %s is missing; %s left unset", dll, _ENV_VAR+ "onnxruntime package found but no native library under %s; %s left unset",+ Path(spec.origin).parent / "capi",+ _ENV_VAR,)return None- os.environ[_ENV_VAR] = str(dll)- logger.info("Pinned %s to bundled ONNX Runtime: %s", _ENV_VAR, dll)- return str(dll)+ os.environ[_ENV_VAR] = str(native)+ logger.info("Pinned %s to bundled ONNX Runtime: %s", _ENV_VAR, native)+ return str(native)except Exception as exc: # never break `import headroom` over an accelerator pinlogger.debug("ort dylib pin skipped: %s: %s", type(exc).__name__, exc)return Nonediff --git a/tests/test_release_workflows.py b/tests/test_release_workflows.pyindex b27acbc7e..07a53077d 100644--- a/tests/test_release_workflows.py+++ b/tests/test_release_workflows.py@@ -200,24 +200,25 @@ def test_fastembed_uses_rustls_features() -> None:def test_fastembed_uses_dynamic_ort_on_windows() -> None:- """Windows sdist builds must not link Pyke's DirectML ORT binaries.+ """Windows and Intel macOS sdist builds must not link Pyke's ORT binaries.- `ort-download-binaries-*` emits DXCORE/DXGI/D3D12/DirectML link libs on- Windows. Those SDK libs are not present on many Python build hosts, so the- Windows target must use ORT dynamic loading instead.+ `ort-download-binaries-*` emits platform SDK link libs (DirectML on+ Windows; unavailable prebuilts on `x86_64-apple-darwin`). Those targets+ must use ORT dynamic loading instead."""cargo = (ROOT / "crates" / "headroom-core" / "Cargo.toml").read_text(encoding="utf-8")- assert "[target.'cfg(windows)'.dependencies]" in cargo- windows_section = cargo.split("[target.'cfg(windows)'.dependencies]", 1)[1].split(- "\n[",- 1,- )[0]- windows_dependency_lines = "\n".join(- line for line in windows_section.splitlines() if not line.lstrip().startswith("#")- )- assert '"ort-load-dynamic"' in windows_section- assert "ort-download-binaries" not in windows_dependency_lines+ for section_marker in (+ "[target.'cfg(windows)'.dependencies]",+ '[target.\'cfg(all(target_os = "macos", target_arch = "x86_64"))\'.dependencies]',+ ):+ assert section_marker in cargo, f"missing Cargo target section: {section_marker}"+ section = cargo.split(section_marker, 1)[1].split("\n[", 1)[0]+ dependency_lines = "\n".join(+ line for line in section.splitlines() if not line.lstrip().startswith("#")+ )+ assert '"ort-load-dynamic"' in section+ assert "ort-download-binaries" not in dependency_linesdef test_dockerfiles_no_longer_install_openssl_devel() -> None:@@ -289,16 +290,13 @@ def test_release_yml_does_not_install_openssl_or_perl_for_wheels() -> None:)-def test_build_wheels_matrix_excludes_intel_macos() -> None:- """`ort-sys 2.0.0-rc.12` (transitive via the ML compression backend)+def test_build_wheels_matrix_includes_intel_macos_with_dynamic_ort() -> None:+ """Intel macOS wheels use `ort-load-dynamic` because `ort-sys 2.0.0-rc.12`has no prebuilt ONNX Runtime binaries for `x86_64-apple-darwin`.- Building ORT from source would add CMake + ~5 minutes per build.- Apple Silicon macOS is fully covered; Intel-mac users install from- the platform-independent sdist this matrix also produces.We assert against the actual matrix entry shape (`target: <triple>`- on a non-comment line) so explanatory comments mentioning the- excluded triple don't false-positive.+ on a non-comment line) so explanatory comments mentioning other+ triples don't false-positive."""content = (ROOT / ".github" / "workflows" / "release.yml").read_text(encoding="utf-8")@@ -319,14 +317,10 @@ def test_build_wheels_matrix_excludes_intel_macos() -> None:assert "aarch64-apple-darwin" in matrix_targets, "Apple Silicon must stay in the matrix"assert "x86_64-unknown-linux-gnu" in matrix_targetsassert "aarch64-unknown-linux-gnu" in matrix_targets-- # Intel macOS must NOT be a matrix entry — re-add only after switching- # off ort-sys (e.g., to ort-tract) or adding a CMake-from-source step.- assert "x86_64-apple-darwin" not in matrix_targets, (- f"x86_64-apple-darwin must not be a wheel-matrix target; got {matrix_targets}"+ assert "x86_64-apple-darwin" in matrix_targets, (+ f"x86_64-apple-darwin must be a wheel-matrix target; got {matrix_targets}")- # The runner OS itself shouldn't appear as a configured `os:` either.matrix_os: list[str] = []for raw in body.splitlines():stripped = raw.lstrip()@@ -334,7 +328,27 @@ def test_build_wheels_matrix_excludes_intel_macos() -> None:continueif stripped.startswith("os:"):matrix_os.append(stripped.split(":", 1)[1].strip())- assert "macos-15-intel" not in matrix_os+ elif stripped.startswith("- os:"):+ matrix_os.append(stripped.split(":", 1)[1].strip())+ assert "macos-15-intel" in matrix_os+++def test_smoke_import_macos_selects_wheel_arch_from_target() -> None:+ """The macOS smoke-import step must pick the wheel tag from the matrix+ target (arm64 for Apple Silicon, x86_64 for Intel) instead of+ hardcoding `_arm64` for every macOS row."""+ content = (ROOT / ".github" / "workflows" / "release.yml").read_text(encoding="utf-8")++ step_start = content.index("- name: Smoke-import wheel on macOS host")+ step_end = content.index("- name: Smoke-import wheel on Windows host", step_start)+ macos_block = content[step_start:step_end]++ assert "WHEEL_TARGET: ${{ matrix.wheel_target }}" in macos_block+ assert "aarch64-apple-darwin) mac_arch=arm64" in macos_block+ assert "x86_64-apple-darwin) mac_arch=x86_64" in macos_block+ assert "macosx_*_${mac_arch}.whl" in macos_block+ assert "headroom_ai-*-${py_tag}-${py_tag}-macosx_*_arm64.whl" not in macos_block+ assert "headroom_ai-*-abi3-macosx_*_arm64.whl" not in macos_blockdef test_aarch64_wheel_uses_native_arm64_runner() -> None:diff --git a/tests/test_transforms/test_ort_dylib.py b/tests/test_transforms/test_ort_dylib.pyindex 8930a07ab..74101565e 100644--- a/tests/test_transforms/test_ort_dylib.py+++ b/tests/test_transforms/test_ort_dylib.py@@ -1,9 +1,9 @@-"""Tests for headroom._ort — the Windows ORT_DYLIB_PATH auto-pin.+"""Tests for headroom._ort — the ORT_DYLIB_PATH auto-pin.-The resolver guards the Rust core against the Windows DLL search picking-up the Windows ML System32 onnxruntime.dll (deadlocks ort session init on-Win11 24H2+, see headroom/_ort.py). The platform gate is monkeypatched so-the full logic runs on any CI OS.+The resolver guards the Rust core on platforms that use `ort-load-dynamic`+(Windows and Intel macOS). On Windows it avoids the System32 onnxruntime.dll+deadlock (Win11 24H2+, see headroom/_ort.py). Platform gates are+monkeypatched so the full logic runs on any CI OS."""from __future__ import annotations@@ -27,6 +27,11 @@ def _force_windows(monkeypatch):monkeypatch.setattr(sys, "platform", "win32")+def _force_intel_macos(monkeypatch):+ monkeypatch.setattr(sys, "platform", "darwin")+ monkeypatch.setattr(_ort.platform, "machine", lambda: "x86_64")++def _fake_spec_for(monkeypatch, package_dir):"""Make find_spec('onnxruntime') resolve to a fake package directory."""spec = SimpleNamespace(origin=str(package_dir / "__init__.py"))@@ -37,11 +42,16 @@ def _fake_spec_for(monkeypatch, package_dir):)-def test_noop_on_non_windows(monkeypatch):+def test_noop_on_non_dynamic_platforms(monkeypatch):monkeypatch.setattr(sys, "platform", "linux")assert _ort.ensure_ort_dylib_pinned() is Noneassert "ORT_DYLIB_PATH" not in _ort.os.environ+ monkeypatch.setattr(sys, "platform", "darwin")+ monkeypatch.setattr(_ort.platform, "machine", lambda: "arm64")+ assert _ort.ensure_ort_dylib_pinned() is None+ assert "ORT_DYLIB_PATH" not in _ort.os.environ+def test_respects_existing_env(monkeypatch):_force_windows(monkeypatch)@@ -63,6 +73,19 @@ def test_pins_to_package_capi_dll(monkeypatch, tmp_path):assert _ort.os.environ["ORT_DYLIB_PATH"] == str(dll)+def test_pins_to_package_capi_dylib_on_intel_macos(monkeypatch, tmp_path):+ _force_intel_macos(monkeypatch)+ pkg = tmp_path / "onnxruntime"+ capi = pkg / "capi"+ capi.mkdir(parents=True)+ dylib = capi / "libonnxruntime.1.23.2.dylib"+ dylib.write_bytes(b"not really a dylib")+ _fake_spec_for(monkeypatch, pkg)++ assert _ort.ensure_ort_dylib_pinned() == str(dylib)+ assert _ort.os.environ["ORT_DYLIB_PATH"] == str(dylib)++def test_idempotent_after_first_resolution(monkeypatch, tmp_path):_force_windows(monkeypatch)pkg = tmp_path / "onnxruntime"