CI: green test matrix, three cleanups after the MSVC fix

Previous run confirmed the MSVC-on-Windows fix works — all 12 test
matrix jobs (ubuntu/macos/windows × py3.11/3.12/3.13/3.14) are green.
sdist is green too. Only build-wheels failed, and only for one real
reason (macOS).

Three cleanups in this commit:

1. Remove the temporary Windows DLL diagnostic step from the test job.
   It lived at .github/workflows/ci.yml as `Diagnose extension DLL
   dependencies (Windows)`. Its purpose was to identify the MinGW-vs-
   MSVC issue, which it did, and now that the ilammy/msvc-dev-cmd
   step is landed the diagnostic is pure CI log noise. The full
   diagnostic recipe (pefile import table + ctypes.WinDLL probe +
   spec-load PyInit probe) is preserved in ~/.claude/CI-SETUP-NOTES.md
   under "Windows CI for Cython extensions: force MSVC" for future
   reuse.

2. Add `fail-fast: false` to the build-wheels matrix. Without it, a
   single-OS wheel failure cancels the other OSes mid-build, so the
   previous run showed "all three build-wheels jobs failed" when in
   reality only macOS actually failed — linux and windows were just
   cascade-canceled while pulling the manylinux image / setting up
   MSVC. The test matrix already has fail-fast: false; this aligns
   build-wheels with the same policy.

3. Drop `brew install libomp` from the cibuildwheel macOS before-all.
   The macOS wheel job actually failed because delocate-wheel refused
   to bundle Homebrew's libomp 22.1.2: that libomp.dylib has a minimum
   macOS target of 15.0, but cibuildwheel's default arm64 target is
   11.0, so bundling it would produce a wheel that lies about its
   compatibility.

   Options considered:
     (a) Bump MACOSX_DEPLOYMENT_TARGET to 15.0 — shrinks supported
         macOS range by ~4 years.
     (b) Build libomp from source with a lower target in before-all —
         complex CI, fragile.
     (c) Drop libomp entirely, let meson's
         `dependency('openmp', required: false)` fall back to serial.

   We take (c). Cython's `prange` silently degrades to `range` when
   OpenMP is not present, so the tests still pass and every numerical
   invariant still holds — the macOS wheel is just single-threaded.
   Users who want parallel fits on macOS can install from source after
   `brew install libomp` (README will document this in Phase 8).

Linux and Windows wheel builds are unaffected by this change — Linux
has GCC + libgomp in the manylinux container, Windows has MSVC's
vcomp140 activated via ilammy/msvc-dev-cmd. Both continue to produce
parallel wheels.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Technologicat

.github/workflows/ci.yml

@@ -81,119 +81,14 @@ jobs:
       - name: Install wlsqm
         run: pip install --no-build-isolation -e .
 
