pyneurale 0.1.1__tar.gz

pyneurale-0.1.1/.clang-format

@@ -0,0 +1,30 @@
+BasedOnStyle: LLVM
+
+Language: Cpp
+Standard: c++20
+
+IndentWidth: 4
+TabWidth: 4
+UseTab: Never
+ColumnLimit: 100
+
+BreakBeforeBraces: Allman
+NamespaceIndentation: None
+
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+
+DerivePointerAlignment: false
+PointerAlignment: Left
+ReferenceAlignment: Pointer
+
+SortIncludes:
+  Enabled: true
+  IgnoreCase: false
+IncludeBlocks: Preserve
+
+FixNamespaceComments: true
+ReflowComments: IndentOnly

pyneurale-0.1.1/.gitattributes

@@ -0,0 +1,5 @@
+* text=auto eol=lf
+
+# Keep CRLF for Windows scripts
+*.bat      text eol=crlf
+*.cmd      text eol=crlf

pyneurale-0.1.1/.github/workflows/benchmarks.yml

@@ -0,0 +1,215 @@
+name: Controlled physical-chain performance characterization
+
+on:
+  workflow_dispatch:
+    inputs:
+      collect_controlled_history:
+        description: Run the administered self-hosted benchmark-history job
+        required: false
+        default: false
+        type: boolean
+  schedule:
+    - cron: "17 3 * * 0"
+
+permissions:
+  contents: read
+
+concurrency:
+  group: physical-chain-benchmarks-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  physical-chain:
+    name: Physical chain (${{ matrix.provider }})
+    runs-on: ubuntu-24.04
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - provider: builtin
+            enable_mkl: "OFF"
+            build_fft_backend: none
+          - provider: mkl
+            enable_mkl: "ON"
+            build_fft_backend: mkl
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Install native build tooling
+        run: python -m pip install --upgrade pip pybind11
+      - name: Add Intel oneAPI APT repository
+        if: matrix.provider == 'mkl'
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes gpg-agent wget
+          wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
+          echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list
+          sudo apt-get update
+      - name: Install oneMKL
+        if: matrix.provider == 'mkl'
+        run: sudo apt-get install --yes intel-oneapi-mkl-devel
+      - name: Record resolved oneMKL packages
+        if: matrix.provider == 'mkl'
+        run: dpkg-query -W 'intel-oneapi-mkl*'
+      - name: Resolve oneMKL package version
+        id: mkl-version
+        if: matrix.provider == 'mkl'
+        run: echo "version=$(dpkg-query -W -f='${Version}' intel-oneapi-mkl-devel)" >> "$GITHUB_OUTPUT"
+      - name: Configure Release benchmark
+        run: >-
+          cmake -S . -B build/performance
+          -DCMAKE_BUILD_TYPE=Release
+          -DCMAKE_RUNTIME_OUTPUT_DIRECTORY="${GITHUB_WORKSPACE}/build/performance/bin"
+          -DNEURALE_BUILD_CPP_TESTS=OFF
+          -DNEURALE_BUILD_BENCHMARKS=ON
+          -DNEURALE_ENABLE_MKL=${{ matrix.enable_mkl }}
+          -DNEURALE_ENABLE_CUDA=OFF
+          -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+      - name: Build physical-chain benchmark
+        run: >-
+          cmake --build build/performance --config Release
+          --target neurale_pipeline_strict_realtime_benchmark
+      - name: Run physical-chain performance characterization
+        run: |
+          mkdir -p "build/benchmark-results/${{ matrix.provider }}"
+          build/performance/bin/neurale_pipeline_strict_realtime_benchmark \
+            --warmup-seconds 1 --duration-seconds 60 --runs 3 \
+            > "build/benchmark-results/${{ matrix.provider }}/results.jsonl"
+      - name: Capture exact characterization environment
+        run: >-
+          python tools/benchmark_policy.py capture
+          --results "build/benchmark-results/${{ matrix.provider }}/results.jsonl"
+          --output "build/benchmark-results/${{ matrix.provider }}/environment.json"
+          --runner-class github-hosted-characterization
+          --runner-label github-hosted --runner-label linux --runner-label x64
+          --runner-name "${RUNNER_NAME}"
+          --runner-image "${ImageOS:-unknown}-${ImageVersion:-unknown}"
+          --evidence-run-id "${{ github.run_id }}-${{ github.run_attempt }}-${{ matrix.provider }}"
+          --git-sha "${{ github.sha }}"
+          --exact-command "neurale_pipeline_strict_realtime_benchmark --warmup-seconds 1 --duration-seconds 60 --runs 3"
+          --provider "${{ matrix.provider }}"
+          --software-component "cmake=$(cmake --version | head -n 1)"
+          --software-component "pybind11=$(python -c 'import pybind11; print(pybind11.__version__)')"
+          --software-component "mkl=${{ steps.mkl-version.outputs.version || 'disabled' }}"
+      - name: Validate machine-readable result structure
+        env:
+          EXPECTED_BUILD_FFT_BACKEND: ${{ matrix.build_fft_backend }}
+          RESULT_PATH: build/benchmark-results/${{ matrix.provider }}/results.jsonl
+        run: |
+          python - <<'PY'
+          import json
+          import os
+          from pathlib import Path
+
+          path = Path(os.environ["RESULT_PATH"])
+          rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
+          assert len(rows) == 42, f"expected 42 records, found {len(rows)}"
+          cases = {(row["feature"], row["bandpass"], row["resampler"]) for row in rows}
+          assert len(cases) == 14, f"expected 14 scenarios, found {len(cases)}"
+          assert {row["run"] for row in rows} == {0, 1, 2}
+          expected_build_backend = os.environ["EXPECTED_BUILD_FFT_BACKEND"]
+          for row in rows:
+              assert row["runs"] == 3
+              assert row["duration_seconds"] == 60
+              assert row["warmup_seconds"] == 1
+              assert row["build_fft_backend"] == expected_build_backend
+              assert row["feature_fft_backend"]
+              assert row["min"] <= row["median"] <= row["p95"] <= row["p99"] <= row["max"]
+              assert row["frames_per_second"] > 0
+              assert row["scalar_samples_per_second"] > 0
+              assert row["realtime_factor"] > 0
+              assert row["compiler"] and row["cpu_model"] and row["build_type"] == "Release"
+          PY
+      - name: Upload JSON Lines results
+        uses: actions/upload-artifact@v4
+        with:
+          name: physical-native-chains-${{ matrix.provider }}-${{ github.run_id }}-${{ github.run_attempt }}
+          path: build/benchmark-results/${{ matrix.provider }}/
+          if-no-files-found: error
+          retention-days: 30
+
+  controlled-history:
+    name: Controlled history (${{ matrix.provider }})
+    if: github.event_name == 'workflow_dispatch' && inputs.collect_controlled_history
+    runs-on: [self-hosted, linux, x64, pyneurale-benchmark]
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - provider: builtin
+            enable_mkl: "OFF"
+          - provider: mkl
+            enable_mkl: "ON"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Install native build tooling
+        run: python -m pip install --upgrade pip pybind11
+      - name: Require pre-provisioned oneMKL
+        id: mkl-version
+        if: matrix.provider == 'mkl'
+        run: |
+          dpkg-query -W 'intel-oneapi-mkl*'
+          echo "version=$(dpkg-query -W -f='${Version}' intel-oneapi-mkl-devel)" >> "$GITHUB_OUTPUT"
+      - name: Validate benchmark policy
+        run: >-
+          python tools/benchmark_policy.py validate
+          --policy benchmarks/regression_policy.json
+      - name: Configure controlled Release benchmark
+        run: >-
+          cmake -S . -B build/controlled-performance-${{ matrix.provider }}
+          -DCMAKE_BUILD_TYPE=Release
+          -DCMAKE_RUNTIME_OUTPUT_DIRECTORY="${GITHUB_WORKSPACE}/build/controlled-performance-${{ matrix.provider }}/bin"
+          -DNEURALE_BUILD_CPP_TESTS=OFF
+          -DNEURALE_BUILD_BENCHMARKS=ON
+          -DNEURALE_ENABLE_MKL=${{ matrix.enable_mkl }}
+          -DNEURALE_ENABLE_CUDA=OFF
+          -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+      - name: Build controlled physical-chain benchmark
+        run: >-
+          cmake --build build/controlled-performance-${{ matrix.provider }} --config Release
+          --target neurale_pipeline_strict_realtime_benchmark
+      - name: Run controlled physical-chain history sample
+        run: |
+          mkdir -p "build/controlled-evidence/${{ matrix.provider }}"
+          build/controlled-performance-${{ matrix.provider }}/bin/neurale_pipeline_strict_realtime_benchmark \
+            --warmup-seconds 1 --duration-seconds 60 --runs 3 \
+            > "build/controlled-evidence/${{ matrix.provider }}/results.jsonl"
+      - name: Capture controlled hardware and software fingerprint
+        run: >-
+          python tools/benchmark_policy.py capture
+          --results "build/controlled-evidence/${{ matrix.provider }}/results.jsonl"
+          --output "build/controlled-evidence/${{ matrix.provider }}/environment.json"
+          --runner-class pyneurale-linux-x64-benchmark-v1
+          --runner-label self-hosted --runner-label linux --runner-label x64
+          --runner-label pyneurale-benchmark
+          --runner-name "${RUNNER_NAME}" --runner-image "self-hosted"
+          --evidence-run-id "${{ github.run_id }}-${{ github.run_attempt }}-${{ matrix.provider }}"
+          --git-sha "${{ github.sha }}"
+          --exact-command "neurale_pipeline_strict_realtime_benchmark --warmup-seconds 1 --duration-seconds 60 --runs 3"
+          --provider "${{ matrix.provider }}"
+          --software-component "cmake=$(cmake --version | head -n 1)"
+          --software-component "pybind11=$(python -c 'import pybind11; print(pybind11.__version__)')"
+          --software-component "mkl=${{ steps.mkl-version.outputs.version || 'disabled' }}"
+      - name: Report current history eligibility without creating a gate
+        run: >-
+          python tools/benchmark_policy.py assess
+          --policy benchmarks/regression_policy.json
+          --runner-class pyneurale-linux-x64-benchmark-v1
+          --input "build/controlled-evidence/${{ matrix.provider }}"
+          --output "build/controlled-evidence/${{ matrix.provider }}/eligibility.json"
+      - name: Upload controlled history evidence
+        uses: actions/upload-artifact@v4
+        with:
+          name: controlled-physical-chain-${{ matrix.provider }}-${{ github.run_id }}-${{ github.run_attempt }}
+          path: build/controlled-evidence/${{ matrix.provider }}/
+          if-no-files-found: error
+          retention-days: 180

