mlc-z3-static 4.16.0__tar.gz

mlc_z3_static-4.16.0/CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required(VERSION 3.26)
+project(mlc_z3_static LANGUAGES NONE)
+
+find_package(Python3 REQUIRED COMPONENTS Interpreter)
+
+if(NOT "$ENV{MLC_Z3_STATIC_ALLOW_SOURCE_BUILD}" STREQUAL "1")
+  message(FATAL_ERROR
+    "mlc-z3-static source builds are disabled by default. Install a prebuilt "
+    "wheel, or set MLC_Z3_STATIC_ALLOW_SOURCE_BUILD=1 to build Z3 from source "
+    "explicitly.")
+endif()
+
+set(MLC_Z3_STATIC_STAGE_DIR "${CMAKE_BINARY_DIR}/staged/mlc_z3_static")
+set(MLC_Z3_STATIC_BUILD_ROOT "${CMAKE_BINARY_DIR}/z3-build")
+
+add_custom_target(stage_mlc_z3_static ALL
+  COMMAND
+    "${CMAKE_COMMAND}" -E env
+    "MLC_Z3_STATIC_PACKAGE_DIR=${MLC_Z3_STATIC_STAGE_DIR}"
+    "MLC_Z3_STATIC_BUILD_ROOT=${MLC_Z3_STATIC_BUILD_ROOT}"
+    "MLC_Z3_STATIC_CMAKE_GENERATOR=${CMAKE_GENERATOR}"
+    "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/scripts/prepare_z3_v4_16_0.py"
+  WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+  COMMENT "Building Z3 static and shared artifacts"
+  VERBATIM
+)
+
+install(DIRECTORY "${MLC_Z3_STATIC_STAGE_DIR}/static" DESTINATION mlc_z3_static)
+install(DIRECTORY "${MLC_Z3_STATIC_STAGE_DIR}/shared" DESTINATION mlc_z3_static)
+install(DIRECTORY "${MLC_Z3_STATIC_STAGE_DIR}/licenses" DESTINATION mlc_z3_static)
+install(FILES "${MLC_Z3_STATIC_STAGE_DIR}/staticlib.json" DESTINATION mlc_z3_static)

mlc_z3_static-4.16.0/LICENSE

@@ -0,0 +1,26 @@
+This package is distributed under the MIT License.
+
+The packaged Z3 artifacts are distributed under the upstream Z3 MIT License,
+which is included in the wheel as mlc_z3_static/licenses/LICENSE-Z3.txt.
+
+MIT License
+
+Copyright (c) MLC AI
+
+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.

mlc_z3_static-4.16.0/PKG-INFO