-      # Diagnose Windows DLL-load failures: first run said vcomp140 is
-      # resolvable via ctypes, so the problem is deeper in the chain. Use
-      # pefile to dump the DLL-level import table of every built .pyd, then
-      # probe each .pyd with ctypes.WinDLL (which only exercises the Windows
-      # loader — PyInit never runs, so a WinDLL failure means Windows could
-      # not resolve a direct DLL import, whereas a WinDLL success + Python
-      # import failure means the Cython cimport chain in PyInit is what
-      # fails).
-      - name: Diagnose extension DLL dependencies (Windows)
-        if: runner.os == 'Windows'
-        # Use Git Bash so the Python heredoc works. PowerShell does not
-        # understand `python - <<'PY' ... PY` and chokes at parse time.
-        shell: bash
-        run: |
-          python -m pip install -q pefile
-          python - <<'PY'
-          import ctypes, glob, importlib.util, os, sys, traceback
-          import pefile
-
-          print('python:', sys.version)
-          print('prefix:', sys.prefix)
-
-          # meson-python editable install drops the compiled .pyd files
-          # under build/<tag>/wlsqm/..., not under the source tree. The
-          # editable loader redirects imports there, so that is where we
-          # have to look.
-          pyds = sorted(glob.glob('build/**/*.pyd', recursive=True))
-          print('=== built .pyd files ===')
-          for p in pyds:
-              print(' ', p)
-
-          print()
-          print('=== DLL-level imports per .pyd (pefile) ===')
-          for p in pyds:
-              try:
-                  pe = pefile.PE(p, fast_load=True)
-                  pe.parse_data_directories(directories=[pefile.DIRECTORY_ENTRY['IMAGE_DIRECTORY_ENTRY_IMPORT']])
-                  imports = [e.dll.decode(errors='replace') for e in getattr(pe, 'DIRECTORY_ENTRY_IMPORT', [])]
-                  print(f'  {p} ->')
-                  for name in imports:
-                      print(f'      {name}')
-                  pe.close()
-              except Exception as e:
-                  print(f'  {p} -> pefile error: {e}')
-
-          print()
-          print('=== ctypes.WinDLL probe per .pyd (DLL-level LoadLibrary only, no PyInit) ===')
-          for p in pyds:
-              try:
-                  ctypes.WinDLL(os.path.abspath(p))
-                  print(f'  WinDLL OK  : {p}')
-              except OSError as e:
-                  print(f'  WinDLL FAIL: {p} -- {e}')
-
-          print()
-          print('=== importlib spec-load probe (runs PyInit for each .pyd individually) ===')
-          # spec_from_file_location loads a .pyd by filesystem path and
-          # runs its PyInit without going through wlsqm/__init__.py. This
-          # isolates which module's PyInit is the first to raise.
-          #
-          # Extensions that `cimport` other wlsqm modules will still
-          # trigger Python-level imports during PyInit, and those
-          # DO go through the package machinery — but we load in
-          # dependency order below, so by the time simple.pyx's PyInit
-          # runs, its cimported deps are already in sys.modules.
-          load_order = [
-              ('wlsqm.fitter.defs',          'fitter/defs'),
-              ('wlsqm.fitter.infra',         'fitter/infra'),
-              ('wlsqm.fitter.polyeval',      'fitter/polyeval'),
-              ('wlsqm.utils.ptrwrap',        'utils/ptrwrap'),
-              ('wlsqm.utils.lapackdrivers',  'utils/lapackdrivers'),
-              ('wlsqm.fitter.interp',        'fitter/interp'),
-              ('wlsqm.fitter.impl',          'fitter/impl'),
-              ('wlsqm.fitter.simple',        'fitter/simple'),
-              ('wlsqm.fitter.expert',        'fitter/expert'),
-          ]
-          def find_pyd(subpath):
-              # subpath is like 'fitter/defs' or 'utils/lapackdrivers'.
-              # Match by subdir + filename stem; the ABI tag varies with
-              # the Python version in the test matrix, so we don't hardcode it.
-              subdir, stem = subpath.split('/')
-              for p in pyds:
-                  norm = p.replace('\\', '/')
-                  if f'/{subdir}/' in norm and os.path.basename(norm).split('.')[0] == stem:
-                      return p
-              return None
-
-          for fqname, subpath in load_order:
-              p = find_pyd(subpath)
-              if p is None:
-                  print(f'  not found : {fqname}')
-                  continue
-              try:
-                  spec = importlib.util.spec_from_file_location(fqname, p)
-                  mod = importlib.util.module_from_spec(spec)
-                  sys.modules[fqname] = mod
-                  spec.loader.exec_module(mod)
-                  print(f'  PyInit OK : {fqname}  ({p})')
-              except Exception as e:
-                  print(f'  PyInit FAIL: {fqname}  ({p})')
-                  print(f'             {type(e).__name__}: {e}')
-                  traceback.print_exc()
-                  break
-          PY
-        continue-on-error: true
-
       - name: Run tests
         run: pytest tests/ -v
 
   build-wheels:
     needs: test
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
     steps:

pyproject.toml

@@ -119,8 +119,22 @@ skip = "*-win32 *-manylinux_i686 *-musllinux*"
 test-requires = ["pytest", "numpy", "scipy"]
 test-command = "pytest {project}/tests -v"
 
-[tool.cibuildwheel.macos]
-before-all = "brew install libomp"
+# macOS wheels ship without OpenMP. We could `brew install libomp` in a
+# `[tool.cibuildwheel.macos] before-all` step and let delocate-wheel bundle
+# libomp.dylib into the wheel, but Homebrew's current libomp (22.x) has a
+# minimum macOS target (15.0) newer than cibuildwheel's default arm64 target
+# (11.0). delocate-wheel correctly refuses to bundle it because the resulting
+# wheel would lie about its compatibility.
+#
+# We could either (a) bump MACOSX_DEPLOYMENT_TARGET to 15.0, shrinking the
+# supported macOS range by ~4 years, or (b) build libomp from source with a
+# lower target (complex CI). Instead, we lean on meson's
+# `dependency('openmp', required: false)` fallback: without libomp on the
+# build host, meson builds the extension in serial mode. Cython's `prange`
+# degrades to plain `range`, tests still pass, and macOS wheels are slower
+# but portable all the way back to macOS 11. Users who want parallel fits
+# on macOS can install from source: `brew install libomp` and then
+# `pip install --no-binary wlsqm wlsqm`. README.md documents this.
 
 [dependency-groups]
 dev = [