pyneurale-0.1.1/.github/workflows/docs.yml

@@ -0,0 +1,57 @@
+name: Documentation
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/docs.yml"
+      - ".readthedocs.yaml"
+      - "cpp/**"
+      - "docs/**"
+      - "src/**"
+      - "tools/build_docs.py"
+      - "pyproject.toml"
+  push:
+    branches:
+      - main
+    paths:
+      - ".github/workflows/docs.yml"
+      - ".readthedocs.yaml"
+      - "cpp/**"
+      - "docs/**"
+      - "src/**"
+      - "tools/build_docs.py"
+      - "pyproject.toml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: docs-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    name: Build documentation
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Install Doxygen
+        run: sudo apt-get update && sudo apt-get install --yes doxygen graphviz
+      - name: Install project and documentation dependencies
+        run: python -m pip install --upgrade pip && python -m pip install -e ".[docs]"
+      - name: Verify headless presentation documentation boundary
+        run: |
+          python - <<'PY'
+          import importlib.util
+          import neurale.experiments.presentation
+
+          import neurale._native as native
+          assert not hasattr(native.experiments, "presentation")
+          PY
+      - name: Build documentation
+        run: python tools/build_docs.py --clean

pyneurale-0.1.1/.github/workflows/format.yml

@@ -0,0 +1,38 @@
+name: Format checks
+
+# A same-repository pull request fires both `push` and `pull_request`, so an
+# unfiltered `push` ran this workflow twice per pull request. The pull-request
+# trigger is the gate; `push` only needs to cover the main branch.
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: format-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  format:
+    name: Python and C++ formatting
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+
+      - name: Install pre-commit
+        run: python -m pip install pre-commit==4.6.0
+
+      - name: Run formatting checks
+        run: pre-commit run --all-files --show-diff-on-failure