@@ -0,0 +1,156 @@
+Metadata-Version: 2.4
+Name: mlc-z3-static
+Version: 4.16.0
+Summary: Prebuilt Z3 4.16.0 static and shared libraries, headers, and CMake metadata
+Keywords: z3,smt,static-library,cmake
+Author-Email: MLC AI <mlc.ai.dev@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: C++
+Classifier: Topic :: Software Development :: Build Tools
+Project-URL: Repository, https://github.com/mlc-ai/package
+Project-URL: Z3, https://github.com/Z3Prover/z3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# mlc-z3-static
+
+`mlc-z3-static` is a Python package that carries native Z3 4.16.0 development
+artifacts for build systems. It does not provide Z3 Python bindings.
+
+The wheel contains:
+
+- Z3 C and C++ headers.
+- A position-independent static `libz3` (`libz3.a` on Unix-like platforms,
+  `.lib` on Windows).
+- A shared `libz3`.
+- Relocatable CMake and pkg-config metadata for each library flavor, under
+  `mlc_z3_static/<kind>/lib/cmake/z3` and `mlc_z3_static/<kind>/lib/pkgconfig`
+  for `kind` in `static` and `shared`.
+
+The package is built with scikit-build-core: building a wheel runs
+`scripts/prepare_z3_v4_16_0.py`, which downloads the pinned Z3 source archive,
+verifies its SHA-256 digest, and builds both library flavors. Source builds are
+opt-in (`MLC_Z3_STATIC_ALLOW_SOURCE_BUILD=1`) to avoid accidental long Z3
+builds when pip cannot find a matching prebuilt wheel.
+
+## Python Helpers
+
+Build systems can locate the packaged artifacts from Python:
+
+```python
+import mlc_z3_static
+
+print(mlc_z3_static.get_cmake_dir("static"))
+print(mlc_z3_static.get_cmake_prefix_path("shared"))
+print(mlc_z3_static.get_static_library_path())
+print(mlc_z3_static.get_shared_library_path())
+```
+
+Or from a build script through the configuration CLI:
+
+```bash
+python -m mlc_z3_static.config --cmake-dir
+python -m mlc_z3_static.config --prefix --kind shared
+```
+
+## Downstream CMake Usage
+
+Install the wheel into the Python environment used by the downstream build:
+
+```bash
+python -m pip install mlc-z3-static==4.16.0
+```
+
+Point CMake at the packaged static Z3 and use Z3's exported target:
+
+```bash
+cmake -S . -B build \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DZ3_DIR="$(python -m mlc_z3_static.config --cmake-dir)"
+```
+
+```cmake
+cmake_minimum_required(VERSION 3.20)
+project(my_z3_consumer LANGUAGES C CXX)
+
+find_package(Z3 CONFIG REQUIRED)
+
+add_executable(my_z3_consumer main.cpp)
+target_link_libraries(my_z3_consumer PRIVATE z3::libz3)
+target_compile_features(my_z3_consumer PRIVATE cxx_std_20)
+```
+
+Or resolve the directory from inside CMake:
+
+```cmake
+find_package(Python3 COMPONENTS Interpreter REQUIRED)
+execute_process(
+  COMMAND "${Python3_EXECUTABLE}" -m mlc_z3_static.config --cmake-dir
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  OUTPUT_VARIABLE Z3_DIR
+)
+find_package(Z3 CONFIG REQUIRED)
+```
+
+Z3 is implemented in C++, so even C-only consumers should enable CXX in the
+CMake project and let CMake link through a C++ linker when using the static
+archive. Use `--kind shared` (or `get_cmake_prefix_path("shared")`) to link the
+shared flavor instead; each flavor has its own relocatable CMake prefix. See
+`example_project/` for a complete uv-managed consumer.
+
+## Local Build
+
+Build a wheel directly:
+
+```bash
+MLC_Z3_STATIC_ALLOW_SOURCE_BUILD=1 python -m build --wheel
+```
+
+Use an existing Z3 checkout instead of downloading the pinned archive:
+
+```bash
+MLC_Z3_STATIC_ALLOW_SOURCE_BUILD=1 \
+MLC_Z3_STATIC_SOURCE_DIR=/path/to/z3 \
+python -m build --wheel
+```
+
+## Build Release Wheels
+
+From this directory:
+
+```bash
+scripts/wheel_manylinux_2_28_v4_16_0.sh
+```
+
+```bash
+scripts/wheel_macos_v4_16_0.sh
+```
+
+The scripts use `uv` for host-side Python tooling, so Debian/Ubuntu system
+Python restrictions such as PEP 668 and missing `ensurepip` do not affect the
+host CIBW runner or post-build verifier. Both run `cibuildwheel==3.3.1`, retag
+Linux wheels as `manylinux_2_28`, and verify each produced wheel from a clean
+temporary virtual environment with:
+
+```bash
+scripts/wheel_verify.sh wheelhouse/<wheel-file>.whl
+```
+
+The verifier installs the wheel, configures a small CMake project against
+`mlc_z3_static.get_cmake_prefix_path("static")`, links to `z3::libz3`, runs the
+executable, and checks that the executable does not link against a dynamic
+`libz3`.
+
+The manylinux script defaults to the host architecture. Set
+`MLC_Z3_STATIC_ARCH=x86_64` or `MLC_Z3_STATIC_ARCH=aarch64` to choose explicitly.
+
+On macOS, local CIBW builds require an official python.org CPython installation.
+The script defaults to the newest installed python.org CPython only as the build
+interpreter. The output wheel is still Python-agnostic and tagged
+`py3-none-<platform>`. Override `CIBW_BUILD` to force a specific installed build
+interpreter, for example `CIBW_BUILD=cp313-macosx_arm64`.

mlc_z3_static-4.16.0/README.md

