hatch-ziglang 0.1.0__tar.gz

hatch_ziglang-0.1.0/.github/workflows/main.yml

@@ -0,0 +1,59 @@
+name: CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+permissions: {}
+
+jobs:
+  tests:
+    name: "Python ${{ matrix.python-version }}"
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          python-version: "${{ matrix.python-version }}"
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync --group dev
+
+      - name: Lint
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
+
+      - name: Type check
+        run: uv run mypy src
+
+      - name: Run tests
+        run: uv run coverage run -m pytest
+
+      - name: Enforce coverage
+        run: uv run coverage report
+
+  # https://github.com/marketplace/actions/alls-green#why
+  check:
+    name: All green
+    if: always()
+    needs: [tests]
+    runs-on: ubuntu-latest
+    permissions: {}
+    steps:
+      - name: Decide whether the needed jobs succeeded or failed
+        uses: re-actors/alls-green@afee1c1eac2a506084c274e9c02c8e0687b48d9e # v1.2.2
+        with:
+          jobs: "${{ toJSON(needs) }}"

hatch_ziglang-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,60 @@
+name: Publish
+
+on:
+  push:
+    tags: ["*"]
+  workflow_dispatch:
+
+permissions: {}
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
+          fetch-depth: 0 # uv-dynamic-versioning derives the version from commit distance
+
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          python-version: "3.12"
+          enable-cache: false
+
+      - name: Build distributions
+        run: uv build
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: dist
+          path: dist/*
+
+  publish:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: [build]
+    if: startsWith(github.ref, 'refs/tags/')
+
+    permissions:
+      id-token: write # trusted publishing (OIDC), no API token
+
+    environment:
+      name: pypi
+      url: https://pypi.org/project/hatch-ziglang
+
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: dist
+          path: dist
+
+      - uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          enable-cache: false
+
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing always

hatch_ziglang-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+.coverage
+.coverage.*
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/

hatch_ziglang-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Marcelo Trylesinski
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

hatch_ziglang-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: hatch-ziglang
+Version: 0.1.0
+Summary: A Hatch build hook that compiles a Zig extension into the wheel.
+Author-email: Marcelo Trylesinski <marcelotryle@gmail.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Hatch
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Zig
+Requires-Python: >=3.10
+Requires-Dist: hatchling
+Description-Content-Type: text/markdown
+
+# hatch-ziglang
+
+A [Hatch](https://hatch.pypa.io/) build hook that compiles a [Zig](https://ziglang.org/) extension
+into the wheel, against the building interpreter, with no out-of-band step.
+
+`uv build` / `pip wheel` / cibuildwheel produce a correct, platform-tagged wheel: the `.so` is built
+during the wheel build against `sys.executable`, and your `build.zig` installs it into the package as
+`_<package><EXT_SUFFIX>`.
+
+## Usage
+
+Add the build requirement and configure the hook in `pyproject.toml`:
+
+```toml
+[build-system]
+requires = ["hatchling", "hatch-ziglang", "ziglang==0.16.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel.hooks.zig]
+package = "yourpkg"
+optimize = "ReleaseFast"  # optional; Zig -Doptimize mode (default ReleaseFast)
+```
+
+| key        | required | description                                                                |
+| ---------- | -------- | -------------------------------------------------------------------------- |
+| `package`  | yes      | the import package directory; artifact is `<package>/_<package><EXT_SUFFIX>` |
+| `optimize` | no       | Zig `-Doptimize` mode (default `ReleaseFast`)                               |
+
+`HATCH_ZIG_BUILD_MODE` overrides `optimize` at build time.
+
+## What `build.zig` receives
+
+The hook runs `zig build -Doptimize=<mode> [-Dtarget=...]` and passes the interpreter paths through
+two environment variables your `build.zig` reads:
+
+- `HATCH_ZIG_PYTHON_INCLUDE` - the building interpreter's `platinclude`
+- `HATCH_ZIG_EXT_SUFFIX` - the building interpreter's `EXT_SUFFIX` (e.g. `.cpython-312-darwin.so`)
+
+On macOS under cibuildwheel, the hook reads `ARCHFLAGS` and `MACOSX_DEPLOYMENT_TARGET` to emit a
+matching `-Dtarget=<arch>-macos[.<min>]`, so the compiled `.so` and the wheel tag agree and delocate
+accepts the repaired wheel.
+
+Zig is resolved from a `zig` on `PATH`, falling back to the `ziglang` pip package (`python -m ziglang`),
+which works inside cibuildwheel's manylinux containers.

hatch_ziglang-0.1.0/README.md

@@ -0,0 +1,44 @@
+# hatch-ziglang
+
+A [Hatch](https://hatch.pypa.io/) build hook that compiles a [Zig](https://ziglang.org/) extension
+into the wheel, against the building interpreter, with no out-of-band step.
+
+`uv build` / `pip wheel` / cibuildwheel produce a correct, platform-tagged wheel: the `.so` is built
+during the wheel build against `sys.executable`, and your `build.zig` installs it into the package as
+`_<package><EXT_SUFFIX>`.
+
+## Usage
+
+Add the build requirement and configure the hook in `pyproject.toml`:
+
+```toml
+[build-system]
+requires = ["hatchling", "hatch-ziglang", "ziglang==0.16.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel.hooks.zig]
+package = "yourpkg"
+optimize = "ReleaseFast"  # optional; Zig -Doptimize mode (default ReleaseFast)
+```
+
+| key        | required | description                                                                |
+| ---------- | -------- | -------------------------------------------------------------------------- |
+| `package`  | yes      | the import package directory; artifact is `<package>/_<package><EXT_SUFFIX>` |
+| `optimize` | no       | Zig `-Doptimize` mode (default `ReleaseFast`)                               |
+
+`HATCH_ZIG_BUILD_MODE` overrides `optimize` at build time.
+
+## What `build.zig` receives
+
+The hook runs `zig build -Doptimize=<mode> [-Dtarget=...]` and passes the interpreter paths through
+two environment variables your `build.zig` reads:
+
+- `HATCH_ZIG_PYTHON_INCLUDE` - the building interpreter's `platinclude`
+- `HATCH_ZIG_EXT_SUFFIX` - the building interpreter's `EXT_SUFFIX` (e.g. `.cpython-312-darwin.so`)
+
+On macOS under cibuildwheel, the hook reads `ARCHFLAGS` and `MACOSX_DEPLOYMENT_TARGET` to emit a
+matching `-Dtarget=<arch>-macos[.<min>]`, so the compiled `.so` and the wheel tag agree and delocate
+accepts the repaired wheel.
+
+Zig is resolved from a `zig` on `PATH`, falling back to the `ziglang` pip package (`python -m ziglang`),
+which works inside cibuildwheel's manylinux containers.

hatch_ziglang-0.1.0/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning>=0.8.0"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hatch-ziglang"
+description = "A Hatch build hook that compiles a Zig extension into the wheel."
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Marcelo Trylesinski", email = "marcelotryle@gmail.com" }]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: Hatch",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Zig",
+]
+dependencies = ["hatchling"]
+dynamic = ["version"]
+
+[project.entry-points.hatch]
+zig = "hatch_ziglang.hooks"
+
+[dependency-groups]
+dev = ["pytest>=8.0", "coverage>=7.0", "ruff", "mypy"]
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv-dynamic-versioning]
+vcs = "git"
+style = "pep440"
+bump = true
+metadata = false
+fallback-version = "0.0.0"
+
+[tool.pytest.ini_options]
+addopts = "-rxXs --strict-config --strict-markers"
+xfail_strict = true
+testpaths = ["tests"]
+filterwarnings = ["error"]
+
+[tool.coverage.run]
+source_pkgs = ["hatch_ziglang", "tests"]
+branch = true
+parallel = true
+
+[tool.coverage.report]
+precision = 2
+fail_under = 100
+show_missing = true
+skip_covered = true
+exclude_lines = [
+    "pragma: no cover",
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+    "@overload",
+]
+
+[tool.ruff]
+line-length = 120
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "FA", "UP", "RUF100"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+
+[tool.mypy]
+strict = true
+warn_unused_ignores = true
+show_error_codes = true
+files = ["src"]

hatch_ziglang-0.1.0/src/hatch_ziglang/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from hatch_ziglang.plugin import ZigBuildHook
+
+__all__ = ["ZigBuildHook"]

hatch_ziglang-0.1.0/src/hatch_ziglang/hooks.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from hatchling.plugin import hookimpl
+
+from hatch_ziglang.plugin import ZigBuildHook
+
+
+@hookimpl
+def hatch_register_build_hook() -> type[ZigBuildHook]:
+    return ZigBuildHook

hatch_ziglang-0.1.0/src/hatch_ziglang/plugin.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import sysconfig
+from pathlib import Path
+from typing import Any
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+# cibuildwheel builds every macOS wheel on the arm64 runner and asks for a
+# specific arch through ARCHFLAGS; translate it into a Zig cross-compile target
+# so the produced `.so` matches the wheel tag delocate enforces.
+_MACOS_ZIG_ARCH = {"arm64": "aarch64-macos", "x86_64": "x86_64-macos"}
+
+
+def _zig_target_args() -> list[str]:
+    archflags = os.environ.get("ARCHFLAGS", "")
+    arches = archflags.split()[1::2]  # "-arch x86_64 -arch arm64" -> ["x86_64", "arm64"]
+    if len(arches) != 1 or sys.platform != "darwin":
+        return []
+    arch = _MACOS_ZIG_ARCH.get(arches[0])
+    if not arch:
+        return []
+    # Pin the binary's minimum macOS to MACOSX_DEPLOYMENT_TARGET (set by
+    # cibuildwheel) so the wheel tag and the `.so`'s required OS version agree
+    # and delocate accepts the repaired wheel.
+    min_version = os.environ.get("MACOSX_DEPLOYMENT_TARGET")
+    target = f"{arch}.{min_version}" if min_version else arch
+    return [f"-Dtarget={target}"]
+
+
+def _zig_command() -> list[str]:
+    """Resolve how to invoke Zig: a `zig` on PATH, else the `ziglang` pip package.
+
+    The pip fallback (`python -m ziglang`) works identically on the host and inside
+    cibuildwheel's manylinux containers, where a host-installed `zig` isn't visible.
+    """
+    if shutil.which("zig"):
+        return ["zig"]
+    try:
+        import ziglang  # type: ignore[import-not-found]  # noqa: F401
+    except ImportError:
+        raise RuntimeError(
+            "Zig toolchain not found: install Zig and put it on PATH, or `pip install ziglang`."
+        ) from None
+    return [sys.executable, "-m", "ziglang"]
+
+
+class ZigBuildHook(BuildHookInterface[Any]):
+    """Compile a Zig extension against the building interpreter during the wheel build.
+
+    This makes `uv build` / `pip wheel` / cibuildwheel produce a correct, platform-tagged
+    wheel with no out-of-band step: the `.so` is built here, against `sys.executable`, and
+    `build.zig` installs it into `<package>/` as `_<package><EXT_SUFFIX>`.
+
+    Configured in `[tool.hatch.build.targets.wheel.hooks.zig]`:
+
+        package   the import package directory; the artifact is `<package>/_<package><EXT_SUFFIX>`
+        optimize  Zig `-Doptimize` mode (default ReleaseFast); overridable via HATCH_ZIG_BUILD_MODE
+
+    `build.zig` receives the interpreter paths through `HATCH_ZIG_PYTHON_INCLUDE` and
+    `HATCH_ZIG_EXT_SUFFIX`.
+    """
+
+    PLUGIN_NAME = "zig"
+
+    @property
+    def _package(self) -> str:
+        package = self.config.get("package")
+        if not package:
+            raise ValueError("hatch-zig requires `package` in [tool.hatch.build.targets.wheel.hooks.zig]")
+        return str(package)
+
+    @property
+    def _optimize(self) -> str:
+        return os.environ.get("HATCH_ZIG_BUILD_MODE", str(self.config.get("optimize", "ReleaseFast")))
+
+    def initialize(self, version: str, build_data: dict[str, Any]) -> None:
+        if self.target_name != "wheel":
+            return
+
+        root = Path(self.root)
+        include = sysconfig.get_path("platinclude")
+        ext_suffix = sysconfig.get_config_var("EXT_SUFFIX")
+        if not include or not ext_suffix:
+            raise RuntimeError("could not resolve platinclude / EXT_SUFFIX from the building interpreter")
+
+        env = {**os.environ, "HATCH_ZIG_PYTHON_INCLUDE": include, "HATCH_ZIG_EXT_SUFFIX": ext_suffix}
+        subprocess.run(
+            [*_zig_command(), "build", f"-Doptimize={self._optimize}", *_zig_target_args()],
+            cwd=root,
+            env=env,
+            check=True,
+        )
+
+        artifact = f"{self._package}/_{self._package}{ext_suffix}"
+        if not (root / artifact).exists():
+            raise RuntimeError(f"zig build did not produce {artifact}")
+
+        # Tag the wheel for this interpreter + platform rather than py3-none-any.
+        build_data["pure_python"] = False
+        build_data["infer_tag"] = True
+        build_data["artifacts"].append(artifact)
+
+    def clean(self, versions: list[str]) -> None:
+        root = Path(self.root)
+        for suffix in ("so", "pyd"):
+            for path in root.glob(f"{self._package}/_{self._package}*.{suffix}"):
+                path.unlink()
+        print(f"removed compiled extensions; building Zig core via {sys.executable}", file=sys.stderr)

hatch_ziglang-0.1.0/tests/test_plugin.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import sysconfig
+from pathlib import Path
+from typing import Any
+from unittest import mock
+
+import pytest
+
+from hatch_ziglang.hooks import hatch_register_build_hook
+from hatch_ziglang.plugin import ZigBuildHook, _zig_command, _zig_target_args
+
+
+def make_hook(root: Path, config: dict[str, Any], target_name: str = "wheel") -> ZigBuildHook:
+    return ZigBuildHook(
+        str(root),
+        config,
+        None,
+        None,
+        str(root),
+        target_name,
+    )
+
+
+def test_entry_point_registers_hook() -> None:
+    assert hatch_register_build_hook() is ZigBuildHook
+    assert ZigBuildHook.PLUGIN_NAME == "zig"
+
+
+def test_package_required(tmp_path: Path) -> None:
+    hook = make_hook(tmp_path, {})
+    with pytest.raises(ValueError, match="requires `package`"):
+        _ = hook._package
+
+
+def test_optimize_default_and_override(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    hook = make_hook(tmp_path, {"package": "foo"})
+    monkeypatch.delenv("HATCH_ZIG_BUILD_MODE", raising=False)
+    assert hook._optimize == "ReleaseFast"
+
+    hook = make_hook(tmp_path, {"package": "foo", "optimize": "ReleaseSafe"})
+    assert hook._optimize == "ReleaseSafe"
+
+    monkeypatch.setenv("HATCH_ZIG_BUILD_MODE", "Debug")
+    assert hook._optimize == "Debug"
+
+
+def test_initialize_skips_non_wheel(tmp_path: Path) -> None:
+    hook = make_hook(tmp_path, {"package": "foo"}, target_name="sdist")
+    build_data: dict[str, Any] = {"artifacts": []}
+    with mock.patch("hatch_ziglang.plugin.subprocess.run") as run:
+        hook.initialize("1.0", build_data)
+    run.assert_not_called()
+    assert build_data == {"artifacts": []}
+
+
+def test_initialize_builds_and_tags(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    ext_suffix = sysconfig.get_config_var("EXT_SUFFIX")
+    (tmp_path / "foo").mkdir()
+    artifact = tmp_path / "foo" / f"_foo{ext_suffix}"
+    monkeypatch.delenv("ARCHFLAGS", raising=False)
+
+    hook = make_hook(tmp_path, {"package": "foo"})
+    build_data: dict[str, Any] = {"artifacts": []}
+
+    def fake_run(cmd: list[str], **kwargs: Any) -> None:
+        artifact.write_bytes(b"")
+        assert "-Doptimize=ReleaseFast" in cmd
+        assert kwargs["env"]["HATCH_ZIG_PYTHON_INCLUDE"]
+        assert kwargs["env"]["HATCH_ZIG_EXT_SUFFIX"] == ext_suffix
+
+    with mock.patch("hatch_ziglang.plugin._zig_command", return_value=["zig"]):
+        with mock.patch("hatch_ziglang.plugin.subprocess.run", side_effect=fake_run):
+            hook.initialize("1.0", build_data)
+
+    assert build_data["pure_python"] is False
+    assert build_data["infer_tag"] is True
+    assert f"foo/_foo{ext_suffix}" in build_data["artifacts"]
+
+
+def test_initialize_missing_artifact(tmp_path: Path) -> None:
+    hook = make_hook(tmp_path, {"package": "foo"})
+    with mock.patch("hatch_ziglang.plugin._zig_command", return_value=["zig"]):
+        with mock.patch("hatch_ziglang.plugin.subprocess.run"):
+            with pytest.raises(RuntimeError, match="did not produce"):
+                hook.initialize("1.0", {"artifacts": []})
+
+
+def test_initialize_missing_interpreter_paths(tmp_path: Path) -> None:
+    hook = make_hook(tmp_path, {"package": "foo"})
+    with mock.patch("hatch_ziglang.plugin.sysconfig.get_path", return_value=None):
+        with pytest.raises(RuntimeError, match="platinclude"):
+            hook.initialize("1.0", {"artifacts": []})
+
+
+def test_clean_removes_extensions(tmp_path: Path) -> None:
+    (tmp_path / "foo").mkdir()
+    so = tmp_path / "foo" / "_foo.cpython-312-darwin.so"
+    pyd = tmp_path / "foo" / "_foo.cp312-win_amd64.pyd"
+    so.write_bytes(b"")
+    pyd.write_bytes(b"")
+
+    hook = make_hook(tmp_path, {"package": "foo"})
+    hook.clean(["1.0"])
+
+    assert not so.exists()
+    assert not pyd.exists()
+
+
+def test_zig_command_prefers_path() -> None:
+    with mock.patch("hatch_ziglang.plugin.shutil.which", return_value="/usr/bin/zig"):
+        assert _zig_command() == ["zig"]
+
+
+def test_zig_command_falls_back_to_ziglang() -> None:
+    with mock.patch("hatch_ziglang.plugin.shutil.which", return_value=None):
+        with mock.patch.dict("sys.modules", {"ziglang": mock.Mock()}):
+            assert _zig_command()[1:] == ["-m", "ziglang"]
+
+
+def test_zig_command_missing_toolchain() -> None:
+    with mock.patch("hatch_ziglang.plugin.shutil.which", return_value=None):
+        with mock.patch.dict("sys.modules", {"ziglang": None}):
+            with pytest.raises(RuntimeError, match="Zig toolchain not found"):
+                _zig_command()
+
+
+def test_zig_target_args_non_macos(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("ARCHFLAGS", "-arch arm64")
+    monkeypatch.setattr("hatch_ziglang.plugin.sys.platform", "linux")
+    assert _zig_target_args() == []
+
+
+def test_zig_target_args_no_single_arch(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("hatch_ziglang.plugin.sys.platform", "darwin")
+    monkeypatch.setenv("ARCHFLAGS", "-arch arm64 -arch x86_64")
+    assert _zig_target_args() == []
+
+
+def test_zig_target_args_unknown_arch(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("hatch_ziglang.plugin.sys.platform", "darwin")
+    monkeypatch.setenv("ARCHFLAGS", "-arch ppc64")
+    assert _zig_target_args() == []
+
+
+def test_zig_target_args_with_min_version(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("hatch_ziglang.plugin.sys.platform", "darwin")
+    monkeypatch.setenv("ARCHFLAGS", "-arch x86_64")
+    monkeypatch.setenv("MACOSX_DEPLOYMENT_TARGET", "11.0")
+    assert _zig_target_args() == ["-Dtarget=x86_64-macos.11.0"]
+
+
+def test_zig_target_args_without_min_version(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr("hatch_ziglang.plugin.sys.platform", "darwin")
+    monkeypatch.setenv("ARCHFLAGS", "-arch arm64")
+    monkeypatch.delenv("MACOSX_DEPLOYMENT_TARGET", raising=False)
+    assert _zig_target_args() == ["-Dtarget=aarch64-macos"]