pyneurale-0.1.1/.github/workflows/hardware.yml

@@ -0,0 +1,110 @@
+name: CUDA hardware validation
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: cuda-hardware-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  cuda-runtime-and-models:
+    name: CUDA runtime probe and model parity
+    runs-on: [self-hosted, linux, x64, cuda]
+    timeout-minutes: 90
+    env:
+      CMAKE_ARGS: >-
+        -DNEURALE_ENABLE_MKL=OFF
+        -DNEURALE_ENABLE_CUDA=ON
+        -DNEURALE_ENABLE_EXPERIMENT_PRESENTATION=OFF
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Require CUDA hardware and compiler
+        run: |
+          nvidia-smi
+          nvcc --version
+      - name: Install build tooling
+        run: python -m pip install --upgrade pip && python -m pip install pybind11 auditwheel
+      - name: Build CUDA-enabled wheel
+        run: python -m pip wheel . --no-deps --wheel-dir dist
+      - name: Audit CUDA wheel shared-library boundary
+        run: |
+          mkdir -p build/cuda-results
+          auditwheel show dist/*.whl 2>&1 | tee build/cuda-results/wheel-audit.txt
+      - name: Inspect CUDA extension exports and direct dependencies
+        run: >-
+          python tools/artifacts/validate_native_binary.py --profile cuda --wheel-dir dist
+          --audit-report build/cuda-results/wheel-audit.txt
+          --report build/cuda-results/native-binary.json
+      - name: Test CUDA wheel in a clean environment
+        run: >-
+          python tools/artifacts/validate_clean_wheel.py --profile cuda --wheel-dir dist
+          --report build/cuda-results/clean-wheel.json
+      - name: Install CUDA-enabled wheel
+        run: >-
+          python -c "from pathlib import Path; import subprocess,sys;
+          wheel=next(Path('dist').glob('*.whl'));
+          subprocess.check_call([sys.executable,'-m','pip','install',str(wheel)+'[test]'])"
+      - name: Require compiled and available CUDA runtime
+        run: |
+          mkdir -p build/cuda-results
+          nvidia-smi --query-gpu=name,driver_version,compute_cap --format=csv > build/cuda-results/gpu.csv
+          nvcc --version > build/cuda-results/nvcc.txt
+          python - <<'PY' | tee build/cuda-results/runtime.json
+          import json
+          import neurale._native as native
+
+          build = native.build_info()
+          runtime = native.cuda.info()
+          assert build["cuda_compiled"] is True, build
+          assert build["cuda_toolkit_version"], build
+          assert runtime["compiled"] is True, runtime
+          assert runtime["available"] is True, runtime
+          assert runtime["device_count"] >= 1, runtime
+          assert runtime["devices"], runtime
+          print(json.dumps({"build": build, "runtime": runtime}, indent=2))
+          PY
+      # The supported hardware contract requires one CUDA device. The separate
+      # multi-device restoration case is deliberately outside this job rather
+      # than being selected and then silently skipped on a one-GPU runner.
+      - name: Run required single-device CUDA runtime and model tests
+        run: >-
+          python -m pytest -o addopts="--require-native -ra"
+          -m gpu
+          --deselect=tests/unit/models/test_neighbors.py::test_knn_cuda_restores_previous_device
+          --junitxml=build/cuda-results/pytest.xml
+          tests/integration/runtime/test_native_extension.py
+          tests/unit/models/test_neighbors.py
+          tests/unit/models/test_density.py
+          tests/unit/models/test_manifold.py
+      - name: Reject an all-skipped CUDA result
+        run: |
+          python - <<'PY'
+          from pathlib import Path
+          import xml.etree.ElementTree as ET
+
+          root = ET.parse(Path("build/cuda-results/pytest.xml")).getroot()
+          suites = [root] if root.tag == "testsuite" else list(root.findall("testsuite"))
+          tests = sum(int(suite.attrib.get("tests", 0)) for suite in suites)
+          skipped = sum(int(suite.attrib.get("skipped", 0)) for suite in suites)
+          failures = sum(int(suite.attrib.get("failures", 0)) for suite in suites)
+          errors = sum(int(suite.attrib.get("errors", 0)) for suite in suites)
+          assert tests >= 31, tests
+          assert skipped == 0, skipped
+          assert failures == 0 and errors == 0, (failures, errors)
+          PY
+      - name: Upload CUDA evidence
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: cuda-hardware-${{ github.run_id }}-${{ github.run_attempt }}
+          path: build/cuda-results
+          if-no-files-found: error
+          retention-days: 30

pyneurale-0.1.1/.github/workflows/pr-smoke.yml

@@ -0,0 +1,112 @@
+name: Fast PR smoke
+
+on:
+  pull_request:
+    paths:
+      - ".github/workflows/**"
+      - "benchmarks/**"
+      - "CMakeLists.txt"
+      - "cpp/**"
+      - "specifications/**"
+      - "src/**"
+      - "tests/**"
+      - "tools/**"
+      - "pyproject.toml"
+      - "pytest.ini"
+      - "SUPPORT.md"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pr-smoke-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  source-imports:
+    name: Source-only imports (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-24.04
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: pip
+      - name: Install source-only dependencies
+        run: python -m pip install --upgrade pip && python -m pip install numpy scipy pytest
+      - name: Run import and dependency-error smoke
+        env:
+          PYTHONPATH: ${{ github.workspace }}/src
+        run: |
+          # The file list is the one in tests/conftest.py, never a second copy:
+          # a hand-written list in CI drifts, and a python_only file missing
+          # from it silently runs nowhere. Passing paths is still required --
+          # collecting all of tests/ without an install dies on the native
+          # modules before any marker selection happens.
+          readarray -t suite < <(python -c "
+          import sys
+          sys.path.insert(0, 'tests')
+          import conftest
+          for relative in sorted(conftest._PYTHON_ONLY_FILES):
+              print('tests/' + relative)
+          ")
+          python -m pytest -o addopts="" -m python_only "${suite[@]}"
+
+  cpu-wheel:
+    name: CPU wheel smoke (${{ matrix.name }})
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Ubuntu 24.04 / Python 3.12
+            runner: ubuntu-24.04
+          - name: Windows / Python 3.12
+            runner: windows-latest
+    env:
+      CMAKE_ARGS: >-
+        -DNEURALE_ENABLE_MKL=OFF
+        -DNEURALE_ENABLE_CUDA=OFF
+        -DNEURALE_ENABLE_EXPERIMENT_PRESENTATION=OFF
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Install build tooling
+        run: python -m pip install --upgrade pip && python -m pip install pybind11
+      - name: Build CPU wheel
+        run: python -m pip wheel . --no-deps --wheel-dir dist
+      - name: Test core wheel in a clean environment
+        run: python tools/artifacts/validate_clean_wheel.py --profile core --wheel-dir dist
+      - name: Install built wheel
+        run: >-
+          python -c "from pathlib import Path; import subprocess,sys;
+          wheel=next(Path('dist').glob('*.whl'));
+          subprocess.check_call([sys.executable,'-m','pip','install',str(wheel)+'[test]'])"
+      - name: Require native CPU and headless imports
+        run: >-
+          python -c "import importlib.util,sys;
+          import neurale,neurale.experiments;
+          import neurale._native as native;
+          info=native.build_info();
+          assert info['cuda_compiled'] is False;
+          assert info['cpu_math_backend']=='none';
+          assert not hasattr(native.experiments, 'presentation');
+          print(info)"
+      - name: Run native and headless experiment smoke
+        run: >-
+          python -m pytest
+          tests/integration/runtime/test_native_extension.py
+          tests/unit/experiments/test_experiments_import.py
+          tests/unit/experiments/test_presentation_import.py
+      - name: Run installed-wheel formal Center-Out closed loops
+        run: >-
+          python -m pytest -o "addopts=--require-native -ra"
+          tests/integration/experiments/test_center_out_closed_loop.py::test_headless_center_out

pyneurale-0.1.1/.github/workflows/sanitizers.yml

@@ -0,0 +1,89 @@
+name: Native sanitizers
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - ".github/workflows/sanitizers.yml"
+      - "CMakeLists.txt"
+      - "cpp/**"
+      - "src/**"
+      - "tests/**"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: sanitizers-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  linux-asan-ubsan-lsan:
+    name: Linux CPU ASan, UBSan, and LSan
+    runs-on: ubuntu-24.04
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Install native build tooling
+        run: python -m pip install --upgrade pip pybind11
+      - name: Configure native sanitizer tests
+        run: >-
+          cmake -S . -B build/sanitizers
+          -DNEURALE_BUILD_CPP_TESTS=ON
+          -DNEURALE_ENABLE_MKL=OFF
+          -DNEURALE_ENABLE_CUDA=OFF
+          -DNEURALE_ENABLE_ASAN=ON
+          -DNEURALE_ENABLE_UBSAN=ON
+          -DNEURALE_ENABLE_LSAN=ON
+          -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+      - name: Compile every public header independently with GCC
+        run: >-
+          cmake --build build/sanitizers --config RelWithDebInfo
+          --target neurale_public_header_self_containment
+      - name: Build native sanitizer tests
+        run: cmake --build build/sanitizers --config RelWithDebInfo
+      - name: Run required sanitizer tests
+        run: >-
+          ctest --test-dir build/sanitizers -C RelWithDebInfo
+          -R '^(neurale_streaming_|neurale_pipeline_|neurale_recording_|neurale_experiments_|neurale_execution_)'
+          -LE 'allocation-full|allocation-operator-new'
+          --no-tests=error --output-on-failure
+
+  windows-msvc-asan:
+    name: Windows CPU MSVC ASan
+    runs-on: windows-latest
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: pip
+      - name: Install native build tooling
+        run: python -m pip install --upgrade pip pybind11
+      - name: Configure native ASan tests
+        run: >-
+          cmake -S . -B build/asan-msvc
+          -DNEURALE_BUILD_CPP_TESTS=ON
+          -DNEURALE_ENABLE_MKL=OFF
+          -DNEURALE_ENABLE_CUDA=OFF
+          -DNEURALE_ENABLE_ASAN=ON
+          -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+      - name: Compile every public header independently with MSVC
+        run: >-
+          cmake --build build/asan-msvc --config RelWithDebInfo
+          --target neurale_public_header_self_containment
+      - name: Build native ASan tests
+        run: cmake --build build/asan-msvc --config RelWithDebInfo
+      - name: Run required ASan tests
+        run: >-
+          ctest --test-dir build/asan-msvc -C RelWithDebInfo
+          -R '^(neurale_streaming_|neurale_pipeline_|neurale_recording_|neurale_experiments_|neurale_execution_)'
+          -LE 'allocation-full|allocation-operator-new'
+          --no-tests=error --output-on-failure