@@ -0,0 +1,137 @@
+# mlc-z3-static
+
+`mlc-z3-static` is a Python package that carries native Z3 4.16.0 development
+artifacts for build systems. It does not provide Z3 Python bindings.
+
+The wheel contains:
+
+- Z3 C and C++ headers.
+- A position-independent static `libz3` (`libz3.a` on Unix-like platforms,
+  `.lib` on Windows).
+- A shared `libz3`.
+- Relocatable CMake and pkg-config metadata for each library flavor, under
+  `mlc_z3_static/<kind>/lib/cmake/z3` and `mlc_z3_static/<kind>/lib/pkgconfig`
+  for `kind` in `static` and `shared`.
+
+The package is built with scikit-build-core: building a wheel runs
+`scripts/prepare_z3_v4_16_0.py`, which downloads the pinned Z3 source archive,
+verifies its SHA-256 digest, and builds both library flavors. Source builds are
+opt-in (`MLC_Z3_STATIC_ALLOW_SOURCE_BUILD=1`) to avoid accidental long Z3
+builds when pip cannot find a matching prebuilt wheel.
+
+## Python Helpers
+
+Build systems can locate the packaged artifacts from Python:
+
+```python
+import mlc_z3_static
+
+print(mlc_z3_static.get_cmake_dir("static"))
+print(mlc_z3_static.get_cmake_prefix_path("shared"))
+print(mlc_z3_static.get_static_library_path())
+print(mlc_z3_static.get_shared_library_path())
+```
+
+Or from a build script through the configuration CLI:
+
+```bash
+python -m mlc_z3_static.config --cmake-dir
+python -m mlc_z3_static.config --prefix --kind shared
+```
+
+## Downstream CMake Usage
+
+Install the wheel into the Python environment used by the downstream build:
+
+```bash
+python -m pip install mlc-z3-static==4.16.0
+```
+
+Point CMake at the packaged static Z3 and use Z3's exported target:
+
+```bash
+cmake -S . -B build \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DZ3_DIR="$(python -m mlc_z3_static.config --cmake-dir)"
+```
+
+```cmake
+cmake_minimum_required(VERSION 3.20)
+project(my_z3_consumer LANGUAGES C CXX)
+
+find_package(Z3 CONFIG REQUIRED)
+
+add_executable(my_z3_consumer main.cpp)
+target_link_libraries(my_z3_consumer PRIVATE z3::libz3)
+target_compile_features(my_z3_consumer PRIVATE cxx_std_20)
+```
+
+Or resolve the directory from inside CMake:
+
+```cmake
+find_package(Python3 COMPONENTS Interpreter REQUIRED)
+execute_process(
+  COMMAND "${Python3_EXECUTABLE}" -m mlc_z3_static.config --cmake-dir
+  OUTPUT_STRIP_TRAILING_WHITESPACE
+  OUTPUT_VARIABLE Z3_DIR
+)
+find_package(Z3 CONFIG REQUIRED)
+```
+
+Z3 is implemented in C++, so even C-only consumers should enable CXX in the
+CMake project and let CMake link through a C++ linker when using the static
+archive. Use `--kind shared` (or `get_cmake_prefix_path("shared")`) to link the
+shared flavor instead; each flavor has its own relocatable CMake prefix. See
+`example_project/` for a complete uv-managed consumer.
+
+## Local Build
+
+Build a wheel directly:
+
+```bash
+MLC_Z3_STATIC_ALLOW_SOURCE_BUILD=1 python -m build --wheel
+```
+
+Use an existing Z3 checkout instead of downloading the pinned archive:
+
+```bash
+MLC_Z3_STATIC_ALLOW_SOURCE_BUILD=1 \
+MLC_Z3_STATIC_SOURCE_DIR=/path/to/z3 \
+python -m build --wheel
+```
+
+## Build Release Wheels
+
+From this directory:
+
+```bash
+scripts/wheel_manylinux_2_28_v4_16_0.sh
+```
+
+```bash
+scripts/wheel_macos_v4_16_0.sh
+```
+
+The scripts use `uv` for host-side Python tooling, so Debian/Ubuntu system
+Python restrictions such as PEP 668 and missing `ensurepip` do not affect the
+host CIBW runner or post-build verifier. Both run `cibuildwheel==3.3.1`, retag
+Linux wheels as `manylinux_2_28`, and verify each produced wheel from a clean
+temporary virtual environment with:
+
+```bash
+scripts/wheel_verify.sh wheelhouse/<wheel-file>.whl
+```
+
+The verifier installs the wheel, configures a small CMake project against
+`mlc_z3_static.get_cmake_prefix_path("static")`, links to `z3::libz3`, runs the
+executable, and checks that the executable does not link against a dynamic
+`libz3`.
+
+The manylinux script defaults to the host architecture. Set
+`MLC_Z3_STATIC_ARCH=x86_64` or `MLC_Z3_STATIC_ARCH=aarch64` to choose explicitly.
+
+On macOS, local CIBW builds require an official python.org CPython installation.
+The script defaults to the newest installed python.org CPython only as the build
+interpreter. The output wheel is still Python-agnostic and tagged
+`py3-none-<platform>`. Override `CIBW_BUILD` to force a specific installed build
+interpreter, for example `CIBW_BUILD=cp313-macosx_arm64`.

mlc_z3_static-4.16.0/example_project/CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.20)
+project(mlc_z3_static_uv_example LANGUAGES C CXX)
+
+find_package(Z3 CONFIG REQUIRED)
+
+if(DEFINED MLC_Z3_STATIC_EXPECTED_PREFIX)
+  get_target_property(Z3_IMPORTED_LOCATION z3::libz3 IMPORTED_LOCATION_RELEASE)
+  if(NOT Z3_IMPORTED_LOCATION)
+    get_target_property(Z3_IMPORTED_LOCATION z3::libz3 IMPORTED_LOCATION)
+  endif()
+  if(NOT Z3_IMPORTED_LOCATION)
+    message(FATAL_ERROR "z3::libz3 does not expose an imported library location")
+  endif()
+
+  file(REAL_PATH "${Z3_IMPORTED_LOCATION}" Z3_IMPORTED_LOCATION_REAL)
+  file(REAL_PATH "${MLC_Z3_STATIC_EXPECTED_PREFIX}" MLC_Z3_STATIC_EXPECTED_PREFIX_REAL)
+  string(FIND "${Z3_IMPORTED_LOCATION_REAL}" "${MLC_Z3_STATIC_EXPECTED_PREFIX_REAL}/" Z3_PREFIX_POSITION)
+  if(NOT Z3_PREFIX_POSITION EQUAL 0)
+    message(
+      FATAL_ERROR
+      "z3::libz3 resolves outside the installed mlc-z3-static wheel prefix.\n"
+      "  imported: ${Z3_IMPORTED_LOCATION_REAL}\n"
+      "  expected prefix: ${MLC_Z3_STATIC_EXPECTED_PREFIX_REAL}"
+    )
+  endif()
+endif()
+
+add_executable(mlc_z3_static_uv_example cpp/main.cpp)
+target_link_libraries(mlc_z3_static_uv_example PRIVATE z3::libz3)
+target_compile_features(mlc_z3_static_uv_example PRIVATE cxx_std_20)

mlc_z3_static-4.16.0/example_project/README.md

@@ -0,0 +1,30 @@
+# mlc-z3-static uv consumer example
+
+This is a minimal downstream project that consumes `mlc-z3-static==4.16.0`
+with `uv`, then links a tiny C++ program against the static Z3 CMake target
+shipped in the wheel.
+
+## Install
+
+From this directory:
+
+```bash
+uv sync
+uv run python -m mlc_z3_static_example
+```
+
+## Build The CMake Consumer
+
+```bash
+scripts/link_static.sh
+```
+
+The script resolves the installed Z3 static CMake prefix through the
+configuration CLI:
+
+```bash
+uv run python -m mlc_z3_static.config --prefix
+```
+
+Then it configures CMake with that prefix so `find_package(Z3 CONFIG REQUIRED)`
+finds the wheel-provided package instead of a system Z3.

mlc_z3_static-4.16.0/example_project/cpp/main.cpp

@@ -0,0 +1,20 @@
+#include <z3++.h>
+
+int main() {
+  z3::context cxx_ctx;
+  z3::expr x = cxx_ctx.bool_const("x");
+  z3::solver cxx_solver(cxx_ctx);
+  cxx_solver.add(x);
+  if (cxx_solver.check() != z3::sat) {
+    return 1;
+  }
+
+  Z3_config cfg = Z3_mk_config();
+  Z3_context ctx = Z3_mk_context(cfg);
+  Z3_solver solver = Z3_mk_solver(ctx);
+  Z3_solver_inc_ref(ctx, solver);
+  Z3_solver_dec_ref(ctx, solver);
+  Z3_del_context(ctx);
+  Z3_del_config(cfg);
+  return 0;
+}

mlc_z3_static-4.16.0/example_project/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mlc-z3-static-example-project"
+version = "0.1.0"
+requires-python = ">=3.11"
+dependencies = [
+  "mlc-z3-static==4.16.0",
+]
+
+[project.optional-dependencies]
+build = [
+  "cmake>=3.26",
+  "ninja>=1.11",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

mlc_z3_static-4.16.0/example_project/scripts/link_static.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+project_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "${project_dir}"
+
+: "${UV:=uv}"
+if ! command -v "${UV}" >/dev/null 2>&1; then
+  echo "uv executable not found: ${UV}" >&2
+  exit 1
+fi
+
+"${UV}" sync --extra build
+
+mlc_z3_static_prefix="$("${UV}" run python -m mlc_z3_static.config --prefix)"
+
+"${UV}" run --extra build cmake -S . -B build \
+  -G Ninja \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_PREFIX_PATH="${mlc_z3_static_prefix}" \
+  -DMLC_Z3_STATIC_EXPECTED_PREFIX="${mlc_z3_static_prefix}"
+"${UV}" run --extra build cmake --build build --config Release
+
+exe="build/mlc_z3_static_uv_example"
+if [[ -x "${exe}" ]]; then
+  "${exe}"
+else
+  "${exe}.exe"
+fi

mlc_z3_static-4.16.0/example_project/src/mlc_z3_static_example/__init__.py

@@ -0,0 +1 @@
+"""Example project that consumes the mlc-z3-static wheel."""

mlc_z3_static-4.16.0/example_project/src/mlc_z3_static_example/__main__.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import mlc_z3_static
+
+
+def main() -> None:
+    print(f"Z3 tag: {mlc_z3_static.Z3_TAG}")
+    print(f"Z3 commit: {mlc_z3_static.Z3_COMMIT}")
+    print(f"Static CMake prefix: {mlc_z3_static.get_cmake_prefix_path('static')}")
+    print(f"Static library: {mlc_z3_static.get_static_library_path()}")
+
+
+if __name__ == "__main__":
+    main()

mlc_z3_static-4.16.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["scikit-build-core>=0.11", "cmake>=3.26", "ninja"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "mlc-z3-static"
+dynamic = ["version"]
+description = "Prebuilt Z3 4.16.0 static and shared libraries, headers, and CMake metadata"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "MLC AI", email = "mlc.ai.dev@gmail.com" }]
+keywords = ["z3", "smt", "static-library", "cmake"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: C++",
+  "Topic :: Software Development :: Build Tools",
+]
+
+[project.urls]
+Repository = "https://github.com/mlc-ai/package"
+Z3 = "https://github.com/Z3Prover/z3"
+
+[tool.scikit-build]
+cmake.version = ">=3.26"
+wheel.py-api = "py3"
+wheel.packages = ["src/mlc_z3_static"]
+sdist.exclude = [
+  "build",
+  "dist",
+  "wheelhouse",
+  "example_project/build",
+  "example_project/.venv",
+  "src/mlc_z3_static/static",
+  "src/mlc_z3_static/shared",
+  "src/mlc_z3_static/licenses",
+  "src/mlc_z3_static/staticlib.json",
+]
+
+[tool.scikit-build.metadata.version]
+provider = "scikit_build_core.metadata.regex"
+input = "src/mlc_z3_static/_version.py"
+
+[tool.cibuildwheel]
+# CIBW_BUILD selects the Python used to run the build. scikit-build-core tags
+# the output wheel py3-none because this package exposes native development
+# artifacts, not a CPython ABI extension.
+build = "cp311-*"
+build-frontend = "build"
+build-verbosity = 1
+skip = "*-musllinux_* pp*"
+test-requires = ["cmake", "ninja"]
+test-command = "python {project}/scripts/smoke_test_mlc_z3_static.py"
+
+[tool.cibuildwheel.environment]
+MLC_Z3_STATIC_ALLOW_SOURCE_BUILD = "1"
+
+[tool.cibuildwheel.linux]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+repair-wheel-command = "python scripts/copy_wheel.py {wheel} {dest_dir}"
+
+[tool.cibuildwheel.macos]
+repair-wheel-command = "python scripts/copy_wheel.py {wheel} {dest_dir}"

mlc_z3_static-4.16.0/scripts/cibuildwheel_run.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "$#" -lt 1 || "$#" -gt 3 ]]; then
+  echo "usage: cibuildwheel_run.sh <platform> [output-dir] [package-dir]" >&2
+  exit 1
+fi
+
+platform="$1"
+output_dir="${2:-wheelhouse}"
+package_dir="${3:-.}"
+
+: "${UV:=uv}"
+if ! command -v "${UV}" >/dev/null 2>&1; then
+  echo "uv executable not found: ${UV}" >&2
+  exit 1
+fi
+
+"${UV}" tool run --isolated --from "cibuildwheel==3.3.1" \
+  cibuildwheel --platform "${platform}" --output-dir "${output_dir}" "${package_dir}"

mlc_z3_static-4.16.0/scripts/copy_wheel.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import shutil
+import sys
+from pathlib import Path
+
+
+def main() -> None:
+    if len(sys.argv) != 3:
+        raise SystemExit("usage: copy_wheel.py <wheel> <dest-dir>")
+    wheel = Path(sys.argv[1]).resolve()
+    dest_dir = Path(sys.argv[2]).resolve()
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(wheel, dest_dir / wheel.name)
+
+
+if __name__ == "__main__":
+    main()