Merge branch 'v3' into v3c/library-fixes

bzip2, fastlz, jbig, qdbm: thread SPC_DEFAULT_CFLAGS into the
hand-rolled Makefile patches and shell compile commands. Backward
compatible when the env var is empty.

icu: append SPC_DEFAULT_CXXFLAGS/LDFLAGS to runConfigureICU's CXXFLAGS
and LDFLAGS so user flags reach the bundled cxx invocation.

openssl: append user CFLAGS/LDFLAGS after the target name on Configure
so options like -flto and -fprofile-* reach the openssl build.

libheif: rewrite libheif 1.22+'s C-incompatible
`struct heif_bad_pixel { uint32_t row; uint32_t column; };` as a
typedef so C consumers compile.

ncurses: filter the clang/zig-cc "N warning(s) generated." stdout line
out of MKlib_gen.sh's preprocessor pipe before sed turns it into
invalid C in lib_gen.c.

libaom: detect target CPU from SystemTarget instead of hard-coding
generic, fall back to generic only when neither nasm nor yasm is
available, and turn off examples/tests/tools/docs.

.github/workflows/build-unix.yml

@@ -331,4 +331,5 @@ jobs:
         with:
           name: build-meta-${{ inputs.php-version }}-${{ inputs.os }}
           path: |
-            buildroot/build-manifest.json
+            buildroot/build-extensions.json
+            buildroot/build-libraries.json

.github/workflows/build-windows-x86_64.yml

@@ -115,4 +115,5 @@ jobs:
         with:
           name: build-meta
           path: |
-            buildroot/build-manifest.json
+            buildroot/build-extensions.json
+            buildroot/build-libraries.json

.github/workflows/ext-matrix-tests.yml

@@ -2,14 +2,13 @@ name: "Extension Matrix Tests"
 
 on:
   workflow_dispatch:
-  pull_request:
+  push:
-    types: [opened, synchronize, labeled]
 
 jobs:
   test:
     name: "${{ matrix.extension }} (PHP ${{ matrix.php-version }} on ${{ matrix.operating-system }})"
     runs-on: ${{ matrix.operating-system }}
-    if: contains(github.event.pull_request.labels.*.name, 'need-full-test')
+    if: contains(github.event.head_commit.message, 'extension test') || contains(github.event.head_commit.message, 'test extensions')
     strategy:
       fail-fast: false
       matrix:

.github/workflows/tests.yml

@@ -227,7 +227,7 @@ jobs:
           echo "matrix=$(echo "$FINAL" | jq -c '{"combo": .}')" >> "$GITHUB_OUTPUT"
 
   ext-test:
-    name: "Ext test: ${{ matrix.combo.extension }} [${{ matrix.combo.sapi }}] (PHP ${{ matrix.combo.php-version }} - ${{ matrix.combo.os }}-${{ matrix.combo.arch }})"
+    name: "Ext test: ${{ matrix.combo.extension }} (PHP ${{ matrix.combo.php-version }} · ${{ matrix.combo.os }}-${{ matrix.combo.arch }})"
     needs: gen-matrix
     runs-on: ${{ matrix.combo.runner }}
     timeout-minutes: 120
@@ -266,5 +266,5 @@ jobs:
         if: always() && hashFiles('log/**') != ''
         uses: actions/upload-artifact@v4
         with:
-          name: logs-${{ matrix.combo.os }}-${{ matrix.combo.arch }}-${{ matrix.combo.sapi }}-${{ matrix.combo.extension }}-php${{ matrix.combo.php-version }}
+          name: logs-${{ matrix.combo.os }}-${{ matrix.combo.arch }}-${{ matrix.combo.extension }}-php${{ matrix.combo.php-version }}
           path: log

captainhook.json

@@ -20,7 +20,7 @@
                 ]
             },
             {
-                "action": "php bin/spc dev:lint-config --check",
+                "action": "bin/spc dev:lint-config --check",
                 "conditions": [
                     {
                         "exec": "\\CaptainHook\\App\\Hook\\Condition\\FileStaged\\InDirectory",

config/pkg/ext/ext-imagick.yml

@@ -13,5 +13,4 @@ ext-imagick:
     os:
       - Linux
       - Darwin
-      - Windows
     arg-type: custom

config/pkg/lib/imagemagick.yml

@@ -16,59 +16,13 @@ imagemagick:
     - libtiff
     - libheif
     - bzip2
-  depends@windows:
-    - zlib
   suggests:
     - zstd
     - xz
     - libzip
     - libxml2
-  headers@windows:
-    - imagemagick/MagickWand/MagickWand.h
   lang: cpp
   pkg-configs:
     - Magick++-7.Q16HDRI
     - MagickCore-7.Q16HDRI
     - MagickWand-7.Q16HDRI
-  static-libs@windows:
-    - CORE_RL_MagickWand_.lib
-    - CORE_RL_MagickCore_.lib
-    - CORE_RL_coders_.lib
-    - CORE_RL_filters_.lib
-    - CORE_RL_aom_.lib
-    - CORE_RL_brotli_.lib
-    - CORE_RL_bzip2_.lib
-    - CORE_RL_cairo_.lib
-    - CORE_RL_croco_.lib
-    - CORE_RL_de265_.lib
-    - CORE_RL_exr_.lib
-    - CORE_RL_ffi_.lib
-    - CORE_RL_freetype_.lib
-    - CORE_RL_fribidi_.lib
-    - CORE_RL_gdk-pixbuf_.lib
-    - CORE_RL_glib_.lib
-    - CORE_RL_harfbuzz_.lib
-    - CORE_RL_heif_.lib
-    - CORE_RL_highway_.lib
-    - CORE_RL_imath_.lib
-    - CORE_RL_jpeg-turbo-12_.lib
-    - CORE_RL_jpeg-turbo-16_.lib
-    - CORE_RL_jpeg-turbo_.lib
-    - CORE_RL_jpeg-xl_.lib
-    - CORE_RL_lcms_.lib
-    - CORE_RL_lqr_.lib
-    - CORE_RL_lzma_.lib
-    - CORE_RL_openh264_.lib
-    - CORE_RL_openjpeg_.lib
-    - CORE_RL_openjph_.lib
-    - CORE_RL_pango_.lib
-    - CORE_RL_pixman_.lib
-    - CORE_RL_png_.lib
-    - CORE_RL_raqm_.lib
-    - CORE_RL_raw_.lib
-    - CORE_RL_rsvg_.lib
-    - CORE_RL_tiff_.lib
-    - CORE_RL_webp_.lib
-    - CORE_RL_xml_.lib
-    - CORE_RL_zip_.lib
-    - CORE_RL_zlib_.lib

config/pkg/lib/libiconv-win.yml

@@ -9,4 +9,5 @@ libiconv-win:
       license-files: [source/COPYING]
       license: GPL-3.0-or-later
   static-libs@windows:
+    - libiconv.lib
     - libiconv_a.lib

config/pkg/lib/libzip.yml

@@ -11,10 +11,6 @@ libzip:
       license: BSD-3-Clause
   depends:
     - zlib
-  depends@windows:
-    - zlib
-    - bzip2
-    - xz
   suggests:
     - bzip2
     - xz

config/pkg/lib/openssl.yml

@@ -27,5 +27,4 @@ openssl:
     - libcrypto.lib
   tools@windows:
     - jom
-    - nasm
     - strawberry-perl

config/pkg/lib/postgresql.yml

@@ -5,6 +5,8 @@ postgresql:
       type: ghtagtar
       repo: postgres/postgres
       match: REL_18_\d+
+    binary:
+      windows-x86_64: { type: url, url: 'https://get.enterprisedb.com/postgresql/postgresql-16.8-1-windows-x64-binaries.zip', extract: { lib/libpq.lib: '{build_root_path}/lib/libpq.lib', lib/libpgport.lib: '{build_root_path}/lib/libpgport.lib', lib/libpgcommon.lib: '{build_root_path}/lib/libpgcommon.lib', include/libpq-fe.h: '{build_root_path}/include/libpq-fe.h', include/postgres_ext.h: '{build_root_path}/include/postgres_ext.h', include/pg_config_ext.h: '{build_root_path}/include/pg_config_ext.h', include/libpq/libpq-fs.h: '{build_root_path}/include/libpq/libpq-fs.h' } }
     metadata:
       license-files: ['@/postgresql.txt']
       license: PostgreSQL
@@ -14,9 +16,6 @@ postgresql:
     - openssl
     - zlib
     - libedit
-  depends@windows:
-    - openssl
-    - zlib
   suggests@unix:
     - icu
     - libxslt
@@ -28,9 +27,3 @@ postgresql:
     - libpq.lib
     - libpgport.lib
     - libpgcommon.lib
-  tools@windows:
-    - python-win
-    - meson
-    - ninja
-    - winflexbison
-    - strawberry-perl

config/pkg/tool/go-win.yml

@@ -5,7 +5,7 @@ go-win:
   env:
     GOROOT: '{pkg_root_path}/go-win'
     GOBIN: '{pkg_root_path}/go-win/bin'
-    GOPATH: '{pkg_root_path}/go-win/gopath'
+    GOPATH: '{pkg_root_path}/go-win/go'
   path@windows:
     - '{pkg_root_path}/go-win/bin'
   tool:

config/pkg/tool/meson.yml

@@ -1,11 +0,0 @@
-meson:
-  type: tool
-  artifact:
-    binary:
-      windows-x86_64: { type: url, url: 'https://github.com/mesonbuild/meson/releases/download/1.11.1/meson-1.11.1-py3-none-any.whl', extract: '{pkg_root_path}/meson/meson-1.11.1-py3-none-any.whl' }
-  path@windows:
-    - '{pkg_root_path}\meson'
-  tool:
-    provides:
-      - meson.bat
-    binary-subdir: meson

config/pkg/tool/ninja.yml

@@ -1,9 +0,0 @@
-ninja:
-  type: tool
-  artifact:
-    binary:
-      windows-x86_64: { type: url, url: 'https://github.com/ninja-build/ninja/releases/download/v1.13.2/ninja-win.zip', extract: { ninja.exe: '{pkg_root_path}/bin/ninja.exe' } }
-  tool:
-    provides:
-      - ninja.exe
-    binary-subdir: bin

config/pkg/tool/python-win.yml

@@ -1,8 +0,0 @@
-python-win:
-  type: tool
-  artifact:
-    binary: custom
-  tool:
-    provides:
-      - python.exe
-    binary-subdir: python-win/tools

config/pkg/tool/winflexbison.yml

@@ -1,12 +0,0 @@
-winflexbison:
-  type: tool
-  artifact:
-    binary:
-      windows-x86_64: { type: url, url: 'https://github.com/lexxmark/winflexbison/releases/download/v2.5.25/win_flex_bison-2.5.25.zip', extract: '{pkg_root_path}/winflexbison' }
-  path@windows:
-    - '{pkg_root_path}\winflexbison'
-  tool:
-    provides:
-      - win_flex.exe
-      - win_bison.exe
-    binary-subdir: winflexbison

docs/.vitepress/sidebar.en.ts

@@ -51,7 +51,6 @@ export default {
         { text: 'Build Lifecycle', link: '/en/develop/build-lifecycle' },
         { text: 'Compilation Tools', link: '/en/develop/system-build-tools' },
         { text: 'Doctor', link: '/en/develop/doctor-module' },
-        { text: 'Performance Engineering', link: '/en/develop/performance' },
         { text: 'PHP Source Modifications', link: '/en/develop/php-src-changes' },
       ],
     },

docs/.vitepress/sidebar.zh.ts

@@ -51,7 +51,6 @@ export default {
         { text: '构建生命周期', link: '/zh/develop/build-lifecycle' },
         { text: '编译工具', link: '/zh/develop/system-build-tools' },
         { text: 'Doctor 环境检查', link: '/zh/develop/doctor-module' },
-        { text: '性能工程', link: '/zh/develop/performance' },
         { text: '对 PHP 源码的修改', link: '/zh/develop/php-src-changes' },
       ],
     },

docs/en/develop/performance.md

@@ -1,301 +0,0 @@
-# Performance Engineering
-
-StaticPHP controls how PHP, its extensions, dependency libraries, and SAPIs are compiled. These choices can affect runtime throughput and latency, startup time, memory use, binary size, portability, and build time. They are related, but they are not the same metric: a smaller binary is not necessarily faster, and a slower build can still produce a faster program.
-
-This page records the current v3 defaults, the optimization work already incorporated into the build, and the areas still being investigated. On Linux, libc and linkage form the first layer: the default fully static musl build and a dynamically linked glibc build have different portability, extension-loading, and performance characteristics. Compiler flags, PGO, and LTO form later layers of the same ongoing work.
-
-This page does not claim that a StaticPHP binary is always faster than another PHP distribution. Results depend on the PHP version, CPU, toolchain, extension set, SAPI, libc, linkage, runtime configuration, and workload.
-
-::: warning Current v3 status
-The v3 branch does not currently expose stable `--pgi`, `--pgo`, or `--lto` CLI options. PGO orchestration and broader LTO compatibility remain active areas of investigation. The sections below describe their design, current constraints, and the direction of that work rather than a supported release recipe.
-:::
-
-## Linux Linkage and libc
-
-StaticPHP's Linux default optimizes for a self-contained artifact, not for the highest possible score on every server workload. `config/env.ini` selects `${GNU_ARCH}-linux-musl`; with the default Zig toolchain this produces a fully static musl binary.
-
-Current performance investigations distinguish three Linux targets:
-
-| Target | libc and final linkage | Runtime requirements | Shared extensions / FFI | Current role |
-|---|---|---|---|---|
-| `native-native-musl` | musl, fully static | Linux kernel on a compatible CPU | No | Default portable single-file release |
-| `native-native-musl -dynamic` | musl, dynamically linked | Compatible musl loader and libraries | Yes | Isolate static-versus-dynamic effects while keeping musl |
-| `native-native-gnu.2.17` | glibc, dynamically linked with a 2.17 baseline | glibc 2.17 or newer | Yes | Broad GNU/Linux compatibility and a glibc performance baseline |
-
-The architecture may replace either `native` component, for example `x86_64-linux-musl`. A `-gnu` target without an explicit version targets the selected/current glibc ABI instead of promising the 2.17 floor.
-
-In this context, “dynamically linked PHP” does not mean every dependency is a system `.so`. StaticPHP still builds most selected third-party libraries and PHP extensions as static archives and links them into the PHP executable. The dynamic part is primarily the libc/runtime loader and any extensions explicitly requested through `--build-shared`. This differs from a conventional distribution PHP in which PHP and many dependencies are separate shared objects.
-
-Likewise, a “static extension” and a “static libc” are independent choices. A glibc-dynamic PHP can contain all PHP extensions statically, while a musl-dynamic PHP can load selected `.so` extensions. Only a fully static musl target prevents runtime loading because no dynamic loader participates in the process.
-
-### What Static versus Dynamic Linking Changes
-
-Static and dynamic linkage mainly change startup work, relocation, symbol resolution, deployment, and library sharing. They do not automatically change PHP VM code generation.
-
-- A fully static process does not start through a runtime dynamic loader or relocate a set of DSOs. This can help very short-lived CLI startup, but PHP initialization, extension startup, script parsing, and Opcache often cost more.
-- A dynamic process pays loader and relocation costs at startup. Long-running FPM or FrankenPHP workers amortize this cost over many requests.
-- Static linking gives the linker a larger closed world for section garbage collection and, when explicitly enabled, LTO. Static linking alone does not perform cross-object optimization.
-- Dynamic glibc allows shared extensions, FFI, NSS integration, and replacement or security updates of runtime libraries without rebuilding PHP. A fully static artifact must be rebuilt to receive libc or embedded-library fixes.
-- Shared-library code pages can be reused across different programs. Identical static PHP worker processes still share file-backed executable pages with one another, so “static means every worker duplicates all code in RAM” is not an accurate model.
-
-StaticPHP's [performance testing issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838) recorded one PHP 8.4 test in which static and dynamic builds stayed within about 1% in either direction across repeated runs. This is useful evidence that linkage alone may not dominate steady-state PHP execution, but it is not a universal result. Short CLI programs, many DSOs, different loaders, and I/O-heavy extensions can produce a different outcome.
-
-### musl versus glibc Performance Surfaces
-
-libc differences appear only when a workload reaches libc or behavior implemented around it. Pure PHP code spends much of its time in the Zend VM, Opcache, and Zend Memory Manager. PHP's own [Zend Memory Manager](https://wiki.php.net/internals/zend_mm) handles most request-bound allocations, so a microbenchmark dominated by PHP arrays and opcodes may expose less of the system allocator than a C extension or server runtime does.
-
-| Workload area | Why the libc can matter | Main observed signals |
-|---|---|---|
-| CPU-bound PHP opcodes | Usually dominated by PHP VM, compiler, CPU target, and Opcache rather than libc | Same PHP/VM/compiler first; then change only libc/linkage |
-| Persistent and native allocations | Persistent PHP allocations, C extensions, libraries, and server code can call libc allocation directly | throughput, allocation contention, RSS, fragmentation after a long soak |
-| ZTS and FrankenPHP | Thread creation, TLS, mutexes, allocator contention, and per-thread caches differ | scaling by worker/thread count, p95/p99, RSS per thread |
-| DNS and name services | Resolver strategy, NSS, `/etc/resolv.conf`, and caching differ | cached and uncached lookup latency, failure/failover latency, query volume |
-| Locale, iconv, regex, and stdio | Implementations and supported behavior differ, not merely speed | correctness first, then throughput with production locale/data |
-| Very short CLI commands | Loader/relocation and initialization are a larger fraction of total time | cold and warm wall time over many process launches |
-| Long-running workers | Startup is amortized; allocator, threading, syscalls, and application behavior become more important | sustained throughput, tail latency, peak/steady RSS |
-
-glibc's allocator provides per-thread caches and multiple arenas whose limits can be tuned; these can improve concurrent allocation throughput at the cost of retained memory. The [glibc allocation tunables](https://sourceware.org/glibc/manual/latest/html_node/Memory-Allocation-Tunables.html) therefore belong in a benchmark record. musl uses a different allocator and prioritizes low baseline overhead, bounded fragmentation, and static-linking suitability; neither design guarantees lower latency or RSS for every PHP application.
-
-Resolver behavior can reverse an apparent “libc performance” result. The [musl functional-differences documentation](https://wiki.musl-libc.org/functional-differences-from-glibc.html) notes that musl queries configured nameservers in parallel, while traditional glibc behavior tries them sequentially. This can improve failover latency but increase DNS traffic. glibc also participates in configurable NSS modules. StaticPHP's DNS comparisons therefore keep resolver, cache state, search domains, and failure conditions consistent instead of treating resolver results as a CPU-only benchmark.
-
-musl uses a much smaller default thread stack than typical glibc configurations. That can reduce reserved address space for thread-heavy programs but can also expose stack assumptions in extensions. It is a deployment and memory characteristic, not proof that one libc executes PHP opcodes faster.
-
-### Current Comparison Model
-
-A direct comparison between the default musl-static binary and a distribution glibc PHP changes libc, linker, compiler, flags, PHP configuration, extensions, dependency versions, and INI at once. It therefore cannot attribute the full difference to libc.
-
-The project uses a controlled matrix with the same StaticPHP commit, PHP source, Zig version, flags, extensions, and SAPI. The three builds are represented by the following commands:
-
-```bash
-EXTENSIONS="bcmath,curl,openssl,opcache"
-
-# A: default-style, fully static musl
-SPC_TARGET=native-native-musl spc build:php "$EXTENSIONS" --build-cli
-
-# B: dynamically linked musl; requires a musl runtime
-SPC_TARGET="native-native-musl -dynamic" spc build:php "$EXTENSIONS" --build-cli
-
-# C: dynamically linked glibc with a defined compatibility floor
-SPC_TARGET=native-native-gnu.2.17 spc build:php "$EXTENSIONS" --build-cli
-```
-
-Each result is associated with its output, build manifest, `php -i`, and logs. The actual linkage is identified from the binary rather than inferred from its filename:
-
-```bash
-file buildroot/bin/php
-readelf -l buildroot/bin/php | grep 'Requesting program interpreter'
-```
-
-A versus B estimates the linkage effect while holding musl constant. B versus C estimates libc/runtime effects with dynamic linkage on both sides. A distribution PHP remains useful as an external reference, but it is reported separately because its compiler and packaging configuration are different.
-
-The current comparison set covers both no-op startup and real CLI scripts. FPM and FrankenPHP measurements separate worker warmup from sustained throughput and tail latency. libc-sensitive coverage includes allocation-heavy extension work, concurrent requests, DNS cache hit/miss/failure cases, file I/O, and long-running RSS/fragmentation behavior.
-
-### Deployment Characteristics
-
-- **musl static** is the StaticPHP default and represents the portable, self-contained deployment profile without shared extensions or FFI.
-- **glibc dynamic** represents integration with a GNU/Linux runtime, including `.so` extensions, FFI, the host name-service stack, and workloads for which glibc produces better measured behavior.
-- **musl dynamic** represents a musl-based runtime that still requires shared extensions. It also provides the middle point in the controlled comparison above, while giving up much of the default's single-file portability.
-
-The default is designed to remain predictable and broadly deployable. The fastest target is workload-specific and continues to be evaluated against the actual CPU, PHP version, SAPI, and application behavior.
-
-## Where Optimization Enters the v3 Build
-
-The v3 build passes optimization settings through several layers:
-
-1. `config/env.ini` supplies platform defaults. `config/env.custom.ini` or the process environment can override them.
-2. `ToolchainManager` selects Zig on Linux, MSVC on Windows, and system, Homebrew, or MacPorts Clang on macOS by default. It initializes `CC`, `CXX`, `AR`, `RANLIB`, and `LD`.
-3. Package executors and `Package::getLibExtra*Flags()` pass the default flags into Autoconf, CMake, and package-specific builds.
-4. The PHP target passes its PHP-specific flags to both `./configure` and `make` on Unix. Static extensions compiled as part of php-src see the same compiler environment.
-5. The FrankenPHP target links the PHP embed library through CGO. Its `CGO_CFLAGS` and `CGO_LDFLAGS` include the PHP and dependency-library flags, followed by Go and external-linker settings.
-6. Deployment extracts separate debug information and strips Unix binaries by default. UPX is optional and affects size and startup behavior, not generated PHP code.
-
-This propagation is intentionally broad, but it is not yet perfectly uniform. Packages with hand-written compiler commands or unusual upstream build systems may ignore part of the global flag set. Extending consistent C, C++, and linker-flag propagation across those adapters remains part of the optimization work.
-
-## Current Default Configuration
-
-The authoritative values are in `config/env.ini`. The following tables explain the current v3 defaults rather than replacing that file.
-
-### Linux Compiler Defaults
-
-These compiler defaults apply to the Linux targets above. The v3 toolchain manager selects Zig unless a maintainer-level `SPC_TOOLCHAIN` override is used.
-
-| Variable | Current default | Purpose |
-|---|---|---|
-| `SPC_DEFAULT_CFLAGS` | `-fPIC -O3 -pipe -fno-plt -fno-semantic-interposition -fstack-clash-protection -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -ffunction-sections -fdata-sections` | Common C flags for libraries and PHP |
-| `SPC_DEFAULT_CXXFLAGS` | `${SPC_DEFAULT_CFLAGS}` | Common C++ flags |
-| `SPC_DEFAULT_LDFLAGS` | `-Wl,-z,relro -Wl,--as-needed -Wl,-z,now -Wl,-z,noexecstack -Wl,--gc-sections` | Link hardening, dependency pruning, and unused-section removal |
-| `SPC_CMD_VAR_PHP_MAKE_EXTRA_CFLAGS` | `-g -fstack-protector-strong -fno-ident -fPIE -fvisibility=hidden -fvisibility-inlines-hidden ${SPC_DEFAULT_CFLAGS}` | PHP and in-tree extension C flags |
-| `SPC_CMD_VAR_PHP_MAKE_EXTRA_CXXFLAGS` | The corresponding C++ form | PHP and in-tree extension C++ flags |
-| `SPC_CMD_VAR_PHP_MAKE_EXTRA_LDFLAGS` | Empty | Additional PHP program linker flags |
-
-The important performance-related defaults are:
-
-- `-O3` favors runtime speed over compilation time and code size.
-- `-fno-semantic-interposition` gives the optimizer more freedom for ELF symbols that cannot be interposed in the final program.
-- `-fno-plt` avoids the traditional ELF procedure linkage table sequence where the toolchain can do so.
-- `-ffunction-sections -fdata-sections` combined with `--gc-sections` lets the linker remove unused functions and data.
-- Frame pointers and `-g` are deliberately retained during compilation for profiling and debugging. The deployed Unix binary is stripped by default, while separate debug information is written under `buildroot/debug/`.
-
-The default PHP configure command also enables `--enable-re2c-cgoto`, disables unused SAPIs and shared PHP libraries, and builds only the requested extensions. These choices reduce unnecessary code; their runtime effect remains workload-dependent.
-
-### macOS
-
-macOS uses the native target and system Clang by default. v3 also supports the newer upstream LLVM distributions from Homebrew and MacPorts through `SPC_USE_LLVM=brew` and `SPC_USE_LLVM=port`. The Homebrew variant selects its `clang`, `clang++`, `llvm-ar`, and `llvm-ranlib` as one coherent toolchain rather than mixing them with the Apple-provided tools.
-
-Homebrew LLVM is one of StaticPHP's current macOS performance paths. Its newer optimizer and code-generation backend can produce faster PHP binaries for some PHP versions and workloads, while also allowing the project to evaluate compiler improvements without waiting for Apple's system Clang release cycle. This is not a guaranteed uplift: PHP VM changes, CPU architecture, extensions, Opcache, and compiler flags can change the result. The project's [performance testing issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838) shows that compiler and optimization-level effects are version- and workload-specific, while the later [v3 toolchain discussion](https://github.com/crazywhalecc/static-php-cli/issues/985#issuecomment-3860775962) records access to an up-to-date compiler as the motivation for the additional macOS LLVM path.
-
-| Variable | Current default | Purpose |
-|---|---|---|
-| `SPC_DEFAULT_CFLAGS` | `--target=${MAC_ARCH}-apple-darwin -O3 -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -ffunction-sections -fdata-sections` | Target selection, optimization, observability, and section splitting |
-| `SPC_DEFAULT_CXXFLAGS` | `${SPC_DEFAULT_CFLAGS}` | Common C++ flags |
-| `SPC_DEFAULT_LDFLAGS` | `-Wl,-dead_strip` | Removes unreachable Mach-O code and data |
-| PHP extra flags | `-g`, stack protection, PIC/PIE, hidden visibility, and the defaults above | PHP and in-tree extension compilation |
-
-### Windows
-
-Windows uses MSVC and the static CRT patches described in [PHP Source Modifications](./php-src-changes). PHP's release configuration supplies its upstream optimization flags, while StaticPHP rewrites the final CLI, CGI, micro, and embed link rules to include `/LTCG`. Dependency CMake builds commonly use `/MT /Os /Ob1 /DNDEBUG`; individual packages may choose other release flags.
-
-`--no-strip` preserves PDB/debug information while keeping `/O2` optimization in StaticPHP's rewritten build command. This is intentional: debug symbols and disabled optimization are separate concerns.
-
-Windows FrankenPHP uses Clang/LLD for the CGO link. Some Windows libraries explicitly avoid `/GL` because MSVC LTCG objects are not accepted by this link path. `/LTCG` on the final link line therefore does not mean every input participates in whole-program optimization.
-
-## Optimization Dimensions
-
-StaticPHP treats performance as several related metrics rather than one score. Each dimension is affected by a different part of the build:
-
-| Goal | Usually measured as | Main influencing controls |
-|---|---|---|
-| Request throughput | requests/s at fixed concurrency | SAPI mode, Opcache, worker model, PHP version, compiler and CPU target |
-| Tail latency | p50/p95/p99 and error rate | workload, warmup, contention, worker count, JIT/Opcache, memory pressure |
-| CLI execution | wall time, CPU time, peak RSS | startup cost, Opcache CLI setting, extension set, PHP/compiler version |
-| Binary size | deployed bytes and debug-file bytes | extension set, section GC/dead stripping, symbol stripping, UPX |
-| Portability | oldest CPU/OS/libc that runs the binary | `SPC_TARGET`, CPU ISA flags, static versus dynamic libc |
-| Build speed | clean build wall time and peak disk/RAM | `SPC_CONCURRENCY`, toolchain, LTO/PGO, number of packages |
-
-Comparable results keep the PHP version, commit, extensions, dependency versions, SAPI, ZTS/NTS mode, INI, target libc, compiler, CPU frequency policy, and workload constant.
-
-## Runtime Optimization Surfaces
-
-### 1. Reproducible Configuration Overrides
-
-`config/env.custom.ini` provides the reproducible override layer while leaving `config/env.ini` as the project baseline. Values replace the complete default string rather than being appended automatically, so performance investigations preserve the baseline and isolate one changed factor.
-
-For example, an x86-64-v3-specific investigation retains the Linux defaults and adds the ISA level:
-
-```ini
-[linux]
-SPC_DEFAULT_CFLAGS="-fPIC -O3 -pipe -fno-plt -fno-semantic-interposition -fstack-clash-protection -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -ffunction-sections -fdata-sections -march=x86-64-v3"
-SPC_DEFAULT_CXXFLAGS="${SPC_DEFAULT_CFLAGS}"
-```
-
-This may allow more vector and instruction selection, but the output no longer runs on CPUs below that ISA level. `-march=native` narrows portability further by coupling the result to the build host's CPU class.
-
-PHP-only investigations are represented by `SPC_CMD_VAR_PHP_MAKE_EXTRA_CFLAGS` and its C++ counterpart rather than the global defaults. Individual-package investigations use snake-case variables such as `libaom_CFLAGS`, `libaom_CXXFLAGS`, and `libaom_LDFLAGS`. Package-specific flags are combined with the defaults when that package uses the common v3 executors.
-
-### 2. Toolchain and PHP-Version Effects
-
-The compiler can matter more than an individual optimization flag. [Issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838) found large GCC-versus-Clang differences for some PHP 8.4 x86-64 tests because PHP's older VM can use GCC global register variables. That result is not universal: architecture, PHP version, VM implementation, and workload all matter, and PHP 8.5 changes the comparison with its newer VM.
-
-Linux v3 defaults to Zig for target flexibility and reproducible libc selection, not because it is guaranteed to produce the fastest binary for every workload. The project's performance work compares this predictable baseline with native toolchains on deployment architectures. `SPC_TOOLCHAIN` remains an internal/maintainer control until a stable user-facing selector is documented.
-
-### 3. SAPI, Thread Safety, and Runtime Settings
-
-- FrankenPHP requires ZTS. CLI, FPM, CGI, micro, and embed remain NTS by default unless the selected SAPI or application requires thread safety.
-- Historical tests in issue #838 observed small ZTS/NTS differences in that particular suite; the result remains specific to that workload.
-- Including `ext-opcache` only builds the extension. Its performance characteristics also depend on runtime INI, including `opcache.enable_cli` for repeated CLI execution and application-specific JIT settings.
-- `--disable-opcache-jit` changes build capability; it is not a substitute for runtime benchmarking. StaticPHP disables the undefined-behavior sanitizer where necessary when Opcache JIT is built on Linux.
-- FrankenPHP performance also depends on worker versus classic mode, worker count, application boot behavior, Caddy modules, and Go runtime settings. Compiler flags cannot compensate for an unrepresentative server configuration.
-
-### 4. Speed, Symbols, and Compression
-
-The default Unix deployment extracts debug information, strips the runtime binary, and keeps the debug file separately. `--no-strip` represents the unstripped variant while current v3 keeps optimization enabled.
-
-`--with-upx-pack` is a size optimization for Linux and Windows. It can change startup time, memory mapping, security-tool behavior, and debuggability, so the project treats it as a packaging tradeoff rather than a PHP execution optimization.
-
-## Profile-Guided Optimization (PGO)
-
-PGO builds an instrumented program, runs a representative workload to collect profiles, and recompiles using the observed branch, call, and value frequencies. The compiler can then improve code layout, inlining, and hot/cold decisions beyond static heuristics.
-
-A complete PGO design contains three distinct phases:
-
-1. **Instrumentation** builds the same PHP version, SAPI, extensions, dependencies, and target with profile-generation flags.
-2. **Training** covers startup and important production paths at representative traffic mixes and concurrency, including a clean shutdown so raw profiles are flushed.
-3. **Profile use** merges the raw profiles with the matching toolchain utility and rebuilds the identical source/configuration with profile-use flags.
-
-Profiles are inputs to the build, not portable benchmark artifacts. Meaningful changes to PHP, extensions, dependencies, compiler version, flags, SAPI linkage, or workload invalidate them. A narrow or stale profile can improve the trained route while making untrained behavior worse.
-
-### StaticPHP PGO Status
-
-The experimental v3 design explores a dedicated PGO context and lifecycle hooks for CLI, CGI, FPM, micro, embed, and FrankenPHP. The concepts under evaluation include:
-
-- instrument and profile-use phases, plus an optional context-sensitive second instrumentation phase;
-- per-SAPI raw-profile directories and merged `.profdata` files;
-- clean rebuilds when switching the active SAPI profile;
-- shutdown patches for php-src and FrankenPHP, because the Go/CGO process does not reliably run the libc `atexit` path that normally flushes profiles;
-- LLVM profile tooling and special linker/runtime handling for Zig, Clang, GCC, and FrankenPHP.
-
-This work is not part of the stable v3 feature set. The current v3 tree contains some preparatory compatibility handling—for example, FrankenPHP detects manual `-fprofile*` C flags when using native GCC, suppresses missing-profile errors, and links `libgcov`—but complete training, merging, invalidation, and rebuilding orchestration remains under investigation.
-
-A raw `-fprofile-generate` addition to the global defaults is not equivalent to this orchestration: it also instruments dependency libraries, changes link requirements, increases build and runtime cost, and may fail to flush usable data. For that reason, the current internal variables do not yet constitute a stable release workflow.
-
-### FrankenPHP's Go PGO
-
-[PR #1142](https://github.com/crazywhalecc/static-php-cli/pull/1142) added FrankenPHP's upstream `default.pgo` to the v2 xcaddy build when present. That profile optimizes the Go portion using a profile distributed with FrankenPHP. It does not train php-src, the PHP embed library, extensions, or CGO glue against your application.
-
-A future end-to-end FrankenPHP PGO design may therefore contain two profile sources:
-
-- FrankenPHP's upstream Go profile for the Go/Caddy code;
-- application-specific compiler profiles for PHP, static extensions, and CGO-linked C code.
-
-Their ownership and invalidation rules are separate concerns in the current design exploration.
-
-## Link-Time Optimization (LTO)
-
-LTO retains compiler intermediate representation until link time so the optimizer can work across translation units. Full LTO processes the combined program more aggressively; ThinLTO distributes more work and usually reduces memory and build-time cost.
-
-Static linking does not automatically enable LTO. Conversely, adding `-flto` to only the final link is insufficient: relevant objects and archives must be produced with a compatible compiler, LTO mode, archiver, ranlib, and linker plugin.
-
-Unix v3 does not enable LTO by default. Historical work made more archive commands respect the selected `AR`, but the project later removed default LTO work because compatibility fixes across dependency libraries were costly. In [issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838), one test environment observed only about 2% runtime improvement while ThinLTO roughly doubled build time and full LTO increased it by about seven times. These are historical measurements on one setup, not a promised ratio.
-
-Current Unix LTO investigations account for the following constraints:
-
-1. Objects, archives, and the final link need one compatible LLVM/Clang or GCC toolchain family.
-2. C, C++, PHP, and linker flags need the same mode, such as `-flto=thin`.
-3. Limiting the initial scope to PHP and its in-tree extensions separates core results from dependency-library compatibility.
-4. Archive contents and the final link log reveal whether LTO reached the intended objects; build completion alone does not.
-5. SAPI and extension smoke tests, clean build time, binary size, throughput, and tail latency together describe the result.
-
-LTO can expose package bugs, unsupported assembly, incompatible archives, symbol-export problems, and Go/CGO linker limitations. It can also increase code size or regress instruction-cache behavior. These compatibility and maintenance costs are why Unix LTO remains opt-in while its benefits continue to be evaluated.
-
-## Performance Evidence and Reproducibility
-
-StaticPHP performance investigations record enough context for another maintainer to reproduce the result:
-
-- StaticPHP commit and registry/package revisions;
-- PHP, FrankenPHP, Go, compiler, linker, and profile-tool versions;
-- host and target OS, libc, architecture, and exact `SPC_TARGET`;
-- CPU model, available instruction set, power/frequency policy, memory, and virtualization;
-- complete extension and dependency set, ZTS/NTS, SAPI, static/dynamic linkage, and INI;
-- all overridden environment variables and whether the binary was stripped or UPX-packed;
-- workload source revision, dataset, route mix, concurrency, duration, warmup, and repetitions;
-- median result, variation, p95/p99 where relevant, peak RSS, binary size, and clean build time.
-
-The project alternates a baseline and one changed build on the same machine. Multiple repetitions and confidence intervals carry more weight than a single best run, and benchmark scripts remain part of the result alongside the raw measurements.
-
-## History and Design Lessons
-
-The following merged changes and issue discussions explain why the current defaults and cautions exist. Unmerged implementation work is represented only by its technical concepts elsewhere on this page.
-
-| Record | Outcome and lesson |
-|---|---|
-| [Issue #385](https://github.com/crazywhalecc/static-php-cli/issues/385), performance degradation | A v2 `--no-strip` path also selected `-O0`, making one reported Laravel test about three times slower. This led to customizable PHP compiler variables and reinforced that debug symbols must not silently disable optimization. Current v3 keeps optimized flags with `--no-strip`. |
-| [PR #806](https://github.com/crazywhalecc/static-php-cli/pull/806), Zig toolchain | Added target-flexible Zig support and documented its build/compatibility tradeoffs. Its discussion also contains the static/dynamic within-1% observation and early GCC/Clang/Zig comparisons. Toolchain choice is partly about portability and libc targeting, not only benchmark speed. |
-| [Issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838), performance testing | Established reproducible compiler, ZTS/NTS, Opcache, LTO, architecture, and PHP VM comparisons. Its results provide background for the `-O3` defaults but also show why conclusions must remain version- and workload-specific. The issue remains the main historical performance notebook. |
-| [Issue #985](https://github.com/crazywhalecc/static-php-cli/issues/985), v3 toolchains | Recorded the decision to prefer predictable defaults while retaining performance-oriented alternatives. On Linux this means Zig alongside native GCC paths; on macOS the discussion also motivated access to a current upstream LLVM instead of being limited to Apple's compiler release cycle. |
-| [Issue #862](https://github.com/crazywhalecc/static-php-cli/issues/862), `--pgo=script.php` proposal | Closed after concluding that one universal training script interface was unrealistic. PGO needs SAPI-aware lifecycle orchestration and user-owned representative training. |
-| [PR #966](https://github.com/crazywhalecc/static-php-cli/pull/966), flags and stripping | Unified PHP make flags and improved separate debug stripping, helping decouple optimization from symbol handling. |
-| [PR #1142](https://github.com/crazywhalecc/static-php-cli/pull/1142), FrankenPHP Go PGO | Added use of FrankenPHP's bundled Go `default.pgo` in the v2 build. This is distinct from application-trained PHP/CGO PGO. |
-| [Issue #1088](https://github.com/crazywhalecc/static-php-cli/issues/1088), native intrinsics | Open design request for declaring CPU intrinsic levels across both libraries and PHP/extensions instead of managing every ISA flag manually. |
-| [PR #1150](https://github.com/crazywhalecc/static-php-cli/pull/1150), macOS `-fno-plt` | Removed an ELF-only flag from the macOS defaults after it broke dependency configure checks. Optimization flags must be target-format aware. |
-
-Most of this investigation and implementation has been led by [@henderkes](https://github.com/henderkes), with reviews, integration, platform fixes, and testing from the other StaticPHP contributors. The project continues to preserve workloads, raw results, and rationale as this work evolves; an individual compiler flag is only the last line of a much broader performance decision.

docs/zh/develop/performance.md

@@ -1,301 +0,0 @@
-# 性能工程
-
-StaticPHP 控制 PHP、扩展、依赖库以及各个 SAPI 的编译方式。这些选择会影响运行时吞吐量与延迟、启动时间、内存占用、二进制体积、可移植性和构建时间。不过它们并不是同一个指标：更小的二进制不一定更快，更慢的构建过程也可能生成更快的程序。
-
-本页记录当前 v3 的默认值、已经进入构建流程的优化，以及仍在探索的方向。在 Linux 上，libc 和链接模型构成第一层：默认的 musl 全静态构建与 glibc 动态构建在可移植性、扩展加载和性能方面具有不同特征；编译参数、PGO 和 LTO 则是这项持续优化工作的后续层次。
-
-本页并不宣称 StaticPHP 二进制在所有情况下都比其他 PHP 发行方式更快。结果取决于 PHP 版本、CPU、工具链、扩展集合、SAPI、libc、链接方式、运行时配置和实际负载。
-
-::: warning 当前 v3 状态
-v3 分支目前没有提供稳定的 `--pgi`、`--pgo` 或 `--lto` CLI 选项。PGO 编排和更广泛的 LTO 兼容性仍处于持续探索阶段。下文描述的是设计、当前约束和优化方向，而不是受支持的正式版本构建方法。
-:::
-
-## Linux 链接方式与 libc
-
-StaticPHP 的 Linux 默认配置优先保证产物自包含，并不追求在所有服务器负载中获得最高分。`config/env.ini` 默认选择 `${GNU_ARCH}-linux-musl`；配合默认 Zig 工具链，会生成完全静态链接 musl 的二进制。
-
-当前性能研究会区分以下三个 Linux target：
-
-| Target | libc 与最终链接方式 | 运行时要求 | 共享扩展 / FFI | 当前定位 |
-|---|---|---|---|---|
-| `native-native-musl` | musl，全静态 | 兼容 CPU 上的 Linux 内核 | 不支持 | 默认的可移植单文件发布 |
-| `native-native-musl -dynamic` | musl，动态链接 | 兼容的 musl loader 和库 | 支持 | 保持 musl 不变，隔离静态/动态链接影响 |
-| `native-native-gnu.2.17` | glibc，动态链接，以 2.17 为基线 | glibc 2.17 或更高版本 | 支持 | 广泛兼容 GNU/Linux，并作为 glibc 性能基线 |
-
-可以用具体架构替换任一 `native`，例如 `x86_64-linux-musl`。不指定版本的 `-gnu` target 会面向所选/当前 glibc ABI，而不是承诺兼容 glibc 2.17。
-
-这里的“动态链接 PHP”并不意味着每个依赖都是系统 `.so`。StaticPHP 仍会把大多数选中的第三方库和 PHP 扩展构建为静态 archive，并链接进 PHP 可执行文件。动态部分主要是 libc/runtime loader，以及通过 `--build-shared` 明确选择的扩展。这与 PHP 和许多依赖都作为独立共享对象提供的传统发行版 PHP 不同。
-
-同样，“静态扩展”和“静态 libc”是两个独立选择。glibc 动态 PHP 可以把所有 PHP 扩展静态编入，musl 动态 PHP 也可以加载指定的 `.so` 扩展。只有 musl 全静态 target 因进程中不存在动态 loader 而无法在运行时加载扩展。
-
-### 静态与动态链接改变了什么
-
-静态和动态链接主要改变启动工作、重定位、符号解析、部署方式和库共享，并不会自动改变 PHP VM 的代码生成方式。
-
-- 全静态进程不会通过 runtime dynamic loader 启动，也不需要重定位一组 DSO。这可能有利于极短 CLI 的启动，但 PHP 初始化、扩展启动、脚本解析和 Opcache 往往占据更多时间。
-- 动态进程需要在启动时支付 loader 和 relocation 成本。长时间运行的 FPM 或 FrankenPHP worker 会把这部分成本分摊到许多请求上。
-- 静态链接为 section garbage collection 以及显式启用的 LTO 提供了更完整的 closed world；但静态链接本身不会进行跨 object 优化。
-- glibc 动态构建支持共享扩展、FFI、NSS 集成，并允许在不重建 PHP 的情况下替换或安全更新运行时库。全静态产物则必须重建才能获得 libc 或内嵌依赖修复。
-- 不同程序可以复用共享库的代码页；相同的静态 PHP worker 进程之间也会共享文件映射的可执行代码页，因此“静态链接会让每个 worker 在内存里复制所有代码”并不准确。
-
-StaticPHP 的[性能测试 Issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838) 记录过一组 PHP 8.4 测试：多次运行时，静态和动态构建在两个方向上的差异都不超过约 1%。这说明仅链接方式未必会主导 PHP 稳态执行性能，但不能把它当作普遍结论。短 CLI、大量 DSO、不同 loader 以及 I/O 密集扩展都可能得到不同结果。
-
-### musl 与 glibc 的性能影响面
-
-只有负载实际进入 libc 或围绕 libc 实现的功能时，两者差异才会出现。纯 PHP 代码的大量时间会花在 Zend VM、Opcache 和 Zend Memory Manager 中。PHP 自己的 [Zend Memory Manager](https://wiki.php.net/internals/zend_mm) 处理大多数 request-bound allocation，因此以 PHP array 和 opcode 为主的 microbenchmark，对系统 allocator 的敏感度可能低于 C 扩展或服务器 runtime。
-
-| 负载领域 | libc 可能产生影响的原因 | 主要观测项 |
-|---|---|---|
-| CPU 密集 PHP opcode | 通常由 PHP VM、编译器、CPU target 和 Opcache 主导，而不是 libc | 先保持 PHP/VM/编译器一致，再只改变 libc/链接方式 |
-| 持久及原生内存分配 | PHP persistent allocation、C 扩展、依赖库和服务器代码可能直接调用 libc allocator | 吞吐量、allocation contention、RSS、长时间运行后的 fragmentation |
-| ZTS 与 FrankenPHP | 线程创建、TLS、mutex、allocator contention 和 per-thread cache 存在差异 | 随 worker/thread 数量的扩展性、p95/p99、每线程 RSS |
-| DNS 与名称服务 | resolver 策略、NSS、`/etc/resolv.conf` 和缓存不同 | 有/无缓存的查询延迟、失败/切换延迟、查询量 |
-| Locale、iconv、regex、stdio | 实现和支持行为不同，不只是速度不同 | 先验证正确性，再用生产 locale/数据测试吞吐量 |
-| 极短 CLI 命令 | loader/relocation 和初始化占总时间的比例更大 | 大量进程启动的 cold/warm wall time |
-| 长时间运行的 worker | 启动成本被分摊，allocator、线程、系统调用和应用行为更加重要 | 持续吞吐量、尾延迟、峰值/稳定 RSS |
-
-glibc allocator 提供 per-thread cache 和多个 arena，并允许调整其上限；这可能提高并发分配吞吐量，但代价是保留更多内存。因此，StaticPHP 的基准记录会包含 [glibc allocation tunable](https://sourceware.org/glibc/manual/latest/html_node/Memory-Allocation-Tunables.html)。musl 使用不同的 allocator，更关注较低基线开销、受控 fragmentation 及静态链接适用性；两种设计都不能保证在所有 PHP 应用中具有更低延迟或 RSS。
-
-Resolver 行为甚至可能反转一个表面上的“libc 性能”结果。[musl 功能差异文档](https://wiki.musl-libc.org/functional-differences-from-glibc.html)指出，musl 会并行查询配置的 nameserver，而传统 glibc 行为会依次尝试。这可能改善故障切换延迟，也可能增加 DNS 流量；glibc 还会参与可配置的 NSS module。因此，StaticPHP 的 DNS 对比会保持 resolver、缓存状态、search domain 和失败条件一致，而不会把 resolver 结果当作单纯 CPU benchmark。
-
-musl 的默认线程栈明显小于典型 glibc 配置。这可以减少线程密集程序保留的地址空间，也可能暴露扩展对栈大小的假设。它属于部署和内存特征，不能证明某个 libc 执行 PHP opcode 更快。
-
-### 当前对比模型
-
-默认 musl 静态二进制与发行版 glibc PHP 的直接对比会同时改变 libc、linker、编译器、参数、PHP 配置、扩展、依赖版本和 INI，因此无法把全部差异归因于 libc。
-
-项目采用相同 StaticPHP commit、PHP 源码、Zig 版本、参数、扩展和 SAPI 形成受控矩阵。三个构建对应以下命令：
-
-```bash
-EXTENSIONS="bcmath,curl,openssl,opcache"
-
-# A：默认形式的 musl 全静态构建
-SPC_TARGET=native-native-musl spc build:php "$EXTENSIONS" --build-cli
-
-# B：musl 动态构建，需要 musl runtime
-SPC_TARGET="native-native-musl -dynamic" spc build:php "$EXTENSIONS" --build-cli
-
-# C：glibc 动态构建，并指定兼容性下限
-SPC_TARGET=native-native-gnu.2.17 spc build:php "$EXTENSIONS" --build-cli
-```
-
-每项结果都与其产物、build manifest、`php -i` 和日志一起保存。实际链接方式由二进制本身确认，而不是根据文件名推断：
-
-```bash
-file buildroot/bin/php
-readelf -l buildroot/bin/php | grep 'Requesting program interpreter'
-```
-
-A 对比 B 用于在保持 musl 不变时估计链接方式的影响；B 对比 C 用于在两者均动态链接时估计 libc/runtime 的影响。发行版 PHP 仍可作为外部参考，但由于编译器和打包配置不同，会单独记录。
-
-当前对比集合同时覆盖 no-op 启动和实际 CLI 脚本。FPM 与 FrankenPHP 会把 worker 预热和持续吞吐量、尾延迟分开记录。libc 敏感场景则包括使用扩展的大量内存分配、并发请求、DNS cache hit/miss/failure、文件 I/O，以及长时间运行后的 RSS/fragmentation。
-
-### 部署特征
-
-- **musl 静态**是 StaticPHP 默认值，代表不依赖共享扩展或 FFI 的可移植、自包含部署形态。
-- **glibc 动态**代表与 GNU/Linux runtime 集成的部署形态，包括 `.so` 扩展、FFI、宿主名称服务栈，以及实测更适合 glibc 的负载。
-- **musl 动态**代表仍需要共享扩展的 musl runtime，同时也是上述受控对比的中间项；它会放弃默认构建的大部分单文件可移植性。
-
-默认值以可预测和广泛部署为目标。最快 target 与具体负载相关，项目仍在结合实际 CPU、PHP 版本、SAPI 和应用行为持续评估。
-
-## 优化配置如何进入 v3 构建
-
-v3 会通过多个层次传递优化配置：
-
-1. `config/env.ini` 提供各平台默认值；`config/env.custom.ini` 或进程环境变量可以覆盖它们。
-2. `ToolchainManager` 默认在 Linux 选择 Zig、Windows 选择 MSVC、macOS 选择系统/Homebrew/MacPorts Clang，并初始化 `CC`、`CXX`、`AR`、`RANLIB` 和 `LD`。
-3. Package executor 和 `Package::getLibExtra*Flags()` 把默认参数传入 Autoconf、CMake 及包专用构建过程。
-4. Unix 上的 PHP target 会把 PHP 专用参数同时传给 `./configure` 和 `make`。作为 php-src 一部分编译的静态扩展会看到相同的编译环境。
-5. FrankenPHP target 通过 CGO 链接 PHP embed 库。它的 `CGO_CFLAGS` 和 `CGO_LDFLAGS` 会包含 PHP 与依赖库参数，再加入 Go 和外部链接器配置。
-6. 部署阶段默认提取单独的调试信息并精简 Unix 二进制。UPX 是可选项，它影响体积和启动行为，而不会优化生成的 PHP 机器码。
-
-这种传递有意覆盖较大范围，但目前还不是完全一致。使用手写编译命令或特殊上游构建系统的包可能忽略部分全局参数。让这些 adapter 一致传递 C、C++ 和 linker 参数，仍是当前优化工作的组成部分。
-
-## 当前默认配置
-
-权威值位于 `config/env.ini`。下面的表格用于解释当前 v3 默认值，不能替代该文件。
-
-### Linux 编译器默认值
-
-这些编译器默认值适用于上文各 Linux target。除非使用维护者级别的 `SPC_TOOLCHAIN` 覆盖项，否则 v3 toolchain manager 会选择 Zig。
-
-| 变量 | 当前默认值 | 用途 |
-|---|---|---|
-| `SPC_DEFAULT_CFLAGS` | `-fPIC -O3 -pipe -fno-plt -fno-semantic-interposition -fstack-clash-protection -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -ffunction-sections -fdata-sections` | 依赖库和 PHP 共用的 C 参数 |
-| `SPC_DEFAULT_CXXFLAGS` | `${SPC_DEFAULT_CFLAGS}` | 共用 C++ 参数 |
-| `SPC_DEFAULT_LDFLAGS` | `-Wl,-z,relro -Wl,--as-needed -Wl,-z,now -Wl,-z,noexecstack -Wl,--gc-sections` | 链接加固、依赖裁剪及未使用 section 移除 |
-| `SPC_CMD_VAR_PHP_MAKE_EXTRA_CFLAGS` | `-g -fstack-protector-strong -fno-ident -fPIE -fvisibility=hidden -fvisibility-inlines-hidden ${SPC_DEFAULT_CFLAGS}` | PHP 和源码树内扩展的 C 参数 |
-| `SPC_CMD_VAR_PHP_MAKE_EXTRA_CXXFLAGS` | 对应的 C++ 形式 | PHP 和源码树内扩展的 C++ 参数 |
-| `SPC_CMD_VAR_PHP_MAKE_EXTRA_LDFLAGS` | 空 | PHP 程序的附加链接参数 |
-
-其中与性能最相关的默认项是：
-
-- `-O3` 偏向运行速度，而不是编译时间和代码体积。
-- `-fno-semantic-interposition` 让优化器能够更自由地处理最终程序中不会被 interpose 的 ELF 符号。
-- `-fno-plt` 在工具链允许时避免传统的 ELF procedure linkage table 调用序列。
-- `-ffunction-sections -fdata-sections` 配合 `--gc-sections`，使链接器可以移除未使用的函数和数据。
-- 编译阶段有意保留 frame pointer 和 `-g`，方便性能分析和调试。部署 Unix 二进制时默认会执行 strip，同时把独立调试信息写入 `buildroot/debug/`。
-
-默认 PHP configure 命令还会启用 `--enable-re2c-cgoto`、禁用未选择的 SAPI 和共享 PHP 库，并只构建请求的扩展。这些选择能减少无关代码，实际运行效果仍取决于具体负载。
-
-### macOS
-
-macOS 默认使用 native target 和系统 Clang。v3 也通过 `SPC_USE_LLVM=brew` 和 `SPC_USE_LLVM=port` 支持 Homebrew、MacPorts 提供的较新 upstream LLVM。Homebrew 变体会把其中的 `clang`、`clang++`、`llvm-ar` 和 `llvm-ranlib` 作为一套完整工具链使用，避免与 Apple 自带工具混用。
-
-Homebrew LLVM 是 StaticPHP 当前在 macOS 上采用的性能优化路径之一。较新的 optimizer 和 code-generation backend 在部分 PHP 版本及负载中可以生成运行性能更好的 PHP 二进制，也让项目不必等待 Apple 系统 Clang 的发布节奏即可评估新的编译器优化。这并不是固定的性能保证：PHP VM 变化、CPU 架构、扩展、Opcache 和编译参数都会改变结果。项目的[性能测试 Issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838)表明编译器及优化等级的影响与版本和负载相关，后续的 [v3 工具链讨论](https://github.com/crazywhalecc/static-php-cli/issues/985#issuecomment-3860775962)则记录了增加 macOS LLVM 路径的动机，即获得不受 Apple 编译器版本限制的较新工具链。
-
-| 变量 | 当前默认值 | 用途 |
-|---|---|---|
-| `SPC_DEFAULT_CFLAGS` | `--target=${MAC_ARCH}-apple-darwin -O3 -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -ffunction-sections -fdata-sections` | 目标选择、优化、可观测性及 section 拆分 |
-| `SPC_DEFAULT_CXXFLAGS` | `${SPC_DEFAULT_CFLAGS}` | 共用 C++ 参数 |
-| `SPC_DEFAULT_LDFLAGS` | `-Wl,-dead_strip` | 移除不可达的 Mach-O 代码和数据 |
-| PHP 附加参数 | `-g`、stack protection、PIC/PIE、hidden visibility 以及上述默认项 | PHP 和源码树内扩展编译 |
-
-### Windows
-
-Windows 使用 MSVC，以及[对 PHP 源码的修改](./php-src-changes)中介绍的静态 CRT 补丁。PHP release 配置提供上游优化参数，StaticPHP 会改写最终 CLI、CGI、micro 和 embed 的链接规则并加入 `/LTCG`。依赖的 CMake 构建通常使用 `/MT /Os /Ob1 /DNDEBUG`，个别 Package 可能选择其他 release 参数。
-
-使用 `--no-strip` 时，StaticPHP 会保留 PDB/调试信息，同时在改写的构建命令中继续使用 `/O2`。这是有意设计：调试符号与关闭优化是两件不同的事。
-
-Windows FrankenPHP 通过 Clang/LLD 完成 CGO 链接。部分 Windows 库会明确禁用 `/GL`，因为该链接路径无法接受 MSVC LTCG object。最终链接行出现 `/LTCG`，并不意味着每个输入都参与了 whole-program optimization。
-
-## 优化维度
-
-StaticPHP 将性能视为多个彼此相关的指标，而不是单一分数。每个维度受到不同构建环节影响：
-
-| 目标 | 通常记录为 | 主要影响项 |
-|---|---|---|
-| 请求吞吐量 | 固定并发下的 requests/s | SAPI 模式、Opcache、worker 模型、PHP 版本、编译器和 CPU target |
-| 尾延迟 | p50/p95/p99 和错误率 | 负载、预热、竞争、worker 数量、JIT/Opcache、内存压力 |
-| CLI 执行 | wall time、CPU time、peak RSS | 启动成本、Opcache CLI 设置、扩展集合、PHP/编译器版本 |
-| 二进制体积 | 部署文件和调试文件字节数 | 扩展集合、section GC/dead stripping、符号精简、UPX |
-| 可移植性 | 能运行该二进制的最旧 CPU/OS/libc | `SPC_TARGET`、CPU ISA 参数、静态或动态 libc |
-| 构建速度 | 干净构建 wall time、峰值磁盘和内存 | `SPC_CONCURRENCY`、工具链、LTO/PGO、Package 数量 |
-
-可比较的结果会保持 PHP 版本、commit、扩展、依赖版本、SAPI、ZTS/NTS、INI、目标 libc、编译器、CPU 频率策略及负载一致。
-
-## 运行时优化层面
-
-### 1. 可复现的配置覆盖
-
-`config/env.custom.ini` 提供可复现的覆盖层，同时让 `config/env.ini` 保持为项目基线。配置值会替换完整默认字符串而不会自动追加，因此性能研究会保留基线，并一次隔离一个变化因素。
-
-例如，面向 x86-64-v3 的研究会保留 Linux 默认值并加入对应 ISA level：
-
-```ini
-[linux]
-SPC_DEFAULT_CFLAGS="-fPIC -O3 -pipe -fno-plt -fno-semantic-interposition -fstack-clash-protection -fno-omit-frame-pointer -mno-omit-leaf-frame-pointer -ffunction-sections -fdata-sections -march=x86-64-v3"
-SPC_DEFAULT_CXXFLAGS="${SPC_DEFAULT_CFLAGS}"
-```
-
-这可能让编译器使用更多向量和指令选择，但产物无法在低于该 ISA level 的 CPU 上运行。`-march=native` 会进一步收窄可移植性，使产物与构建机的 CPU 类型绑定。
-
-PHP 范围的研究由 `SPC_CMD_VAR_PHP_MAKE_EXTRA_CFLAGS` 及其 C++ 对应项表示，而不是改变全局默认值。单个 Package 的研究使用 snake-case 变量，例如 `libaom_CFLAGS`、`libaom_CXXFLAGS` 和 `libaom_LDFLAGS`。当 Package 使用 v3 通用 executor 时，Package 专用参数会与默认参数合并。
-
-### 2. 工具链和 PHP 版本的影响
-
-编译器造成的差异可能大于单个优化参数。[Issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838) 在部分 PHP 8.4 x86-64 测试中发现 GCC 与 Clang 之间有较大差异，因为较旧的 PHP VM 可以使用 GCC global register variable。该结果并不普遍适用：架构、PHP 版本、VM 实现和负载都会影响结论，PHP 8.5 的新 VM 也改变了这项比较。
-
-Linux v3 默认使用 Zig，是为了 target 灵活性和可复现的 libc 选择，并不代表它在所有负载下都一定生成最快的二进制。项目的性能工作会在实际部署架构上对比这个可预测基线与 native toolchain。在稳定的用户级选择器得到正式文档前，`SPC_TOOLCHAIN` 仍属于内部/维护者控制项。
-
-### 3. SAPI、线程安全及运行时配置
-
-- FrankenPHP 要求 ZTS。CLI、FPM、CGI、micro 和 embed 默认保持 NTS，只有所选 SAPI 或应用确实需要线程安全时才涉及 ZTS。
-- Issue #838 的历史测试在特定测试集中观察到的 ZTS/NTS 差异较小；该结论仍局限于当时的负载。
-- 加入 `ext-opcache` 只代表构建该扩展；它的性能特征还取决于运行时 INI，包括重复 CLI 执行中的 `opcache.enable_cli` 和应用特定的 JIT 配置。
-- `--disable-opcache-jit` 改变的是构建能力，不能代替运行时测试。在 Linux 构建 Opcache JIT 时，StaticPHP 会在必要位置禁用 undefined-behavior sanitizer。
-- FrankenPHP 性能还取决于 worker/classic 模式、worker 数量、应用启动行为、Caddy 模块及 Go runtime 设置。编译参数无法弥补不具代表性的服务器配置。
-
-### 4. 速度、符号和压缩
-
-Unix 默认部署流程会提取调试信息、精简运行时二进制，并单独保留调试文件。`--no-strip` 代表未精简形态，当前 v3 在这种形态下仍会保留优化参数。
-
-`--with-upx-pack` 是 Linux 和 Windows 的体积优化。它可能改变启动时间、内存映射、安全工具行为和可调试性，因此项目将它视为打包取舍，而不是 PHP 执行性能优化。
-
-## Profile-Guided Optimization（PGO）
-
-PGO 会先生成插桩程序，运行具有代表性的负载收集 profile，然后根据观察到的分支、调用和值频率重新编译。这样，编译器能够在代码布局、inline 和 hot/cold 决策方面超越静态启发式规则。
-
-完整的 PGO 设计包含三个独立阶段：
-
-1. **插桩阶段**使用相同的 PHP 版本、SAPI、扩展、依赖和 target，并加入 profile-generation 参数完成构建。
-2. **训练阶段**以具有代表性的流量比例和并发覆盖启动及重要生产路径，也包含正常关闭进程以 flush raw profile。
-3. **Profile-use 阶段**通过匹配工具链的 profile 工具合并 raw profile，并用 profile-use 参数重新构建完全一致的源码和配置。
-
-Profile 是构建输入，不是可移植的基准产物。PHP、扩展、依赖、编译器版本、参数、SAPI 链接方式或负载发生实质变化后，原有 profile 即会失效。范围过窄或已经过期的 profile 可能加速训练过的 route，却让未训练路径变慢。
-
-### StaticPHP PGO 状态
-
-v3 的实验性设计正在探索面向 CLI、CGI、FPM、micro、embed 和 FrankenPHP 的独立 PGO context 与 lifecycle hook。目前评估的概念包括：
-
-- 插桩和 profile-use 阶段，以及可选的第二轮 context-sensitive 插桩；
-- 每个 SAPI 独立的 raw-profile 目录和合并后的 `.profdata` 文件；
-- 切换活动 SAPI profile 时执行干净重建；
-- php-src 和 FrankenPHP 的 shutdown 补丁，因为 Go/CGO 进程不会可靠执行通常负责 flush profile 的 libc `atexit` 路径；
-- LLVM profile 工具，以及 Zig、Clang、GCC 和 FrankenPHP 所需的特殊链接/runtime 处理。
-
-这项工作尚未进入稳定的 v3 功能集。当前 v3 源码已经包含部分前置兼容处理，例如 FrankenPHP 在 native GCC 下发现手动 `-fprofile*` C 参数时，会忽略 missing-profile error 并链接 `libgcov`；完整的训练、合并、失效和重建编排仍在探索中。
-
-仅把 `-fprofile-generate` 加入全局默认值并不等同于完整编排：它还会同时插桩依赖库、改变链接要求、增加构建和运行成本，并且可能无法 flush 出可用数据。因此，当前内部变量尚不构成稳定的发布流程。
-
-### FrankenPHP 的 Go PGO
-
-[PR #1142](https://github.com/crazywhalecc/static-php-cli/pull/1142) 在 v2 xcaddy 构建中加入了对 FrankenPHP 上游 `default.pgo` 的使用。这个 profile 使用随 FrankenPHP 分发的数据优化 Go 部分；它不会针对你的应用训练 php-src、PHP embed 库、扩展或 CGO glue。
-
-未来的端到端 FrankenPHP PGO 设计可能同时包含两类 profile：
-
-- FrankenPHP 上游为 Go/Caddy 代码提供的 Go profile；
-- 针对 PHP、静态扩展和 CGO 链接 C 代码的应用专用编译器 profile。
-
-两者的归属及失效规则，是当前设计探索中彼此独立的问题。
-
-## Link-Time Optimization（LTO）
-
-LTO 会把编译器中间表示保留到链接阶段，让优化器跨 translation unit 工作。Full LTO 会更激进地处理合并后的程序；ThinLTO 会分散更多工作，通常能降低内存及构建时间成本。
-
-静态链接不会自动启用 LTO。反过来，只给最终链接加入 `-flto` 也不够：相关 object 和 archive 必须由兼容的编译器、LTO mode、archiver、ranlib 及 linker plugin 生成。
-
-Unix v3 默认不启用 LTO。历史工作让更多 archive 命令使用所选 `AR`，但项目后来移除了默认 LTO 尝试，因为跨依赖库维护兼容修复的成本过高。在 [Issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838) 的一个测试环境中，运行时提升只有约 2%，ThinLTO 构建时间约变成两倍，Full LTO 约变成七倍。这只是特定环境的历史测量结果，不是承诺的固定比例。
-
-当前 Unix LTO 研究会考虑以下约束：
-
-1. object、archive 和最终链接需要使用同一个兼容的 LLVM/Clang 或 GCC 工具链家族。
-2. C、C++、PHP 和 linker 参数需要采用相同模式，例如 `-flto=thin`。
-3. 初期只覆盖 PHP 和源码树内扩展，有助于把核心结果与依赖库兼容性分开。
-4. archive 内容和最终链接日志可以确认 LTO 是否进入预期 object；仅构建成功并不能说明这一点。
-5. SAPI 与扩展 smoke test、干净构建时间、二进制体积、吞吐量和尾延迟共同构成结果。
-
-LTO 可能暴露 Package bug、不支持的汇编、archive 不兼容、符号导出问题以及 Go/CGO 链接限制，也可能增加代码体积或造成 instruction cache 退化。这些兼容性与维护成本，是 Unix LTO 在持续评估收益期间仍保持 opt-in 的原因。
-
-## 性能证据与可复现性
-
-StaticPHP 的性能研究会记录足够的上下文，使其他维护者可以复现结果：
-
-- StaticPHP commit 以及 registry/Package revision；
-- PHP、FrankenPHP、Go、编译器、链接器和 profile 工具版本；
-- 宿主与目标 OS、libc、架构，以及完整的 `SPC_TARGET`；
-- CPU 型号、可用指令集、电源/频率策略、内存和虚拟化环境；
-- 完整扩展与依赖集合、ZTS/NTS、SAPI、静态/动态链接方式和 INI；
-- 所有覆盖的环境变量，以及二进制是否 strip 或使用 UPX；
-- 负载源码 revision、数据集、route 比例、并发、持续时间、预热和重复次数；
-- 中位数、波动范围、适用时的 p95/p99、peak RSS、二进制体积和干净构建时间。
-
-项目会在同一台机器上交替运行基线和单项改动构建。多次重复和置信区间比一次最佳结果更有意义，基准脚本也会和原始测量结果一起保留。
-
-## 历史记录与设计经验
-
-以下已合并修改和 Issue 讨论解释了当前默认值和注意事项的来源。未合并的实现工作仅以技术概念的形式出现在本文其他位置。
-
-| 记录 | 结果与经验 |
-|---|---|
-| [Issue #385](https://github.com/crazywhalecc/static-php-cli/issues/385)，性能退化 | v2 的一条 `--no-strip` 路径同时选择了 `-O0`，使报告中的一个 Laravel 测试约慢了三倍。这促成了可定制 PHP 编译变量，并再次说明调试符号不能静默关闭优化。当前 v3 的 `--no-strip` 会保留优化参数。 |
-| [PR #806](https://github.com/crazywhalecc/static-php-cli/pull/806)，Zig 工具链 | 加入 target 灵活的 Zig 支持并记录构建/兼容性取舍；讨论中还包含静态/动态差异在 1% 内的观察，以及早期 GCC/Clang/Zig 对比。工具链选择部分是为了可移植性与 libc target，而不只是基准速度。 |
-| [Issue #838](https://github.com/crazywhalecc/static-php-cli/issues/838)，性能测试 | 建立了可复现的编译器、ZTS/NTS、Opcache、LTO、架构及 PHP VM 对比。其结果为 `-O3` 默认值提供了背景，也展示了为什么结论必须绑定版本和负载。该 Issue 仍是主要的历史性能笔记。 |
-| [Issue #985](https://github.com/crazywhalecc/static-php-cli/issues/985)，v3 工具链 | 记录了优先采用可预测默认值，同时保留性能导向替代方案的决策。Linux 对应 Zig 与 native GCC 路径；macOS 的讨论也促成了较新 upstream LLVM 的接入，使构建不受 Apple 编译器发布节奏限制。 |
-| [Issue #862](https://github.com/crazywhalecc/static-php-cli/issues/862)，`--pgo=script.php` 提案 | 因一个通用训练脚本接口并不现实而关闭。PGO 需要感知 SAPI 的 lifecycle 编排，以及由用户负责的代表性训练。 |
-| [PR #966](https://github.com/crazywhalecc/static-php-cli/pull/966)，参数和 strip | 统一 PHP make 参数并改进独立调试信息精简流程，帮助解耦优化与符号处理。 |
-| [PR #1142](https://github.com/crazywhalecc/static-php-cli/pull/1142)，FrankenPHP Go PGO | 在 v2 构建中加入 FrankenPHP 自带 Go `default.pgo` 的使用；它不同于应用训练的 PHP/CGO PGO。 |
-| [Issue #1088](https://github.com/crazywhalecc/static-php-cli/issues/1088)，native intrinsic | 尚未关闭的设计需求，希望在依赖库与 PHP/扩展之间统一声明 CPU intrinsic level，而不是手工管理每一项 ISA 参数。 |
-| [PR #1150](https://github.com/crazywhalecc/static-php-cli/pull/1150)，macOS `-fno-plt` | 因一个 ELF 专用参数破坏依赖 configure 检查，将其从 macOS 默认值移除。优化参数必须感知目标文件格式。 |
-
-其中大部分调查和性能优化由 [@henderkes](https://github.com/henderkes) 主导，其他 StaticPHP 贡献者参与了 review、集成、平台修复和测试。随着这项工作继续推进，项目会保留负载、原始结果和决策理由；单个编译参数只是更广泛性能决策的最后一行。

src/Package/Artifact/meson_win.php

@@ -1,48 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Package\Artifact;
-
-use StaticPHP\Attribute\Artifact\AfterBinaryExtract;
-use StaticPHP\Exception\EnvironmentException;
-use StaticPHP\Util\FileSystem;
-
-class meson_win
-{
-    /**
-     * Meson 1.11 dropped the Windows MSI, so the artifact is the wheel, installed offline
-     * into a private venv. The venv is not just packaging hygiene: pip generates a real
-     * meson.exe launcher there, and PostgreSQL needs one because its build re-invokes meson
-     * through find_program(), which rejects non-executables like the meson.pyz zipapp.
-     */
-    #[AfterBinaryExtract('meson', ['windows-x86_64'])]
-    public function afterExtract(string $target_path): void
-    {
-        $dir = dirname($target_path);
-        $venv = "{$dir}\\venv";
-
-        // Prefer the python-win tool package (installed alongside via tools@windows),
-        // fall back to whatever Python the machine already has.
-        $candidates = ['"' . PKG_ROOT_PATH . '\python-win\tools\python.exe"', 'python', 'py -3'];
-        $python = null;
-        foreach ($candidates as $candidate) {
-            [$code] = cmd()->execWithResult("{$candidate} --version", false);
-            if ($code === 0) {
-                $python = $candidate;
-                break;
-            }
-        }
-        if ($python === null) {
-            throw new EnvironmentException('meson needs Python 3; the python-win tool package did not install and no system Python was found.');
-        }
-
-        if (is_dir($venv)) {
-            FileSystem::removeDir($venv);
-        }
-        cmd()->exec("{$python} -m venv \"{$venv}\"")
-            ->exec("\"{$venv}\\Scripts\\python.exe\" -m pip install --no-index --no-deps \"{$target_path}\"");
-
-        FileSystem::writeFile("{$dir}\\meson.bat", "@echo off\r\n\"%~dp0venv\\Scripts\\meson.exe\" %*\r\n");
-    }
-}

src/Package/Artifact/python_win.php

@@ -1,66 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Package\Artifact;
-
-use StaticPHP\Artifact\ArtifactDownloader;
-use StaticPHP\Artifact\Downloader\DownloadResult;
-use StaticPHP\Artifact\Downloader\Type\CheckUpdateResult;
-use StaticPHP\Attribute\Artifact\AfterBinaryExtract;
-use StaticPHP\Attribute\Artifact\CustomBinary;
-use StaticPHP\Attribute\Artifact\CustomBinaryCheckUpdate;
-use StaticPHP\Exception\DownloaderException;
-
-/**
- * Full CPython for Windows from the official python.org nuget package. It is a plain zip
- * (python.exe plus stdlib under tools/, venv and ensurepip included), so it installs into
- * the pkgroot without touching the system. Used by the meson tool package.
- */
-class python_win
-{
-    #[CustomBinary('python-win', [
-        'windows-x86_64',
-    ])]
-    public function downBinary(ArtifactDownloader $downloader): DownloadResult
-    {
-        $version = $this->getLatestVersion($downloader->getRetry());
-
-        $url = "https://api.nuget.org/v3-flatcontainer/python/{$version}/python.{$version}.nupkg";
-        // .nupkg is a zip; name the cache file .zip so the extractor treats it as one
-        $path = DOWNLOAD_PATH . DIRECTORY_SEPARATOR . "python-win-{$version}.zip";
-        default_shell()->executeCurlDownload($url, $path, retries: $downloader->getRetry());
-
-        return DownloadResult::archive(basename($path), ['url' => $url, 'version' => $version], extract: '{pkg_root_path}/python-win', version: $version);
-    }
-
-    #[CustomBinaryCheckUpdate('python-win', ['windows-x86_64'])]
-    public function checkUpdateBinary(?string $old_version): CheckUpdateResult
-    {
-        $version = $this->getLatestVersion();
-        return new CheckUpdateResult(
-            old: $old_version,
-            new: $version,
-            needUpdate: $old_version === null || $version !== $old_version,
-        );
-    }
-
-    #[AfterBinaryExtract('python-win', ['windows-x86_64'])]
-    public function afterExtract(string $target_path): void
-    {
-        if (!file_exists("{$target_path}\\tools\\python.exe")) {
-            throw new DownloaderException("Python installation appears incomplete: python.exe not found at {$target_path}\\tools\\python.exe");
-        }
-    }
-
-    private function getLatestVersion(int $retries = 0): string
-    {
-        $index = default_shell()->executeCurl('https://api.nuget.org/v3-flatcontainer/python/index.json', retries: $retries);
-        $versions = $index ? (json_decode($index, true)['versions'] ?? []) : [];
-        $stable = array_filter($versions, fn ($v) => preg_match('/^\d+\.\d+\.\d+$/', $v));
-        if ($stable === []) {
-            throw new DownloaderException('Failed to get Python versions from the nuget index');
-        }
-        return end($stable);
-    }
-}

src/Package/Extension/imagick.php

@@ -4,17 +4,12 @@ declare(strict_types=1);
 
 namespace Package\Extension;
 
-use Package\Target\php;
-use StaticPHP\Attribute\Package\BeforeStage;
 use StaticPHP\Attribute\Package\CustomPhpConfigureArg;
 use StaticPHP\Attribute\Package\Extension;
-use StaticPHP\Attribute\PatchDescription;
 use StaticPHP\Package\PackageBuilder;
-use StaticPHP\Package\PhpExtensionPackage;
-use StaticPHP\Util\FileSystem;
 
 #[Extension('imagick')]
-class imagick extends PhpExtensionPackage
+class imagick
 {
     #[CustomPhpConfigureArg('Darwin')]
     #[CustomPhpConfigureArg('Linux')]
@@ -23,35 +18,4 @@ class imagick extends PhpExtensionPackage
         $disable_omp = ' ac_cv_func_omp_pause_resource_all=no';
         return '--with-imagick=' . ($shared ? 'shared,' : '') . $builder->getBuildRootPath() . $disable_omp;
     }
-
-    #[CustomPhpConfigureArg('Windows')]
-    public function getWindowsConfigureArg(bool $shared): string
-    {
-        // config.w32 uses PHP_IMAGICK as an extra search path for CORE_RL_*.lib; the static
-        // ImageMagick libs are installed flat in buildroot/lib (headers in buildroot/include/imagemagick).
-        return '--with-imagick=' . BUILD_LIB_PATH;
-    }
-
-    #[BeforeStage('php', [php::class, 'buildconfForWindows'], 'ext-imagick')]
-    #[PatchDescription('Add the Win32 system libraries the static ImageMagick stack needs')]
-    public function patchConfigW32ForWindows(): void
-    {
-        $config = $this->getSourceDir() . '/config.w32';
-
-        // Idempotency guard (the source dir may be patched in place and reused across builds).
-        if (str_contains(FileSystem::readFile($config), 'LIBS_IMAGICK')) {
-            return;
-        }
-
-        // The static ImageMagick stack needs several Win32 system libraries (GDI/GDI+, WIC, urlmon, ...)
-        // that aren't already pulled in by the other extensions. (imagick itself builds as plain C:
-        // ImageMagick is built with a 32-bit channel mask, see imagemagick.php buildWin, so the
-        // MagickCore headers don't require a C++ translation unit.)
-        FileSystem::replaceFileStr(
-            $config,
-            "AC_DEFINE('HAVE_IMAGICK', 1);",
-            'ADD_FLAG("LIBS_IMAGICK", "gdi32.lib gdiplus.lib urlmon.lib msimg32.lib oleaut32.lib windowscodecs.lib iphlpapi.lib");' . "\n\t\t" .
-            "AC_DEFINE('HAVE_IMAGICK', 1);"
-        );
-    }
 }

src/Package/Extension/pgsql.php

@@ -5,15 +5,11 @@ declare(strict_types=1);
 namespace Package\Extension;
 
 use Package\Target\php;
-use StaticPHP\Attribute\Package\BeforeStage;
 use StaticPHP\Attribute\Package\CustomPhpConfigureArg;
 use StaticPHP\Attribute\Package\Extension;
-use StaticPHP\Attribute\PatchDescription;
 use StaticPHP\Package\PackageBuilder;
 use StaticPHP\Package\PackageInstaller;
 use StaticPHP\Package\PhpExtensionPackage;
-use StaticPHP\Package\TargetPackage;
-use StaticPHP\Util\FileSystem;
 use StaticPHP\Util\SPCConfigUtil;
 
 #[Extension('pgsql')]
@@ -43,27 +39,6 @@ class pgsql extends PhpExtensionPackage
         return "--with-pgsql={$builder->getBuildRootPath()}";
     }
 
-    #[BeforeStage('php', [php::class, 'buildconfForWindows'], 'ext-pgsql')]
-    #[PatchDescription('Link the Win32 system libraries the static libpq needs')]
-    public function patchConfigW32ForWindows(TargetPackage $package): void
-    {
-        $config = "{$package->getSourceDir()}\\ext\\pgsql\\config.w32";
-
-        if (str_contains(FileSystem::readFile($config), 'LIBS_PGSQL')) {
-            return;
-        }
-
-        // libpq uses SSPI for Windows auth (secur32) and the static libcrypto behind it
-        // reads the system cert store (crypt32). Nothing else puts these on the link line
-        // when the openssl extension itself is not part of the build.
-        FileSystem::replaceFileStr(
-            $config,
-            'EXTENSION("pgsql", "pgsql.c", PHP_PGSQL_SHARED, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1");',
-            'EXTENSION("pgsql", "pgsql.c", PHP_PGSQL_SHARED, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1");' . "\n\t\t" .
-            'ADD_FLAG("LIBS_PGSQL", "secur32.lib crypt32.lib");'
-        );
-    }
-
     public function getSharedExtensionEnv(): array
     {
         $parent = parent::getSharedExtensionEnv();

src/Package/Extension/xlswriter.php

@@ -11,7 +11,6 @@ use StaticPHP\Attribute\Package\Extension;
 use StaticPHP\Attribute\PatchDescription;
 use StaticPHP\Package\PackageInstaller;
 use StaticPHP\Package\PhpExtensionPackage;
-use StaticPHP\Util\FileSystem;
 use StaticPHP\Util\SourcePatcher;
 
 #[Extension('xlswriter')]
@@ -29,17 +28,6 @@ class xlswriter extends PhpExtensionPackage
         return $arg;
     }
 
-    #[BeforeStage('php', [php::class, 'buildconfForWindows'], 'ext-xlswriter')]
-    #[PatchDescription('Define XML_STATIC so bundled Expat uses plain symbols instead of __declspec(dllimport) in static builds')]
-    public function patchConfigForStaticExpat(): void
-    {
-        FileSystem::replaceFileStr(
-            "{$this->getSourceDir()}/config.w32",
-            "' /D USE_SYSTEM_MINIZIP",
-            "' /D XML_STATIC /D USE_SYSTEM_MINIZIP"
-        );
-    }
-
     #[BeforeStage('php', [php::class, 'makeForWindows'], 'ext-xlswriter')]
     #[PatchDescription('Fix Windows build: apply win32 patch and add UTF-8 BOM to theme.c')]
     public function patchBeforeMakeForWindows(): void

src/Package/Library/brotli.php

@@ -27,7 +27,10 @@ class brotli
     {
         UnixCMakeExecutor::create($lib)
             ->setBuildDir($lib->getSourceDir() . '/build-dir')
-            ->addConfigureArgs("-DSHARE_INSTALL_PREFIX={$lib->getBuildRootPath()}")
+            ->addConfigureArgs(
+                "-DSHARE_INSTALL_PREFIX={$lib->getBuildRootPath()}",
+                '-DBROTLI_DISABLE_TESTS=ON',
+            )
             ->build();
 
         // Patch pkg-config files

src/Package/Library/bzip2.php

@@ -17,7 +17,9 @@ class bzip2
     #[PatchBeforeBuild]
     public function patchBeforeBuild(LibraryPackage $lib): void
     {
-        FileSystem::replaceFileStr($lib->getSourceDir() . '/Makefile', 'CFLAGS=-Wall', 'CFLAGS=-fPIC -Wall');
+        // Makefile pins -O2 -fPIC; inject SPC_DEFAULT_CFLAGS
+        $extra = deduplicate_flags(trim((string) getenv('SPC_DEFAULT_CFLAGS')) . ' -fPIC -Wall');
+        FileSystem::replaceFileStr($lib->getSourceDir() . '/Makefile', 'CFLAGS=-Wall', "CFLAGS={$extra}");
     }
 
     #[BuildFor('Windows')]

src/Package/Library/fastlz.php

@@ -18,9 +18,11 @@ class fastlz
     {
         $cc = getenv('CC') ?: 'cc';
         $ar = getenv('AR') ?: 'ar';
+        $extra = trim((string) getenv('SPC_DEFAULT_CFLAGS'));
+        $extra = $extra !== '' ? $extra . ' -fPIC' : '-O3 -fPIC';
 
         shell()->cd($lib->getSourceDir())->initializeEnv($lib)
-            ->exec("{$cc} -c -O3 -fPIC fastlz.c -o fastlz.o")
+            ->exec("{$cc} -c {$extra} fastlz.c -o fastlz.o")
             ->exec("{$ar} rcs libfastlz.a fastlz.o");
 
         // Copy header file

src/Package/Library/gmp.php

@@ -8,6 +8,7 @@ use StaticPHP\Attribute\Package\BuildFor;
 use StaticPHP\Attribute\Package\Library;
 use StaticPHP\Package\LibraryPackage;
 use StaticPHP\Runtime\Executor\UnixAutoconfExecutor;
+use StaticPHP\Runtime\SystemTarget;
 
 #[Library('gmp')]
 class gmp
@@ -16,10 +17,12 @@ class gmp
     #[BuildFor('Darwin')]
     public function build(LibraryPackage $lib): void
     {
-        UnixAutoconfExecutor::create($lib)
+        $make = UnixAutoconfExecutor::create($lib)->appendEnv(['CFLAGS' => '-std=c17']);
-            ->appendEnv(['CFLAGS' => '-std=c17'])
+        if (SystemTarget::getTargetArch() === 'x86_64' && SystemTarget::getTargetOS() === 'Linux') {
-            ->configure('--enable-fat')
+            $libc = SystemTarget::getLibc() === 'glibc' ? 'gnu' : 'musl';
-            ->make();
+            $make->addConfigureArgs(["--host=x86_64-pc-linux-{$libc}"]);
+        }
+        $make->configure('--enable-fat')->make();
         $lib->patchPkgconfPrefix(['gmp.pc']);
     }
 }

src/Package/Library/icu.php

@@ -24,9 +24,12 @@ class icu
     #[BuildFor('Linux')]
     public function buildLinux(LibraryPackage $lib, ToolchainInterface $toolchain, PackageBuilder $builder): void
     {
+        // runConfigureICU bakes CXXFLAGS/LDFLAGS, apply user flags too
+        $userCxxFlags = trim((string) getenv('SPC_DEFAULT_CXXFLAGS'));
+        $userLdFlags = trim((string) getenv('SPC_DEFAULT_LDFLAGS'));
         $cppflags = 'CPPFLAGS="-DU_CHARSET_IS_UTF8=1  -DU_USING_ICU_NAMESPACE=1 -DU_STATIC_IMPLEMENTATION=1 -DPIC -fPIC"';
-        $cxxflags = 'CXXFLAGS="-std=c++17 -DPIC -fPIC -fno-ident"';
+        $cxxflags = "CXXFLAGS=\"-std=c++17 -DPIC -fPIC -fno-ident {$userCxxFlags}\"";
-        $ldflags = $toolchain->isStatic() ? 'LDFLAGS="-static"' : '';
+        $ldflags = $toolchain->isStatic() ? "LDFLAGS=\"-static {$userLdFlags}\"" : "LDFLAGS=\"{$userLdFlags}\"";
         shell()->cd($lib->getSourceDir() . '/source')->initializeEnv($lib)
             ->exec(
                 "{$cppflags} {$cxxflags} {$ldflags} " .

src/Package/Library/imagemagick.php

@@ -6,86 +6,15 @@ namespace Package\Library;
 
 use StaticPHP\Attribute\Package\BuildFor;
 use StaticPHP\Attribute\Package\Library;
-use StaticPHP\Exception\EnvironmentException;
 use StaticPHP\Package\LibraryPackage;
 use StaticPHP\Runtime\Executor\UnixAutoconfExecutor;
 use StaticPHP\Runtime\SystemTarget;
 use StaticPHP\Toolchain\Interface\ToolchainInterface;
 use StaticPHP\Util\FileSystem;
-use StaticPHP\Util\System\WindowsUtil;
 
 #[Library('imagemagick')]
 class imagemagick
 {
-    /**
-     * Build a fully static, self-contained ImageMagick 7 (Q16-HDRI, /MT) on Windows using the
-     * official VisualMagick build (the ImageMagick/Windows + Configure + Dependencies repos), which
-     * bundles every delegate. ImageMagick has no autoconf/CMake build on Windows, so this clones the
-     * VisualMagick tree, generates a static x64 solution via the Configure tool, and builds it with
-     * msbuild. The resulting CORE_RL_*.lib static libraries + MagickWand/MagickCore headers are
-     * installed into the build root for ext-imagick to link.
-     *
-     * The VisualMagick tree lives under source/ so bin/spc reset cleans it up like everything
-     * else; override the location with SPC_IMAGEMAGICK_BUILD_DIR.
-     */
-    #[BuildFor('Windows')]
-    public function buildWin(LibraryPackage $lib): void
-    {
-        $work = getenv('SPC_IMAGEMAGICK_BUILD_DIR') ?: SOURCE_PATH . '\imagemagick-win';
-        $configure_release = '2026.05.30.2033';
-        $configure_url = "https://github.com/ImageMagick/Configure/releases/download/{$configure_release}/Configure.Release.x64.exe";
-
-        FileSystem::createDir($work);
-        // Clone the VisualMagick repos (ImageMagick source + Configure + Dependencies + all delegates).
-        if (!is_dir("{$work}\\ImageMagick")) {
-            cmd()->cd($work)->exec(SPC_GIT_EXEC . ' clone --depth 1 https://github.com/ImageMagick/Windows.git .');
-            cmd()->cd($work)->exec('bash clone-repositories.sh --imagemagick7');
-        }
-        // Use the prebuilt Configure tool (building it from source needs the MFC components).
-        default_shell()->executeCurlDownload($configure_url, "{$work}\\Configure\\Configure.Release.x64.exe", retries: 2);
-
-        // Generate a static, /MT (linkRuntime), x64, Q16-HDRI solution with the configs embedded
-        // (zeroConfigurationSupport) and OpenMP off (no vcomp runtime dependency).
-        $ver = WindowsUtil::findVisualStudio();
-        $vs_major = is_array($ver) ? $ver['major_version'] : 'unknown';
-        $vs_arg = match ($vs_major) {
-            '18',
-            '17' => '/VS2022',
-            '16' => '/VS2019',
-            default => throw new EnvironmentException("Current VS version {$vs_major} is not supported yet!"),
-        };
-        cmd()->cd("{$work}\\Configure")
-            ->exec("Configure.Release.x64.exe /noWizard {$vs_arg} /x64 /static /linkRuntime /noOpenMP /zeroConfigurationSupport");
-
-        // x64 IM7 defaults to a 64-bit channel mask, whose magick-baseconfig.h #errors unless the
-        // consuming translation unit is C++. ext-imagick is plain C, so force a 32-bit channel mask
-        // (ample: 32 channels >> RGBA/CMYK) before building, keeping libs and the installed header in sync.
-        FileSystem::replaceFileStr(
-            "{$work}\\ImageMagick\\MagickCore\\magick-baseconfig.h",
-            '#define MAGICKCORE_CHANNEL_MASK_DEPTH 64',
-            '#define MAGICKCORE_CHANNEL_MASK_DEPTH 32'
-        );
-
-        cmd()->cd($work)
-            ->exec('msbuild IM7.Static.x64.sln /m /t:Rebuild /nologo /p:Configuration=Release /p:Platform=x64');
-
-        $artifacts = "{$work}\\Artifacts\\lib";
-        if (!is_dir($artifacts)) {
-            throw new EnvironmentException('ImageMagick VisualMagick build produced no Artifacts/lib; build failed.');
-        }
-        // Install the static libs (flat, onto the build-root lib path) and the public headers.
-        FileSystem::createDir($lib->getLibDir());
-        foreach (glob("{$artifacts}\\CORE_RL_*.lib") as $f) {
-            FileSystem::copy($f, $lib->getLibDir() . '\\' . basename($f));
-        }
-        foreach (['MagickWand', 'MagickCore'] as $dir) {
-            FileSystem::createDir($lib->getIncludeDir() . "\\imagemagick\\{$dir}");
-            foreach (glob("{$work}\\ImageMagick\\{$dir}\\*.h") as $h) {
-                FileSystem::copy($h, $lib->getIncludeDir() . "\\imagemagick\\{$dir}\\" . basename($h));
-            }
-        }
-    }
-
     #[BuildFor('Darwin')]
     #[BuildFor('Linux')]
     public function buildUnix(LibraryPackage $lib, ToolchainInterface $toolchain): void
@@ -116,6 +45,9 @@ class imagemagick
                 // implicit --with-gcc-arch
                 // bleeds host cpu features into built binaries
                 '--without-gcc-arch',
+                '--disable-docs',
+                '--without-utilities',
+                '--disable-dpc',
             );
 
         // special: linux-static target needs `-static`

src/Package/Library/jbig.php

@@ -17,7 +17,9 @@ class jbig
     #[PatchBeforeBuild]
     public function patchBeforeBuild(LibraryPackage $lib): void
     {
-        FileSystem::replaceFileStr($lib->getSourceDir() . '/Makefile', 'CFLAGS = -O2 -W -Wno-unused-result', 'CFLAGS = -O2 -W -Wno-unused-result -fPIC');
+        $extra = trim((string) getenv('SPC_DEFAULT_CFLAGS'));
+        $cflags = ($extra !== '' ? $extra : '-O2') . ' -W -Wno-unused-result -fPIC';
+        FileSystem::replaceFileStr($lib->getSourceDir() . '/Makefile', 'CFLAGS = -O2 -W -Wno-unused-result', "CFLAGS = {$cflags}");
     }
 
     #[BuildFor('Darwin')]

src/Package/Library/ldap.php

@@ -35,6 +35,7 @@ class ldap
             ->optionalPackage('libsodium', '--with-argon2=libsodium', '--enable-argon2=no')
             ->addConfigureArgs(
                 '--disable-slapd',
+                '--disable-debug',
                 '--without-systemd',
                 '--without-cyrus-sasl',
                 'ac_cv_func_pthread_kill_other_threads_np=no'

src/Package/Library/libaom.php

@@ -9,8 +9,10 @@ use StaticPHP\Attribute\Package\Library;
 use StaticPHP\Package\LibraryPackage;
 use StaticPHP\Runtime\Executor\UnixCMakeExecutor;
 use StaticPHP\Runtime\Executor\WindowsCMakeExecutor;
+use StaticPHP\Runtime\SystemTarget;
 use StaticPHP\Toolchain\Interface\ToolchainInterface;
 use StaticPHP\Toolchain\ZigToolchain;
+use StaticPHP\Util\System\UnixUtil;
 
 #[Library('libaom')]
 class libaom extends LibraryPackage
@@ -39,9 +41,23 @@ class libaom extends LibraryPackage
             $new = trim($extra . ' -D_GNU_SOURCE');
             f_putenv("SPC_COMPILER_EXTRA={$new}");
         }
+        $targetCpu = SystemTarget::getTargetArch();
+        if (str_starts_with($targetCpu, 'aarch')) {
+            $targetCpu = str_replace('aarch', 'arm', $targetCpu);
+        }
+        if (!UnixUtil::findCommand('nasm') && !UnixUtil::findCommand('yasm')) {
+            $targetCpu = 'generic';
+        }
         UnixCMakeExecutor::create($this)
             ->setBuildDir("{$this->getSourceDir()}/builddir")
-            ->addConfigureArgs('-DAOM_TARGET_CPU=generic')
+            ->addConfigureArgs(
+                "-DAOM_TARGET_CPU={$targetCpu}",
+                '-DCONFIG_RUNTIME_CPU_DETECT=1',
+                '-DENABLE_EXAMPLES=OFF',
+                '-DENABLE_TESTS=OFF',
+                '-DENABLE_TOOLS=OFF',
+                '-DENABLE_DOCS=OFF',
+            )
             ->build();
         f_putenv("SPC_COMPILER_EXTRA={$extra}");
         $this->patchPkgconfPrefix(['aom.pc']);

src/Package/Library/libavif.php

@@ -35,7 +35,12 @@ class libavif
             ->optionalPackage('libjpeg', '-DAVIF_JPEG=SYSTEM', '-DAVIF_JPEG=OFF')
             ->optionalPackage('libxml2', '-DAVIF_LIBXML2=SYSTEM', '-DAVIF_LIBXML2=OFF')
             ->optionalPackage('libpng', '-DAVIF_LIBPNG=SYSTEM', '-DAVIF_LIBPNG=OFF')
-            ->addConfigureArgs('-DAVIF_LIBYUV=OFF')
+            ->addConfigureArgs(
+                '-DAVIF_LIBYUV=OFF',
+                '-DAVIF_BUILD_APPS=OFF',
+                '-DAVIF_BUILD_TESTS=OFF',
+                '-DAVIF_GTEST=OFF',
+            )
             ->build();
         // patch pkgconfig
         $lib->patchPkgconfPrefix(['libavif.pc']);
@@ -49,7 +54,7 @@ class libavif
                 '-DAVIF_BUILD_APPS=OFF',
                 '-DAVIF_BUILD_TESTS=OFF',
                 '-DAVIF_LIBYUV=OFF',
-                '-DAVIF_ENABLE_GTEST=OFF',
+                '-DAVIF_GTEST=OFF',
             )
             ->build();
     }

src/Package/Library/libffi.php

@@ -16,7 +16,7 @@ class libffi extends LibraryPackage
     public function buildLinux(): void
     {
         UnixAutoconfExecutor::create($this)
-            ->configure()->make();
+            ->configure('--disable-docs')->make();
 
         if (is_file("{$this->getBuildRootPath()}/lib64/libffi.a")) {
             copy("{$this->getBuildRootPath()}/lib64/libffi.a", "{$this->getBuildRootPath()}/lib/libffi.a");
@@ -33,6 +33,7 @@ class libffi extends LibraryPackage
             ->configure(
                 "--host={$arch}-apple-darwin",
                 "--target={$arch}-apple-darwin",
+                '--disable-docs',
             )
             ->make();
         $this->patchPkgconfPrefix(['libffi.pc']);

src/Package/Library/libheif.php

@@ -24,6 +24,17 @@ class libheif
                 'list(APPEND REQUIRES_PRIVATE "libbrotlidec")' . "\n" . '        list(APPEND REQUIRES_PRIVATE "libbrotlienc")'
             );
         }
+        // libheif 1.22+ ships a C-incompatible header: `struct heif_bad_pixel`
+        $heif_properties = $lib->getSourceDir() . '/libheif/api/libheif/heif_properties.h';
+        if (file_exists($heif_properties)
+            && str_contains(file_get_contents($heif_properties), 'struct heif_bad_pixel { uint32_t row; uint32_t column; };')
+        ) {
+            FileSystem::replaceFileStr(
+                $heif_properties,
+                'struct heif_bad_pixel { uint32_t row; uint32_t column; };',
+                'typedef struct heif_bad_pixel { uint32_t row; uint32_t column; } heif_bad_pixel;'
+            );
+        }
     }
 
     #[BuildFor('Darwin')]
@@ -36,6 +47,7 @@ class libheif
                 '-DWITH_EXAMPLES=OFF',
                 '-DWITH_GDK_PIXBUF=OFF',
                 '-DBUILD_TESTING=OFF',
+                '-DBUILD_DOCUMENTATION=OFF',
                 '-DWITH_LIBSHARPYUV=ON', // optional: libwebp
                 '-DENABLE_PLUGIN_LOADING=OFF',
             )

src/Package/Library/libjxl.php

@@ -25,6 +25,7 @@ class libjxl extends LibraryPackage
                 '-DJPEGXL_ENABLE_MANPAGES=OFF',
                 '-DJPEGXL_ENABLE_BENCHMARK=OFF',
                 '-DJPEGXL_ENABLE_PLUGINS=OFF',
+                '-DJPEGXL_ENABLE_DOXYGEN=OFF',
                 '-DJPEGXL_ENABLE_SJPEG=ON',
                 '-DJPEGXL_ENABLE_JNI=OFF',
                 '-DJPEGXL_ENABLE_TRANSCODE_JPEG=ON',

src/Package/Library/libmemcached.php

@@ -12,17 +12,25 @@ use StaticPHP\Runtime\Executor\UnixCMakeExecutor;
 #[Library('libmemcached')]
 class libmemcached extends LibraryPackage
 {
+    private const array DISABLE_ARGS = [
+        '-DBUILD_TESTING=OFF',
+        '-DBUILD_DOCS=OFF',
+        '-DENABLE_MEMASLAP=OFF',
+    ];
+
     #[BuildFor('Linux')]
     public function buildLinux(): void
     {
         UnixCMakeExecutor::create($this)
-            ->addConfigureArgs('-DCMAKE_INSTALL_RPATH=""')
+            ->addConfigureArgs('-DCMAKE_INSTALL_RPATH=""', ...self::DISABLE_ARGS)
             ->build();
     }
 
     #[BuildFor('Darwin')]
     public function buildDarwin(): void
     {
-        UnixCMakeExecutor::create($this)->build();
+        UnixCMakeExecutor::create($this)
+            ->addConfigureArgs(...self::DISABLE_ARGS)
+            ->build();
     }
 }

src/Package/Library/libpng.php

@@ -20,6 +20,8 @@ class libpng
     {
         $args = [
             '--enable-hardware-optimizations',
+            '--disable-tests',
+            '--disable-tools',
             "--with-zlib-prefix={$lib->getBuildRootPath()}",
         ];
 

src/Package/Library/librabbitmq.php

@@ -13,17 +13,29 @@ use StaticPHP\Runtime\Executor\WindowsCMakeExecutor;
 #[Library('librabbitmq')]
 class librabbitmq extends LibraryPackage
 {
+    private const array DISABLE_ARGS = [
+        '-DBUILD_EXAMPLES=OFF',
+        '-DBUILD_TESTING=OFF',
+        '-DBUILD_TOOLS=OFF',
+        '-DBUILD_TOOLS_DOCS=OFF',
+        '-DBUILD_API_DOCS=OFF',
+    ];
+
     #[BuildFor('Darwin')]
     #[BuildFor('Linux')]
     public function buildUnix(): void
     {
-        UnixCMakeExecutor::create($this)->addConfigureArgs('-DBUILD_STATIC_LIBS=ON')->build();
+        UnixCMakeExecutor::create($this)
+            ->addConfigureArgs('-DBUILD_STATIC_LIBS=ON', ...self::DISABLE_ARGS)
+            ->build();
     }
 
     #[BuildFor('Windows')]
     public function buildWin(): void
     {
-        WindowsCMakeExecutor::create($this)->build();
+        WindowsCMakeExecutor::create($this)
+            ->addConfigureArgs(...self::DISABLE_ARGS)
+            ->build();
         rename("{$this->getLibDir()}\\librabbitmq.4.lib", "{$this->getLibDir()}\\rabbitmq.4.lib");
     }
 }

src/Package/Library/libtiff.php

@@ -41,6 +41,9 @@ class libtiff
                 '--disable-libdeflate',
                 '--disable-tools',
                 '--disable-contrib',
+                '--disable-tests',
+                '--disable-docs',
+                '--disable-sphinx',
                 '--disable-cxx',
                 '--without-x',
             )

src/Package/Library/libuv.php

@@ -13,12 +13,18 @@ use StaticPHP\Runtime\Executor\WindowsCMakeExecutor;
 #[Library('libuv')]
 class libuv
 {
+    private const array DISABLE_ARGS = [
+        '-DLIBUV_BUILD_SHARED=OFF',
+        '-DLIBUV_BUILD_TESTS=OFF',
+        '-DLIBUV_BUILD_BENCH=OFF',
+    ];
+
     #[BuildFor('Darwin')]
     #[BuildFor('Linux')]
     public function buildUnix(LibraryPackage $lib): void
     {
         UnixCMakeExecutor::create($lib)
-            ->addConfigureArgs('-DLIBUV_BUILD_SHARED=OFF')
+            ->addConfigureArgs(...self::DISABLE_ARGS)
             ->build();
         // patch pkgconfig
         $lib->patchPkgconfPrefix(['libuv-static.pc']);
@@ -28,7 +34,7 @@ class libuv
     public function buildWindows(LibraryPackage $lib): void
     {
         WindowsCMakeExecutor::create($lib)
-            ->addConfigureArgs('-DLIBUV_BUILD_SHARED=OFF')
+            ->addConfigureArgs(...self::DISABLE_ARGS)
             ->build();
     }
 }

src/Package/Library/libxslt.php

@@ -34,6 +34,7 @@ class libxslt
                 '--without-crypto',
                 '--without-debug',
                 '--without-debugger',
+                '--without-profiler',
                 "--with-libxml-prefix={$lib->getBuildRootPath()}",
             );
         if (getenv('SPC_LD_LIBRARY_PATH') && getenv('SPC_LIBRARY_PATH')) {

src/Package/Library/mimalloc.php

@@ -21,6 +21,7 @@ class mimalloc
             ->addConfigureArgs(
                 '-DMI_BUILD_SHARED=OFF',
                 '-DMI_BUILD_OBJECT=OFF',
+                '-DMI_BUILD_TESTS=OFF',
                 '-DMI_INSTALL_TOPLEVEL=ON',
             );
         if (SystemTarget::getLibc() === 'musl') {

src/Package/Library/ncurses.php

@@ -6,6 +6,8 @@ namespace Package\Library;
 
 use StaticPHP\Attribute\Package\BuildFor;
 use StaticPHP\Attribute\Package\Library;
+use StaticPHP\Attribute\Package\PatchBeforeBuild;
+use StaticPHP\Attribute\PatchDescription;
 use StaticPHP\Package\LibraryPackage;
 use StaticPHP\Runtime\Executor\UnixAutoconfExecutor;
 use StaticPHP\Toolchain\Interface\ToolchainInterface;
@@ -16,6 +18,24 @@ use StaticPHP\Util\FileSystem;
 #[Library('ncursesw')]
 class ncurses
 {
+    #[PatchBeforeBuild]
+    #[PatchDescription('Filter clang/zig "N warning(s) generated." line out of MKlib_gen.sh preprocessor pipe')]
+    public function patchBeforeBuild(LibraryPackage $lib): void
+    {
+        // MKlib_gen.sh feeds the C preprocessor's stdout through a sed/awk
+        // pipeline into lib_gen.c. zig-cc/clang emits "N warning(s) generated."
+        // on stdout (not stderr), and that line ends up as invalid C in the
+        // generated source. Filter it out of the pipe before sed sees it.
+        $mklibGen = $lib->getSourceDir() . '/ncurses/base/MKlib_gen.sh';
+        if (is_file($mklibGen) && !str_contains((string) file_get_contents($mklibGen), "| grep -v ' generated")) {
+            FileSystem::replaceFileStr(
+                $mklibGen,
+                '$preprocessor $TMP 2>/dev/null \\',
+                "\$preprocessor \$TMP 2>/dev/null \\\n| grep -v ' generated\\.\$' \\",
+            );
+        }
+    }
+
     #[BuildFor('Darwin')]
     #[BuildFor('Linux')]
     public function build(LibraryPackage $package, ToolchainInterface $toolchain): void

src/Package/Library/nghttp3.php

@@ -24,6 +24,7 @@ class nghttp3
                 '-DBUILD_SHARED_LIBS=OFF',
                 '-DENABLE_STATIC_CRT=ON',
                 '-DENABLE_LIB_ONLY=ON',
+                '-DBUILD_TESTING=OFF',
             )
             ->build();
     }

src/Package/Library/ngtcp2.php

@@ -25,6 +25,7 @@ class ngtcp2
                 '-DENABLE_STATIC_CRT=ON',
                 '-DENABLE_LIB_ONLY=ON',
                 '-DENABLE_OPENSSL=OFF',
+                '-DBUILD_TESTING=OFF',
             )
             ->build();
     }

src/Package/Library/openssl.php

@@ -6,24 +6,43 @@ namespace Package\Library;
 
 use StaticPHP\Attribute\Package\BuildFor;
 use StaticPHP\Attribute\Package\Library;
+use StaticPHP\Attribute\Package\Validate;
+use StaticPHP\DI\ApplicationContext;
 use StaticPHP\Exception\EnvironmentException;
 use StaticPHP\Package\LibraryPackage;
 use StaticPHP\Package\PackageBuilder;
-use StaticPHP\Package\ToolPackage;
+use StaticPHP\Runtime\SystemTarget;
-use StaticPHP\Registry\PackageLoader;
 use StaticPHP\Util\FileSystem;
 use StaticPHP\Util\System\LinuxUtil;
+use StaticPHP\Util\System\WindowsUtil;
 
 #[Library('openssl')]
 class openssl
 {
+    #[Validate]
+    public function validate(): void
+    {
+        if (SystemTarget::getTargetOS() === 'Windows') {
+            global $argv;
+            $perl_path_native = PKG_ROOT_PATH . '\strawberry-perl\perl\bin\perl.exe';
+            $perl = file_exists($perl_path_native) ? ($perl_path_native) : WindowsUtil::findCommand('perl.exe');
+            if ($perl === null) {
+                throw new EnvironmentException(
+                    'You need to install perl first!',
+                    "Please run \"{$argv[0]} doctor\" to fix the environment.",
+                );
+            }
+            ApplicationContext::set('perl', $perl);
+        }
+    }
+
     #[BuildFor('Windows')]
     public function buildWin(LibraryPackage $lib, PackageBuilder $builder): void
     {
-        $perl = $this->resolveWindowsPerl();
+        $perl = ApplicationContext::get('perl');
         $cmd = cmd()->cd($lib->getSourceDir())
             ->exec(
-                escapeshellarg($perl) . ' Configure zlib VC-WIN64A ' .
+                "{$perl} Configure zlib VC-WIN64A " .
                 'no-shared ' .
                 '--prefix=' . quote($lib->getBuildRootPath()) . ' ' .
                 '--with-zlib-lib=' . quote($lib->getLibDir()) . ' ' .
@@ -92,6 +111,12 @@ class openssl
         $openssl_dir ??= LinuxUtil::getOSRelease()['dist'] === 'redhat' ? '/etc/pki/tls' : '/etc/ssl';
         $ex_lib = trim($ex_lib);
 
+        // anything we want included (PGO -fprofile-*, LTO, custom hardening)
+        // has to be appended on the command line *after* the target name.
+        $userCFlags = trim((string) getenv('SPC_DEFAULT_CFLAGS'));
+        $userLdFlags = trim((string) getenv('SPC_DEFAULT_LDFLAGS'));
+        $userExtra = trim($userCFlags . ' ' . $userLdFlags);
+
         shell()->cd($lib->getSourceDir())->initializeEnv($lib)
             ->exec(
                 "{$env} ./Configure no-shared zlib " .
@@ -102,7 +127,8 @@ class openssl
                 'enable-pie ' .
                 'no-legacy ' .
                 'no-tests ' .
-                "linux-{$arch}"
+                "linux-{$arch} " .
+                $userExtra
             )
             ->exec('make clean')
             ->exec("make -j{$lib->getBuilder()->concurrency} CNF_EX_LIBS=\"{$ex_lib}\"")
@@ -126,22 +152,4 @@ class openssl
         FileSystem::replaceFileRegex("{$pkg->getLibDir()}/pkgconfig/libcrypto.pc", '/Libs.private:.*/m', 'Requires.private: zlib');
         FileSystem::replaceFileRegex("{$pkg->getLibDir()}/cmake/OpenSSL/OpenSSLConfig.cmake", '/set\(OPENSSL_LIBCRYPTO_DEPENDENCIES .*\)/m', 'set(OPENSSL_LIBCRYPTO_DEPENDENCIES "${OPENSSL_LIBRARY_DIR}/libz.a")');
     }
-
-    private function resolveWindowsPerl(): string
-    {
-        global $argv;
-
-        $tool = PackageLoader::getPackage('strawberry-perl');
-        if ($tool instanceof ToolPackage) {
-            $perl = $tool->getBinary('perl.exe');
-            if (file_exists($perl)) {
-                return $perl;
-            }
-        }
-
-        throw new EnvironmentException(
-            'OpenSSL requires strawberry-perl, but it is not installed.',
-            "Please run \"{$argv[0]} install-pkg strawberry-perl\" or retry the build with downloads enabled.",
-        );
-    }
 }

src/Package/Library/postgresql.php

@@ -37,10 +37,6 @@ class postgresql extends LibraryPackage
     #[PatchDescription('Various patches before building PostgreSQL')]
     public function patchBeforeBuild(): bool
     {
-        // These patches target the autoconf/Make build; the Windows build uses Meson (see buildWin).
-        if (SystemTarget::getTargetOS() === 'Windows') {
-            return true;
-        }
         // skip the test on platforms where libpq infrastructure may be provided by statically-linked libraries
         FileSystem::replaceFileStr("{$this->getSourceDir()}/src/interfaces/libpq/Makefile", 'invokes exit\'; exit 1;', 'invokes exit\';');
         // disable shared libs build
@@ -57,73 +53,6 @@ class postgresql extends LibraryPackage
         return true;
     }
 
-    #[BuildFor('Windows')]
-    public function buildWin(LibraryPackage $lib): void
-    {
-        $src = $lib->getSourceDir();
-        $build_root = $lib->getBuildRootPath();
-        $lib_dir = $lib->getLibDir();
-        $inc_dir = $lib->getIncludeDir();
-        $build = "{$src}\\build";
-
-        // Export the public pg_char_to_encoding()/pg_encoding_to_char() from libpgcommon.a so a
-        // statically-linked libpq.a resolves them (PHP's ext/pgsql relies on them too). This mirrors
-        // the Unix build's -UUSE_PRIVATE_ENCODING_FUNCS patch, but for the Meson build.
-        FileSystem::replaceFileStr(
-            "{$src}\\src\\common\\meson.build",
-            "'c_args': ['-DUSE_PRIVATE_ENCODING_FUNCS'],",
-            "'c_args': [],"
-        );
-
-        // Fresh Meson build dir (Meson refuses to reuse a dir configured differently).
-        if (is_dir($build)) {
-            FileSystem::removeDir($build);
-        }
-
-        // Meson's OpenSSL detection link-tests CRYPTO_new_ex_data; our static libcrypto needs its
-        // Win32 deps (and zlib, since OpenSSL was built with zlib) on the link line to succeed.
-        $ld = 'ws2_32.lib gdi32.lib advapi32.lib crypt32.lib user32.lib secur32.lib zlibstatic.lib';
-
-        $configure = 'meson setup build'
-            . ' --prefix=' . escapeshellarg($build_root)
-            . ' -Ddefault_library=static'   // static libpq.a / libpgcommon.a / libpgport.a
-            . ' -Db_vscrt=mt'               // /MT static CRT, matching the rest of the build
-            . ' -Dssl=openssl'
-            // Everything libpq doesn't need: keeps deps minimal and avoids server-only detection.
-            . ' -Dzlib=disabled -Dnls=disabled -Dreadline=disabled -Dicu=disabled'
-            . ' -Dlz4=disabled -Dzstd=disabled -Dtap_tests=disabled'
-            . ' -Dplperl=disabled -Dplpython=disabled -Dpltcl=disabled'
-            . ' -Dgssapi=disabled -Dldap=disabled -Dlibxml=disabled -Dlibxslt=disabled'
-            . ' -Dextra_include_dirs=' . escapeshellarg("{$build_root}\\include")
-            . ' -Dextra_lib_dirs=' . escapeshellarg($lib_dir);
-
-        // Build only the three frontend static libs (not the server) — keeps it fast and avoids
-        // needing every backend dependency. meson/ninja/win_bison/win_flex/perl come from the
-        // tool packages declared in the package config (tools@windows).
-        $targets = 'src/interfaces/libpq/libpq.a src/common/libpgcommon.a src/port/libpgport.a';
-
-        cmd()->cd($src)
-            ->setEnv([
-                'LIB' => $lib_dir . ';' . (getenv('LIB') ?: ''),
-                'LDFLAGS' => $ld,
-            ])
-            ->exec($configure)
-            ->exec("ninja -C build {$targets}");
-
-        // Install the static libs under the names PHP's ext/pgsql + frankenphp expect (.lib).
-        FileSystem::createDir($lib_dir);
-        FileSystem::createDir($inc_dir);
-        FileSystem::copy("{$build}\\src\\interfaces\\libpq\\libpq.a", "{$lib_dir}\\libpq.lib");
-        FileSystem::copy("{$build}\\src\\common\\libpgcommon.a", "{$lib_dir}\\libpgcommon.lib");
-        FileSystem::copy("{$build}\\src\\port\\libpgport.a", "{$lib_dir}\\libpgport.lib");
-
-        // Install the public libpq headers (PG18 no longer ships pg_config_ext.h).
-        FileSystem::copy("{$src}\\src\\interfaces\\libpq\\libpq-fe.h", "{$inc_dir}\\libpq-fe.h");
-        FileSystem::copy("{$src}\\src\\include\\postgres_ext.h", "{$inc_dir}\\postgres_ext.h");
-        FileSystem::createDir("{$inc_dir}\\libpq");
-        FileSystem::copy("{$src}\\src\\include\\libpq\\libpq-fs.h", "{$inc_dir}\\libpq\\libpq-fs.h");
-    }
-
     #[BuildFor('Darwin')]
     #[BuildFor('Linux')]
     public function buildUnix(PackageInstaller $installer, PackageBuilder $builder): void

src/Package/Library/qdbm.php

@@ -20,6 +20,11 @@ class qdbm
     {
         $ac = UnixAutoconfExecutor::create($lib)->configure();
         FileSystem::replaceFileRegex($lib->getSourceDir() . '/Makefile', '/MYLIBS = libqdbm.a.*/m', 'MYLIBS = libqdbm.a');
+        // Makefile pins -O3, replace with SPC_DEFAULT_CFLAGS
+        $extra = trim((string) getenv('SPC_DEFAULT_CFLAGS'));
+        if ($extra !== '') {
+            FileSystem::replaceFileRegex($lib->getSourceDir() . '/Makefile', '/^CFLAGS = .*$/m', "CFLAGS = -Wall {$extra}");
+        }
         $ac->make(SystemTarget::getTargetOS() === 'Darwin' ? 'mac' : '');
         $lib->patchPkgconfPrefix(['qdbm.pc']);
     }

src/Package/Library/readline.php

@@ -20,6 +20,7 @@ class readline
             ->configure(
                 '--with-curses',
                 '--enable-multibyte=yes',
+                '--disable-install-examples',
             )
             ->make();
         $lib->patchPkgconfPrefix(['readline.pc']);

src/Package/Library/tidy.php

@@ -22,7 +22,8 @@ class tidy
             ->setBuildDir("{$lib->getSourceDir()}/build-dir")
             ->addConfigureArgs(
                 '-DSUPPORT_CONSOLE_APP=OFF',
-                '-DBUILD_SHARED_LIB=OFF'
+                '-DBUILD_SHARED_LIB=OFF',
+                '-DSUPPORT_LOCALIZATIONS=OFF',
             );
         if (version_compare(get_cmake_version(), '4.0.0', '>=')) {
             $cmake->addConfigureArgs('-DCMAKE_POLICY_VERSION_MINIMUM=3.5');
@@ -38,7 +39,8 @@ class tidy
             ->setBuildDir("{$lib->getSourceDir()}/build-dir")
             ->addConfigureArgs(
                 '-DSUPPORT_CONSOLE_APP=OFF',
-                '-DBUILD_SHARED_LIB=OFF'
+                '-DBUILD_SHARED_LIB=OFF',
+                '-DSUPPORT_LOCALIZATIONS=OFF',
             )->build();
 
         // rename tidy_static.lib to tidy_a.lib

src/Package/Library/unixodbc.php

@@ -35,6 +35,7 @@ class unixodbc extends LibraryPackage
                 '--with-included-ltdl',
                 "--sysconfdir={$sysconf_selector}",
                 '--enable-gui=no',
+                '--enable-readline=no',
             )
             ->make();
         $this->patchPkgconfPrefix(['odbc.pc', 'odbccr.pc', 'odbcinst.pc']);

src/Package/Library/xz.php

@@ -22,6 +22,11 @@ class xz
             ->configure(
                 '--disable-scripts',
                 '--disable-doc',
+                '--disable-xz',
+                '--disable-xzdec',
+                '--disable-lzmadec',
+                '--disable-lzmainfo',
+                '--disable-lzma-links',
                 '--with-libiconv',
                 '--bindir=/tmp/xz', // xz binary will corrupt `tar` command, that's really strange.
             )

src/Package/Library/zstd.php

@@ -14,16 +14,20 @@ use StaticPHP\Util\FileSystem;
 #[Library('zstd')]
 class zstd
 {
+    private const array DISABLE_ARGS = [
+        '-DZSTD_BUILD_STATIC=ON',
+        '-DZSTD_BUILD_SHARED=OFF',
+        '-DZSTD_BUILD_PROGRAMS=OFF',
+        '-DZSTD_BUILD_TESTS=OFF',
+    ];
+
     #[BuildFor('Windows')]
     public function buildWin(LibraryPackage $package): void
     {
         WindowsCMakeExecutor::create($package)
             ->setWorkingDir("{$package->getSourceDir()}/build/cmake")
             ->setBuildDir("{$package->getSourceDir()}/build/cmake/build")
-            ->addConfigureArgs(
+            ->addConfigureArgs(...self::DISABLE_ARGS)
-                '-DZSTD_BUILD_STATIC=ON',
-                '-DZSTD_BUILD_SHARED=OFF',
-            )
             ->build();
         FileSystem::copy($package->getLibDir() . '\zstd_static.lib', $package->getLibDir() . '/zstd.lib');
         FileSystem::copy($package->getLibDir() . '\zstd_static.lib', $package->getLibDir() . '/libzstd.lib');
@@ -35,10 +39,7 @@ class zstd
     {
         UnixCMakeExecutor::create($lib)
             ->setBuildDir("{$lib->getSourceDir()}/build/cmake/build")
-            ->addConfigureArgs(
+            ->addConfigureArgs(...self::DISABLE_ARGS)
-                '-DZSTD_BUILD_STATIC=ON',
-                '-DZSTD_BUILD_SHARED=OFF',
-            )
             ->build();
 
         $lib->patchPkgconfPrefix(['libzstd.pc'], PKGCONF_PATCH_PREFIX);

src/Package/Target/curl.php

@@ -35,18 +35,16 @@ class curl
     #[BuildFor('Windows')]
     public function buildWin(LibraryPackage $lib): void
     {
-        $lib_dir = str_replace('\\', '/', $lib->getLibDir());
-        $zstd_lib = "{$lib_dir}/zstd_static.lib";
-        $extra_libs = "{$lib_dir}/libcrypto.lib {$lib_dir}/libssl.lib ws2_32.lib gdi32.lib advapi32.lib crypt32.lib user32.lib";
         WindowsCMakeExecutor::create($lib)
             ->optionalPackage('zstd', ...cmake_boolean_args('CURL_ZSTD'))
             ->optionalPackage('brotli', ...cmake_boolean_args('CURL_BROTLI'))
             ->addConfigureArgs(
                 '-DBUILD_CURL_EXE=ON',
-                '-DCMAKE_C_STANDARD_LIBRARIES=' . escapeshellarg($extra_libs),
+                '-DZSTD_LIBRARY=' . BUILD_LIB_PATH . '/zstd_static.lib',
-                '-DZSTD_LIBRARY=' . escapeshellarg($zstd_lib),
                 '-DBUILD_TESTING=OFF',
                 '-DBUILD_EXAMPLES=OFF',
+                '-DBUILD_LIBCURL_DOCS=OFF',
+                '-DENABLE_CURL_MANUAL=OFF',
                 '-DUSE_LIBIDN2=OFF',
                 '-DCURL_USE_LIBPSL=OFF',
                 '-DUSE_WINDOWS_SSPI=ON',
@@ -85,6 +83,9 @@ class curl
             ->addConfigureArgs(
                 '-DBUILD_CURL_EXE=ON',
                 '-DBUILD_LIBCURL_DOCS=OFF',
+                '-DBUILD_TESTING=OFF',
+                '-DBUILD_EXAMPLES=OFF',
+                '-DENABLE_CURL_MANUAL=OFF',
                 '-DOPENSSL_ROOT_DIR=' . BUILD_ROOT_PATH,
             )
             ->build();

src/Package/Target/php.php

@@ -328,49 +328,6 @@ class php extends TargetPackage
         return $info;
     }
 
-    public function getBuildManifestData(PackageInstaller $installer): array
-    {
-        if ($this->getName() !== 'php') {
-            return [];
-        }
-
-        $all_extensions = [];
-        $static_extensions = [];
-        $shared_extensions = [];
-        foreach ($installer->getResolvedPackages(PhpExtensionPackage::class) as $extension) {
-            $extension_name = $extension->getExtensionName();
-            if ($extension->isBuildStatic() || $extension->isBuildShared()) {
-                $all_extensions[] = $extension_name;
-            }
-            if ($extension->isBuildStatic()) {
-                $static_extensions[] = $extension_name;
-            }
-            if ($extension->isBuildShared()) {
-                $shared_extensions[] = $extension_name;
-            }
-        }
-
-        $sapis = array_values(array_filter([
-            $installer->isPackageResolved('php-cli') ? 'cli' : null,
-            $installer->isPackageResolved('php-fpm') ? 'fpm' : null,
-            $installer->isPackageResolved('php-micro') ? 'micro' : null,
-            $installer->isPackageResolved('php-cgi') ? 'cgi' : null,
-            $installer->isPackageResolved('php-embed') ? 'embed' : null,
-            $installer->isPackageResolved('frankenphp') ? 'frankenphp' : null,
-        ]));
-
-        return [
-            'version' => static::getPHPVersion(return_null_if_failed: true),
-            'thread-safety' => $this->getBuildOption('enable-zts', false) ? 'zts' : 'nts',
-            'sapis' => $sapis,
-            'extensions' => [
-                'all' => $all_extensions,
-                'static' => $static_extensions,
-                'shared' => $shared_extensions,
-            ],
-        ];
-    }
-
     #[BeforeStage('php', 'build')]
     public function beforeBuild(PackageBuilder $builder, Package $package): void
     {

src/Package/Target/php/frankenphp.php

@@ -26,55 +26,6 @@ use ZM\Logger\ConsoleColor;
 
 trait frankenphp
 {
-    /**
-     * Source of the -mthreads stripping shim, see windowsCgoCompilers(). The %s
-     * placeholder receives the wrapped compiler path as a C string literal.
-     */
-    private const string MTHREADS_SHIM_C = <<<'C'
-        // Generated by static-php-cli. Drops the MinGW-only -mthreads flag Go passes to
-        // cgo (golang/go#80290) and forwards everything else to clang.
-        #include <windows.h>
-        #include <wchar.h>
-        #include <stdlib.h>
-
-        static const wchar_t compiler[] = L"%s";
-
-        int main(void)
-        {
-            const wchar_t *args = GetCommandLineW();
-            // skip our own (possibly quoted) argv[0]
-            if (*args == L'"') {
-                args++;
-                while (*args && *args != L'"') args++;
-                if (*args) args++;
-            } else {
-                while (*args && *args != L' ' && *args != L'\t') args++;
-            }
-
-            // "<compiler>" + args + trailing space so a flag at the very end still matches
-            size_t len = wcslen(compiler) + wcslen(args) + 8;
-            wchar_t *cmd = calloc(len, sizeof(wchar_t));
-            if (cmd == NULL) return 1;
-            swprintf(cmd, len, L"\"%%ls\"%%ls ", compiler, args);
-
-            // remove every space-delimited -mthreads token
-            wchar_t *p;
-            while ((p = wcsstr(cmd, L" -mthreads ")) != NULL) {
-                wmemmove(p, p + 10, wcslen(p + 10) + 1);
-            }
-
-            STARTUPINFOW si = {sizeof(si)};
-            PROCESS_INFORMATION pi;
-            if (!CreateProcessW(NULL, cmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) {
-                return 127;
-            }
-            WaitForSingleObject(pi.hProcess, INFINITE);
-            DWORD code = 1;
-            GetExitCodeProcess(pi.hProcess, &code);
-            return (int) code;
-        }
-        C;
-
     #[Stage]
     public function buildFrankenphpForUnix(TargetPackage $package, PackageInstaller $installer, ToolchainInterface $toolchain, PackageBuilder $builder): void
     {
@@ -282,21 +233,10 @@ trait frankenphp
         $dep_libs = array_unique($dep_libs);
         $lib_dir = str_replace('\\', '/', BUILD_LIB_PATH);
         $php_embed_lib = "-lphp{$major}embed";
-        // pathcch: PathCchCanonicalizeEx etc. used by frankenphp/caddy path handling.
+        $win_sys_libs = '-lkernel32 -lole32 -luser32 -ladvapi32 -lshell32 -lws2_32 -ldnsapi -lpsapi -lbcrypt';
-        // secur32: InitSecurityInterfaceA (curl Schannel/SSPI). crypt32/gdi32: OpenSSL + Schannel.
-        $win_sys_libs = '-lkernel32 -lole32 -luser32 -ladvapi32 -lshell32 -lws2_32 -ldnsapi -lpsapi -lbcrypt -lpathcch -lsecur32 -lcrypt32 -lgdi32';
         $cgo_ldflags = clean_spaces(implode(' ', array_filter([
             "-L{$lib_dir}",
             $php_embed_lib,
-            // FrankenPHP's cgo code references PHP/lexbor/zend symbols via __declspec(dllimport).
-            // Their definitions live in php{N}embed.lib but are only pulled in if the plain symbol
-            // is referenced, so the __imp_ refs go unresolved. Force-include one symbol from each
-            // defining object (zend_atomic.obj, lexbor url.obj, lexbor idna.obj) to pull them in;
-            // lld then auto-imports the __imp_ refs. (/WHOLEARCHIVE would also drag in libxml2.res,
-            // which collides with Go's own resource object: "more than one resource obj file".)
-            '-Wl,/INCLUDE:zend_atomic_bool_store',
-            '-Wl,/INCLUDE:lxb_url_parse',
-            '-Wl,/INCLUDE:lxb_unicode_idna_init',
             implode(' ', $dep_libs),
             $win_sys_libs,
             '-llibcmt',
@@ -322,11 +262,10 @@ trait frankenphp
         // Fix: prepend clang's directory to PATH and use plain executable names instead,
         // which matches FrankenPHP's official CI approach (CC=clang, CXX=clang++).
         $clang_dir = dirname($clang_info['clang']);
-        [$cc, $cxx] = $this->windowsCgoCompilers($package, $clang_info['clang']);
         $env = [
             'CGO_ENABLED' => '1',
-            'CC' => $cc,
+            'CC' => 'clang.exe',
-            'CXX' => $cxx,
+            'CXX' => 'clang++.exe',
             'PATH' => $clang_dir . ';' . getenv('PATH'),
             'CGO_CFLAGS' => clean_spaces($cgo_cflags),
             'CGO_LDFLAGS' => $cgo_ldflags,
@@ -427,48 +366,6 @@ trait frankenphp
         }
     }
 
-    /**
-     * Return the [CC, CXX] cgo should use to build FrankenPHP on Windows.
-     *
-     * Go passes the MinGW-only `-mthreads` flag to the C compiler for cgo builds;
-     * Clang >= 20 rejects it for the MSVC target. When it does, wrap Clang with a
-     * small compiled shim that strips the flag before forwarding. An executable and
-     * not a .bat on purpose: batch files run through cmd.exe, which caps the command
-     * line at 8191 characters, and cgo link steps with big extension stacks (imagick)
-     * blow past that. A real process gets the full ~32K limit, and beyond that Go
-     * switches to a response file by itself.
-     *
-     * Workaround for https://github.com/golang/go/issues/80290, remove once Go
-     * stops passing the flag.
-     *
-     * @return array{0: string, 1: string}
-     */
-    protected function windowsCgoCompilers(TargetPackage $package, string $clang): array
-    {
-        $probe = $package->getSourceDir() . '\mthreads-probe.c';
-        file_put_contents($probe, "int main(void){return 0;}\n");
-        [$ret] = cmd()->execWithResult('"' . $clang . '" -mthreads -c ' . escapeshellarg($probe) . ' -o ' . escapeshellarg($probe . '.o'), false);
-        FileSystem::removeFileIfExists($probe);
-        FileSystem::removeFileIfExists($probe . '.o');
-        if ($ret === 0) {
-            return ['clang.exe', 'clang++.exe'];
-        }
-
-        logger()->info('Clang rejects -mthreads; wrapping it to strip the flag (golang/go#80290)');
-        $dir = dirname($clang);
-        $wrappers = [];
-        foreach (['cc-nothreads' => 'clang.exe', 'cxx-nothreads' => 'clang++.exe'] as $name => $compiler) {
-            $src = $package->getSourceDir() . "\\{$name}.c";
-            $exe = $package->getSourceDir() . "\\{$name}.exe";
-            file_put_contents($src, sprintf(self::MTHREADS_SHIM_C, str_replace('\\', '\\\\', "{$dir}\\{$compiler}")));
-            cmd()->cd($package->getSourceDir())
-                ->exec('"' . $clang . '" -O2 ' . escapeshellarg($src) . ' -o ' . escapeshellarg($exe));
-            $wrappers[] = $exe;
-        }
-
-        return $wrappers;
-    }
-
     protected function getFrankenPHPVersion(TargetPackage $package): string
     {
         if ($version = getenv('FRANKENPHP_VERSION')) {

src/Package/Target/php/unix.php

@@ -59,7 +59,7 @@ trait unix
         }
 
         if (self::getPHPVersionID() >= 80300 && self::getPHPVersionID() < 80400) {
-            SourcePatcher::patchFile('spc_fix_avx512_cache_before_80400.patch', $package->getSourceDir());
+            SourcePatcher::patchFile('spc_fix_avx512_cache_before_80400.patch', $this->getSourceDir());
         }
     }
 
@@ -289,7 +289,16 @@ trait unix
         $builder->deployBinary($package->getSourceDir() . '/sapi/micro/micro.sfx', $dst);
         // patch after UPX-ed micro.sfx (Linux only)
         if (SystemTarget::getTargetOS() === 'Linux' && $builder->getOption('with-upx-pack')) {
-            self::patchMicroUpxPackedBinary($dst);
+            // cut binary with readelf to remove UPX extra segment
+            [$ret, $out] = shell()->execWithResult("readelf -l {$dst} | awk '/LOAD|GNU_STACK/ {getline; print \\$1, \\$2, \\$3, \\$4, \\$6, \\$7}'");
+            $out[1] = explode(' ', $out[1]);
+            $offset = $out[1][0];
+            if ($ret !== 0 || !str_starts_with($offset, '0x')) {
+                throw new PatchException('phpmicro UPX patcher', 'Cannot find offset in readelf output');
+            }
+            $offset = hexdec($offset);
+            // remove upx extra wastes
+            file_put_contents($dst, substr(file_get_contents($dst), 0, $offset));
         }
         $package->setOutput('Binary path for micro SAPI', $dst);
     }
@@ -671,43 +680,6 @@ trait unix
         return $php;
     }
 
-    /**
-     * Remove the extra segment appended by UPX when packing phpmicro.
-     */
-    private static function patchMicroUpxPackedBinary(string $binaryPath): void
-    {
-        [$ret, $out] = shell()->execWithResult('readelf -W -l ' . escapeshellarg($binaryPath));
-        if ($ret !== 0) {
-            throw new PatchException('phpmicro UPX patcher', 'Cannot find offset in readelf output');
-        }
-
-        $fileSizes = [];
-        foreach ($out as $index => $line) {
-            $line = trim($line);
-            if (!preg_match('/^(LOAD|GNU_STACK)\s+/', $line)) {
-                continue;
-            }
-
-            $columns = preg_split('/\s+/', $line);
-            if (isset($columns[4]) && preg_match('/^0x[[:xdigit:]]+$/', $columns[4]) === 1) {
-                $fileSizes[] = $columns[4];
-                continue;
-            }
-
-            $next = $out[$index + 1] ?? '';
-            if (preg_match('/^\s*(0x[[:xdigit:]]+)\s+0x[[:xdigit:]]+/', $next, $matches)) {
-                $fileSizes[] = $matches[1];
-            }
-        }
-
-        $offset = $fileSizes[1] ?? null;
-        if ($offset === null) {
-            throw new PatchException('phpmicro UPX patcher', 'Cannot find offset in readelf output');
-        }
-
-        file_put_contents($binaryPath, substr(file_get_contents($binaryPath), 0, intval(hexdec($offset))));
-    }
-
     /**
      * Rename libphp.so to libphp-<release>.so if -release is set in LDFLAGS.
      */

src/Package/Target/php/windows.php

@@ -4,7 +4,6 @@ declare(strict_types=1);
 
 namespace Package\Target\php;
 
-use Package\Target\php;
 use StaticPHP\Attribute\Package\BeforeStage;
 use StaticPHP\Attribute\Package\BuildFor;
 use StaticPHP\Attribute\Package\Stage;
@@ -127,10 +126,7 @@ trait windows
             throw new PatchException('Windows Makefile patching for php.exe target', 'Cannot patch windows CLI Makefile, Makefile does not contain "$(BUILD_DIR)\php.exe:" line');
         }
         $lines[$line_num] = '$(BUILD_DIR)\php.exe: generated_files $(DEPS_CLI) $(PHP_GLOBAL_OBJS) $(CLI_GLOBAL_OBJS) $(STATIC_EXT_OBJS) $(ASM_OBJS) $(BUILD_DIR)\php.exe.res $(BUILD_DIR)\php.exe.manifest';
-        // /FORCE:MULTIPLE: extensions may bundle their own static copies of common libraries (e.g.
+        $lines[$line_num + 1] = "\t" . '"$(LINK)" /nologo $(PHP_GLOBAL_OBJS_RESP) $(CLI_GLOBAL_OBJS_RESP) $(STATIC_EXT_OBJS_RESP) $(STATIC_EXT_LIBS) $(ASM_OBJS) $(LIBS) $(LIBS_CLI) $(BUILD_DIR)\php.exe.res /out:$(BUILD_DIR)\php.exe $(LDFLAGS) $(LDFLAGS_CLI) /ltcg /nodefaultlib:msvcrt /nodefaultlib:msvcrtd /ignore:4286';
-        // imagick's ImageMagick ships its own zlib/png/jpeg, duplicating gd's); let the first
-        // definition win instead of failing with LNK2005. /ignore:4006 silences the resulting noise.
-        $lines[$line_num + 1] = "\t" . '"$(LINK)" /nologo $(PHP_GLOBAL_OBJS_RESP) $(CLI_GLOBAL_OBJS_RESP) $(STATIC_EXT_OBJS_RESP) $(STATIC_EXT_LIBS) $(ASM_OBJS) $(LIBS) $(LIBS_CLI) $(BUILD_DIR)\php.exe.res /out:$(BUILD_DIR)\php.exe $(LDFLAGS) $(LDFLAGS_CLI) /ltcg /nodefaultlib:msvcrt /nodefaultlib:msvcrtd /ignore:4286 /FORCE:MULTIPLE /ignore:4006';
         FileSystem::writeFile("{$package->getSourceDir()}\\Makefile", implode("\r\n", $lines));
     }
 
@@ -175,9 +171,8 @@ trait windows
             }
         }
 
-        $libs_cli = $this->makeLibsResponseFile($package, 'cli', "ws2_32.lib shell32.lib {$extra_libs}");
         cmd()->cd($package->getSourceDir())
-            ->exec("nmake /nologo {$debug_overrides}LIBS_CLI=\"{$libs_cli}\" EXTRA_LD_FLAGS_PROGRAM= php.exe");
+            ->exec("nmake /nologo {$debug_overrides}LIBS_CLI=\"ws2_32.lib shell32.lib {$extra_libs}\" EXTRA_LD_FLAGS_PROGRAM= php.exe");
 
         $this->deployWindowsBinary($builder, $package, 'php-cli');
     }
@@ -202,10 +197,7 @@ trait windows
             throw new PatchException('Windows Makefile patching for php-cgi.exe target', 'Cannot patch windows CGI Makefile, Makefile does not contain "$(BUILD_DIR)\php-cgi.exe:" line');
         }
         $lines[$line_num] = '$(BUILD_DIR)\php-cgi.exe: $(DEPS_CGI) $(CGI_GLOBAL_OBJS) $(PHP_GLOBAL_OBJS) $(STATIC_EXT_OBJS) $(ASM_OBJS) $(BUILD_DIR)\php-cgi.exe.res $(BUILD_DIR)\php-cgi.exe.manifest';
-        // /FORCE:MULTIPLE /ignore:4006: same reason as the php.exe target above. Without it the
+        $lines[$line_num + 1] = "\t" . '@"$(LINK)" /nologo $(PHP_GLOBAL_OBJS_RESP) $(CGI_GLOBAL_OBJS_RESP) $(STATIC_EXT_OBJS_RESP) $(STATIC_EXT_LIBS) $(ASM_OBJS) $(LIBS) $(LIBS_CGI) $(BUILD_DIR)\php-cgi.exe.res /out:$(BUILD_DIR)\php-cgi.exe $(LDFLAGS) $(LDFLAGS_CGI) /ltcg /nodefaultlib:msvcrt /nodefaultlib:msvcrtd /ignore:4286';
-        // CGI link fails with LNK2005 (e.g. imagick's MagickCore defines gettimeofday, which
-        // php's time.obj also defines).
-        $lines[$line_num + 1] = "\t" . '@"$(LINK)" /nologo $(PHP_GLOBAL_OBJS_RESP) $(CGI_GLOBAL_OBJS_RESP) $(STATIC_EXT_OBJS_RESP) $(STATIC_EXT_LIBS) $(ASM_OBJS) $(LIBS) $(LIBS_CGI) $(BUILD_DIR)\php-cgi.exe.res /out:$(BUILD_DIR)\php-cgi.exe $(LDFLAGS) $(LDFLAGS_CGI) /ltcg /nodefaultlib:msvcrt /nodefaultlib:msvcrtd /ignore:4286 /FORCE:MULTIPLE /ignore:4006';
         FileSystem::writeFile("{$package->getSourceDir()}\\Makefile", implode("\r\n", $lines));
 
         // Patch cgi-static, comment ZEND_TSRMLS_CACHE_DEFINE()
@@ -246,9 +238,8 @@ trait windows
             }
         }
 
-        $libs_cgi = $this->makeLibsResponseFile($package, 'cgi', "ws2_32.lib kernel32.lib advapi32.lib {$extra_libs}");
         cmd()->cd($package->getSourceDir())
-            ->exec("nmake /nologo {$debug_overrides}LIBS_CGI=\"{$libs_cgi}\" EXTRA_LD_FLAGS_PROGRAM= php-cgi.exe");
+            ->exec("nmake /nologo {$debug_overrides}LIBS_CGI=\"ws2_32.lib kernel32.lib advapi32.lib {$extra_libs}\" EXTRA_LD_FLAGS_PROGRAM= php-cgi.exe");
 
         $this->deployWindowsBinary($builder, $package, 'php-cgi');
     }
@@ -273,19 +264,6 @@ trait windows
         }
     }
 
-    #[BeforeStage('php', [self::class, 'makeMicroForWindows'])]
-    #[PatchDescription('Add /FORCE:MULTIPLE to the micro.sfx link, matching the CLI and CGI targets')]
-    public function patchMicroTarget(TargetPackage $package): void
-    {
-        $makefile = "{$package->getSourceDir()}\\Makefile";
-        if (str_contains(FileSystem::readFile($makefile), 'LDFLAGS_MICRO=/FORCE:MULTIPLE')) {
-            return;
-        }
-        // Same reason as the php.exe and php-cgi.exe targets: extension-bundled libs duplicate
-        // symbols from php's own objects and the link fails with LNK2005.
-        FileSystem::replaceFileStr($makefile, "\r\nLDFLAGS_MICRO=", "\r\nLDFLAGS_MICRO=/FORCE:MULTIPLE /ignore:4006 ");
-    }
-
     #[Stage]
     public function makeMicroForWindows(TargetPackage $package, PackageBuilder $builder, PackageInstaller $installer): void
     {
@@ -333,9 +311,8 @@ trait windows
 
         $fake_cli = $package->getBuildOption('with-micro-fake-cli', false) ? ' /DPHP_MICRO_FAKE_CLI' : '';
 
-        $libs_micro = $this->makeLibsResponseFile($package, 'micro', "ws2_32.lib shell32.lib {$extra_libs}");
         cmd()->cd($package->getSourceDir())
-            ->exec("nmake /nologo {$debug_overrides}LIBS_MICRO=\"{$libs_micro}\" CFLAGS_MICRO=\"/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1{$fake_cli}\" EXTRA_LD_FLAGS_PROGRAM= micro");
+            ->exec("nmake /nologo {$debug_overrides}LIBS_MICRO=\"ws2_32.lib shell32.lib {$extra_libs}\" CFLAGS_MICRO=\"/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1{$fake_cli}\" EXTRA_LD_FLAGS_PROGRAM= micro");
 
         $this->deployWindowsBinary($builder, $package, 'php-micro');
     }
@@ -737,18 +714,12 @@ C_CODE;
         // MSVC cl.exe format: compiler flags must come before /link, linker flags after
         // ldflags contains /LIBPATH which must be after /link
         // /FORCE:MULTIPLE: in ZTS mode both zend.obj and php_embed.obj (both packed into the fat php8embed.lib) define _tsrm_ls_cache as a __declspec(thread) variable.
-        // /INCLUDE: php8embed.lib's ext/uri (uri_parser_whatwg.obj) references lexbor lxb_url_*/
-        // lxb_unicode_idna_* via __declspec(dllimport); their definitions live in url.obj/idna.obj
-        // but are only pulled in if the plain symbol is referenced. Force-include one symbol from
-        // each so the objects are linked and the __imp_ refs auto-import. (FrankenPHP needs the same.)
-        // System libs add pathcch (PathCchCanonicalizeEx), secur32 (curl Schannel InitSecurityInterface),
-        // crypt32/gdi32 (OpenSSL + Schannel) on top of the Makefile LIBS set.
         $compile_cmd = sprintf(
-            'cl.exe /nologo /O2 /MT /Z7 %s embed.c /Fe:embed.exe /link /FORCE:MULTIPLE /INCLUDE:lxb_url_parse /INCLUDE:lxb_unicode_idna_init /LIBPATH:"%s\lib" %s %s',
+            'cl.exe /nologo /O2 /MT /Z7 %s embed.c /Fe:embed.exe /link /FORCE:MULTIPLE /LIBPATH:"%s\lib" %s %s',
             $include_flags,
             BUILD_ROOT_PATH,
             $config['libs'],
-            'kernel32.lib ole32.lib user32.lib advapi32.lib shell32.lib ws2_32.lib dnsapi.lib psapi.lib bcrypt.lib pathcch.lib secur32.lib crypt32.lib gdi32.lib'  // Windows system libs (match Makefile LIBS) + curl/openssl deps
+            'kernel32.lib ole32.lib user32.lib advapi32.lib shell32.lib ws2_32.lib dnsapi.lib psapi.lib bcrypt.lib'  // Windows system libs (match Makefile LIBS)
         );
 
         // Log command explicitly (workaround for cmd() not logging complex commands properly)
@@ -762,11 +733,9 @@ C_CODE;
             );
         }
 
-        // Run the embed test. Use a ".\" prefix: cmd.exe does not resolve a bare "embed.exe" from
+        // Run the embed test
-        // the current directory, while the cwd must remain $test_dir so the script's relative
-        // "embed.php" is found.
         InteractiveTerm::setMessage('Running php-embed run smoke test');
-        [$ret, $output] = cmd()->cd($test_dir)->execWithResult('.\embed.exe');
+        [$ret, $output] = cmd()->cd($test_dir)->execWithResult('embed.exe');
         $raw_output = implode('', $output);
         if ($ret !== 0 || trim($raw_output) !== 'hello') {
             throw new ValidationException(
@@ -887,17 +856,4 @@ C_CODE;
 
         $package->setOutput('PHP headers path for embed SAPI', $php_include_dir);
     }
-
-    /**
-     * Write the collected lib list into a linker response file and return the @file
-     * token for the nmake command line. With big extension stacks (imagick alone pulls
-     * in ~60 static libs) the inline list can push the whole command past cmd.exe's
-     * 8191 character limit; link.exe reads @file without any length limit.
-     */
-    private function makeLibsResponseFile(TargetPackage $package, string $sapi, string $libs): string
-    {
-        $file = "{$package->getSourceDir()}\\spc-libs-{$sapi}.rsp";
-        FileSystem::writeFile($file, $libs);
-        return "@{$file}";
-    }
 }

src/StaticPHP/Artifact/ArtifactExtractor.php

@@ -228,27 +228,6 @@ class ArtifactExtractor
         $mode = $extract_config['mode'];
 
         if ($mode === 'selective') {
-            // Check if all destination files already exist before extracting
-            $all_files_exist = true;
-            foreach ($extract_config['files'] as $src_pattern => $dst_path) {
-                $resolved = $this->replacePathVariables($dst_path);
-                // For glob patterns, check if at least the parent directory exists
-                if (str_contains($src_pattern, '*')) {
-                    $parent = dirname($resolved);
-                    if (!is_dir($parent)) {
-                        $all_files_exist = false;
-                        break;
-                    }
-                } elseif (!file_exists($resolved) && !is_dir($resolved)) {
-                    $all_files_exist = false;
-                    break;
-                }
-            }
-            if ($all_files_exist) {
-                logger()->debug("Binary [{$name}] already extracted (selective), skip.");
-                return SPC_STATUS_ALREADY_EXTRACTED;
-            }
-
             $this->doSelectiveExtract($name, $cache_info, $extract_config['files']);
             $artifact->emitAfterBinaryExtract($target_path, $platform);
             logger()->debug("Emitted after-binary-extract hooks for [{$name}]");
@@ -272,14 +251,8 @@ class ArtifactExtractor
         logger()->debug("Emitted after-binary-extract hooks for [{$name}]");
 
         /* @phpstan-ignore-next-line */
-        if ($hash !== null) {
+        if ($hash !== null && $cache_info['cache_type'] !== 'file') {
-            // Directory targets: store hash inside the directory
+            FileSystem::writeFile("{$target_path}/.spc-hash", $hash);
-            if (is_dir($target_path)) {
-                FileSystem::writeFile("{$target_path}/.spc-hash", $hash);
-            } elseif (is_file($target_path)) {
-                // File targets: store hash as a sidecar file (e.g., meson .whl)
-                FileSystem::writeFile("{$target_path}.spc-hash", $hash);
-            }
         }
         return SPC_STATUS_EXTRACTED;
     }
@@ -359,24 +332,9 @@ class ArtifactExtractor
 
     /**
      * Check if artifact is already extracted with correct hash.
-     *
-     * Handles both directory targets (hash stored in $path/.spc-hash) and
-     * file targets (hash stored in $path.spc-hash sidecar).
      */
     protected function isAlreadyExtracted(string $path, ?string $expected_hash): bool
     {
-        // File targets: check sidecar hash file (e.g., meson .whl)
-        if (is_file($path)) {
-            if ($expected_hash === null) {
-                return false;
-            }
-            $hash_file = "{$path}.spc-hash";
-            if (!file_exists($hash_file)) {
-                return false;
-            }
-            return FileSystem::readFile($hash_file) === $expected_hash;
-        }
-
         if (!is_dir($path)) {
             return false;
         }

src/StaticPHP/Command/Dev/GenExtTestMatrixCommand.php

@@ -14,12 +14,6 @@ class GenExtTestMatrixCommand extends BaseCommand
 {
     private const string BUILD_TARGETS = '--build-cli --build-cgi --build-micro --with-suggests -vvv';
 
-    private const string FRANKENPHP_BUILD_TARGETS = '--build-cli --build-frankenphp --enable-zts --with-suggests -vvv';
-
-    private const array SUPPORTED_SAPIS = [
-        'frankenphp',
-    ];
-
     private const array OS_RUNNERS = [
         'linux' => ['arch' => 'x86_64', 'runner' => 'ubuntu-latest', 'os_key' => 'Linux'],
         'windows' => ['arch' => 'x86_64', 'runner' => 'windows-2025', 'os_key' => 'Windows'],
@@ -90,7 +84,6 @@ class GenExtTestMatrixCommand extends BaseCommand
         $this->addOption('for-extensions', null, InputOption::VALUE_OPTIONAL, 'Filter by extension display names, comma-separated', '')
             ->addOption('for-libs', null, InputOption::VALUE_OPTIONAL, 'Filter by lib names (depends+suggests), comma-separated', '')
             ->addOption('os', null, InputOption::VALUE_OPTIONAL, 'Filter by OS (Linux/Darwin/Windows), comma-separated', '')
-            ->addOption('sapi', null, InputOption::VALUE_OPTIONAL, 'Add extra SAPI build tests, comma-separated (supported: frankenphp)', '')
             ->addOption('tier2', null, InputOption::VALUE_NONE, 'Use Tier 2 runners (Linux aarch64 + macOS x86_64, no Windows)');
     }
 
@@ -105,15 +98,8 @@ class GenExtTestMatrixCommand extends BaseCommand
         $filter_extensions = $parse_option('for-extensions');
         $filter_libs = $parse_option('for-libs');
         $filter_os_keys = $parse_option('os');
-        $filter_sapis = array_unique($parse_option('sapi'));
         $tier2 = (bool) $this->input->getOption('tier2');
 
-        $unknown_sapis = array_values(array_diff($filter_sapis, self::SUPPORTED_SAPIS));
-        if (!empty($unknown_sapis)) {
-            $this->output->writeln('<error>Unsupported SAPI(s): ' . implode(', ', $unknown_sapis) . '</error>');
-            return static::USER_ERROR;
-        }
-
         $base_runners = $tier2 ? self::OS_RUNNERS_TIER2 : self::OS_RUNNERS;
 
         $all = PackageConfig::getAll();
@@ -140,67 +126,6 @@ class GenExtTestMatrixCommand extends BaseCommand
             }
         }
 
-        [$entries, $all_ext_lib_deps] = $this->buildEntriesForRunners(
-            $base_runners,
-            $filter_os_keys,
-            $all_regular,
-            $all_virtual,
-            $all_libraries,
-            self::BUILD_TARGETS,
-            'default',
-        );
-
-        if (in_array('frankenphp', $filter_sapis, true)) {
-            [$frankenphp_entries, $frankenphp_ext_lib_deps] = $this->buildEntriesForRunners(
-                self::OS_RUNNERS,
-                [],
-                $all_regular,
-                $all_virtual,
-                $all_libraries,
-                self::FRANKENPHP_BUILD_TARGETS,
-                'frankenphp',
-            );
-            $entries = array_merge($entries, $frankenphp_entries);
-            $all_ext_lib_deps = array_replace_recursive($all_ext_lib_deps, $frankenphp_ext_lib_deps);
-        }
-
-        if (!empty($filter_extensions) || !empty($filter_libs)) {
-            $entries = array_values(array_filter($entries, function (array $entry) use ($filter_extensions, $filter_libs, $all_ext_lib_deps): bool {
-                $names = explode(',', $entry['extension']);
-
-                if (!empty($filter_extensions) && count(array_intersect($names, $filter_extensions)) > 0) {
-                    return true;
-                }
-
-                if (!empty($filter_libs)) {
-                    $lib_deps = $all_ext_lib_deps[$entry['os']] ?? [];
-                    foreach ($names as $name) {
-                        if (count(array_intersect($lib_deps[$name] ?? [], $filter_libs)) > 0) {
-                            return true;
-                        }
-                    }
-                }
-
-                return false;
-            }));
-        }
-
-        $this->output->write(json_encode($entries, JSON_UNESCAPED_SLASHES));
-        return static::SUCCESS;
-    }
-
-    /**
-     * @return array{array<int, array<string, string>>, array<string, array<string, string[]>>}
-     */
-    private function buildEntriesForRunners(
-        array $base_runners,
-        array $filter_os_keys,
-        array $all_regular,
-        array $all_virtual,
-        array $all_libraries,
-        string $build_targets,
-        string $sapi,
-    ): array {
         $os_runners = empty($filter_os_keys)
             ? $base_runners
             : array_filter($base_runners, fn ($info) => in_array($info['os_key'], $filter_os_keys, true));
@@ -312,18 +237,40 @@ class GenExtTestMatrixCommand extends BaseCommand
 
             sort($groups);
             foreach ($groups as $group) {
+                $extra = $this->extraBuildFlags($group);
                 $entries[] = [
                     'runner' => $os_info['runner'],
                     'os' => $os,
                     'arch' => $os_info['arch'],
-                    'sapi' => $sapi,
                     'extension' => $group,
-                    'build-args' => './bin/spc build "' . $group . '" ' . $this->buildTargetsWithExtraFlags($build_targets, $group),
+                    'build-args' => './bin/spc build "' . $group . '" ' . self::BUILD_TARGETS . ($extra !== '' ? ' ' . $extra : ''),
                 ];
             }
         }
 
-        return [$entries, $all_ext_lib_deps];
+        if (!empty($filter_extensions) || !empty($filter_libs)) {
+            $entries = array_values(array_filter($entries, function (array $entry) use ($filter_extensions, $filter_libs, $all_ext_lib_deps): bool {
+                $names = explode(',', $entry['extension']);
+
+                if (!empty($filter_extensions) && count(array_intersect($names, $filter_extensions)) > 0) {
+                    return true;
+                }
+
+                if (!empty($filter_libs)) {
+                    $lib_deps = $all_ext_lib_deps[$entry['os']] ?? [];
+                    foreach ($names as $name) {
+                        if (count(array_intersect($lib_deps[$name] ?? [], $filter_libs)) > 0) {
+                            return true;
+                        }
+                    }
+                }
+
+                return false;
+            }));
+        }
+
+        $this->output->write(json_encode($entries, JSON_UNESCAPED_SLASHES));
+        return static::SUCCESS;
     }
 
     /**
@@ -450,18 +397,6 @@ class GenExtTestMatrixCommand extends BaseCommand
         return implode(' ', $flags);
     }
 
-    private function buildTargetsWithExtraFlags(string $build_targets, string $group): string
-    {
-        $flags = explode(' ', $build_targets);
-        foreach (explode(' ', $this->extraBuildFlags($group)) as $extra) {
-            if ($extra === '' || in_array($extra, $flags, true)) {
-                continue;
-            }
-            $flags[] = $extra;
-        }
-        return implode(' ', $flags);
-    }
-
     /**
      * Resolve the value of a platform-specific array field, applying the suffix fallback chain.
      *

src/StaticPHP/Command/Dev/TestBotCommand.php

@@ -25,10 +25,6 @@ class TestBotCommand extends BaseCommand
 
     private const string TIER2_LABEL = 'test/tier2';
 
-    private const array SAPI_LABELS = [
-        'sapi/frankenphp' => 'frankenphp',
-    ];
-
     /** PHP version labels → version string (8.5 is always included as default) */
     private const array PHP_VERSION_LABELS = [
         'test/php-83' => '8.3',
@@ -97,12 +93,6 @@ class TestBotCommand extends BaseCommand
         }
         $tier2 = in_array(self::TIER2_LABEL, $label_names, true);
         $need_test = in_array('need-test', $label_names, true);
-        $sapis = [];
-        foreach (self::SAPI_LABELS as $label => $sapi) {
-            if (in_array($label, $label_names, true)) {
-                $sapis[] = $sapi;
-            }
-        }
 
         // Resolve PHP versions (default always included)
         $php_versions = [self::DEFAULT_PHP_VERSION];
@@ -129,9 +119,6 @@ class TestBotCommand extends BaseCommand
             if (!empty($os_keys)) {
                 $flag_parts[] = '--os=' . implode(',', $os_keys);
             }
-            if (!empty($sapis)) {
-                $flag_parts[] = '--sapi=' . implode(',', $sapis);
-            }
             $gen_matrix_args = implode(' ', $flag_parts);
 
             if ($tier2) {
@@ -141,7 +128,7 @@ class TestBotCommand extends BaseCommand
                     fn ($k) => $k !== 'Windows'
                 ));
                 if (!empty($tier2_os)) {
-                    $tier2_parts = array_values(array_filter($flag_parts, fn ($f) => !str_starts_with($f, '--os=') && !str_starts_with($f, '--sapi=')));
+                    $tier2_parts = array_values(array_filter($flag_parts, fn ($f) => !str_starts_with($f, '--os=')));
                     $tier2_parts[] = '--os=' . implode(',', $tier2_os);
                     $tier2_parts[] = '--tier2';
                     $gen_matrix_args_tier2 = implode(' ', $tier2_parts);
@@ -156,7 +143,6 @@ class TestBotCommand extends BaseCommand
             $label_names,
             $os_keys,
             $tier2,
-            $sapis,
             $php_versions,
             $need_test,
         );
@@ -170,7 +156,6 @@ class TestBotCommand extends BaseCommand
             'gen_matrix_args_tier2' => $gen_matrix_args_tier2,
             'php_versions' => $php_versions,
             'tier2' => $tier2,
-            'sapis' => $sapis,
             'comment_body' => $comment_body,
         ];
 
@@ -254,7 +239,6 @@ class TestBotCommand extends BaseCommand
         array $label_names,
         array $os_keys,
         bool $tier2,
-        array $sapis,
         array $php_versions,
         bool $need_test,
     ): string {
@@ -274,7 +258,6 @@ class TestBotCommand extends BaseCommand
             '`test/linux` `test/windows` `test/macos` (platform)',
             '`test/tier2` (extra arch)',
             '`test/php-83` `test/php-84` (PHP version)',
-            '`sapi/frankenphp` (extra FrankenPHP SAPI build)',
         ]);
 
         // Case 1: need-test absent → invite the author to add it
@@ -320,8 +303,7 @@ class TestBotCommand extends BaseCommand
         }
 
         $php_str = implode(', ', array_map(fn ($v) => "PHP {$v}", $php_versions)) . ' NTS';
-        $sapi_str = !empty($sapis) ? ' + SAPI: ' . implode(', ', $sapis) . ' (Tier1 Linux/macOS/Windows)' : '';
+        $active_test_labels = array_values(array_filter($label_names, fn ($l) => str_starts_with($l, 'test/')));
-        $active_test_labels = array_values(array_filter($label_names, fn ($l) => str_starts_with($l, 'test/') || str_starts_with($l, 'sapi/')));
         $labels_str = !empty($active_test_labels) ? '`' . implode('`, `', $active_test_labels) . '`' : '_none_';
 
         return implode("\n", [
@@ -331,7 +313,7 @@ class TestBotCommand extends BaseCommand
             $detected,
             '**Active labels**: ' . $labels_str,
             '**Available labels**: ' . $available_labels,
-            '**Config**: ' . implode(' + ', $platform_parts) . ' | ' . $php_str . $sapi_str,
+            '**Config**: ' . implode(' + ', $platform_parts) . ' | ' . $php_str,
         ]);
     }
 }

src/StaticPHP/Doctor/Item/WindowsToolCheck.php

@@ -12,6 +12,7 @@ use StaticPHP\Package\PackageInstaller;
 use StaticPHP\Runtime\SystemTarget;
 use StaticPHP\Toolchain\ToolchainManager;
 use StaticPHP\Util\FileSystem;
+use StaticPHP\Util\GlobalEnvManager;
 use StaticPHP\Util\System\WindowsUtil;
 
 #[OptionalCheck([self::class, 'optional'])]
@@ -73,6 +74,27 @@ class WindowsToolCheck
         return CheckResult::ok($path);
     }
 
+    #[CheckItem('if nasm installed', level: 995)]
+    public function checkNasm(): ?CheckResult
+    {
+        if (($a = WindowsUtil::findCommand('nasm.exe')) === null) {
+            return CheckResult::fail('nasm.exe not found in path.', 'install-nasm');
+        }
+        return CheckResult::ok($a);
+    }
+
+    #[CheckItem('if perl(strawberry) installed', limit_os: 'Windows', level: 994)]
+    public function checkPerl(): ?CheckResult
+    {
+        if (($path = WindowsUtil::findCommand('perl.exe')) === null) {
+            return CheckResult::fail('perl not found in path.', 'install-perl');
+        }
+        if (!str_contains(implode('', cmd()->execWithResult(quote($path) . ' -v', false)[1]), 'MSWin32')) {
+            return CheckResult::fail($path . ' is not built for msvc.', 'install-perl');
+        }
+        return CheckResult::ok($path);
+    }
+
     #[CheckItem('if environment is properly set up', level: 1)]
     public function checkenv(): ?CheckResult
     {
@@ -91,6 +113,16 @@ class WindowsToolCheck
         return CheckResult::ok();
     }
 
+    #[FixItem('install-perl')]
+    public function installPerl(): bool
+    {
+        $installer = new PackageInstaller();
+        $installer->addInstallPackage('strawberry-perl');
+        $installer->run(true);
+        GlobalEnvManager::addPathIfNotExists(PKG_ROOT_PATH . '\strawberry-perl');
+        return true;
+    }
+
     #[FixItem('install-msys2-build-essentials')]
     public function installMsys2(): bool
     {
@@ -109,6 +141,15 @@ class WindowsToolCheck
         return true;
     }
 
+    #[FixItem('install-nasm')]
+    public function installNasm(): bool
+    {
+        $installer = new PackageInstaller(interactive: false);
+        $installer->addInstallPackage('nasm');
+        $installer->run(true);
+        return true;
+    }
+
     #[FixItem('install-vswhere')]
     public function installVSWhere(): bool
     {

src/StaticPHP/Exception/ExceptionHandler.php

@@ -111,7 +111,7 @@ class ExceptionHandler
 
     private static function logError($message, int $indent_space = 0, bool $output_log = true, string $color = 'red'): void
     {
-        $spc_log = spc_log_stream(SPC_OUTPUT_LOG);
+        $spc_log = fopen(SPC_OUTPUT_LOG, 'a');
         $msg = explode("\n", (string) $message);
         foreach ($msg as $v) {
             $line = str_pad($v, strlen($v) + $indent_space, ' ', STR_PAD_LEFT);

src/StaticPHP/Package/PackageInstaller.php

@@ -15,7 +15,6 @@ use StaticPHP\Exception\EnvironmentException;
 use StaticPHP\Exception\WrongUsageException;
 use StaticPHP\Registry\PackageLoader;
 use StaticPHP\Runtime\SystemTarget;
-use StaticPHP\Util\BuildManifestDumper;
 use StaticPHP\Util\BuildRootTracker;
 use StaticPHP\Util\DependencyResolver;
 use StaticPHP\Util\DirDiff;
@@ -283,11 +282,6 @@ class PackageInstaller
         // pipeline above (they were merged into $this->packages in resolvePackages()). This only
         // throws if a tool genuinely failed to become available (e.g. no artifact for this platform).
         $this->ensureRequiredTools();
-
-        // Pure install operations must not overwrite the manifest of an existing build.
-        if ($this->build_packages !== []) {
-            new BuildManifestDumper()->dump($this->packages, $this->build_packages, $this->install_packages, $this);
-        }
     }
 
     public function isBuildPackage(Package|string $package): bool

src/StaticPHP/Package/TargetPackage.php

@@ -117,19 +117,6 @@ class TargetPackage extends LibraryPackage
         return null;
     }
 
-    /**
-     * Get target-specific structured data for the build manifest.
-     *
-     * Target implementations may override this method to expose build facts that
-     * cannot be represented by the generic resolved package list.
-     *
-     * @return array<string, mixed>
-     */
-    public function getBuildManifestData(PackageInstaller $installer): array
-    {
-        return [];
-    }
-
     /**
      * Gets all build options for the target package.
      *

src/StaticPHP/Runtime/Shell/DefaultShell.php

@@ -4,7 +4,6 @@ declare(strict_types=1);
 
 namespace StaticPHP\Runtime\Shell;
 
-use StaticPHP\Exception\ExecutionException;
 use StaticPHP\Exception\InterruptException;
 use StaticPHP\Exception\SPCInternalException;
 use StaticPHP\Runtime\SystemTarget;
@@ -154,7 +153,7 @@ class DefaultShell extends Shell
 
         $this->logCommandInfo($cmd);
         logger()->debug("[TAR EXTRACT] {$cmd}");
-        $this->passthruTolerateSymlinks($cmd);
+        $this->passthru($cmd, $this->console_putput);
         return true;
     }
 
@@ -201,7 +200,7 @@ class DefaultShell extends Shell
         $run = function ($cmd) {
             $this->logCommandInfo($cmd);
             logger()->debug("[7Z EXTRACT] {$cmd}");
-            $this->passthruTolerateSymlinks($cmd);
+            $this->passthru($cmd, $this->console_putput);
         };
 
         $extname = FileSystem::extname($archive_path);
@@ -215,67 +214,4 @@ class DefaultShell extends Shell
 
         return true;
     }
-
-    /**
-     * Run an extraction command, tolerating symbolic links that the host cannot create.
-     *
-     * Windows tar.exe (bsdtar) cannot create the symbolic links some archives ship (e.g. zstd's
-     * tests/cli-tests/bin/unzstd -> zstd), failing each with "Can't create '...': Invalid argument"
-     * and exiting non-zero. Those entries are never needed to build, so on Windows we swallow a
-     * failure whose only errors are such symlink creations and continue. Any other failure still throws.
-     */
-    private function passthruTolerateSymlinks(string $cmd): void
-    {
-        // Symlink creation only fails on a Windows host; elsewhere extraction handles symlinks fine.
-        if (PHP_OS_FAMILY !== 'Windows') {
-            $this->passthru($cmd, $this->console_putput);
-            return;
-        }
-
-        $result = $this->passthru($cmd, $this->console_putput, capture_output: true, throw_on_error: false);
-        if ($result['code'] === 0) {
-            return;
-        }
-        if ($this->isSymlinkOnlyExtractFailure($result['output'])) {
-            logger()->warning('Some symbolic links could not be created during extraction and were skipped (not supported on this Windows host). This is harmless for building.');
-            return;
-        }
-        throw new ExecutionException(
-            cmd: $cmd,
-            message: "Command exited with non-zero code: {$result['code']}",
-            code: $result['code'],
-            cd: $this->cd,
-            env: $this->env,
-        );
-    }
-
-    /**
-     * Decide whether an extraction failure was caused solely by symbolic links that could not be
-     * created on Windows. Returns true only when at least one such error is present and no other
-     * error-looking output is found, so genuine extraction failures still propagate.
-     */
-    private function isSymlinkOnlyExtractFailure(string $output): bool
-    {
-        $saw_symlink_error = false;
-        foreach (preg_split('/\r\n|\r|\n/', $output) ?: [] as $line) {
-            $line = trim($line);
-            if ($line === '') {
-                continue;
-            }
-            // bsdtar's trailing summary line; not an error on its own.
-            if (str_contains($line, 'Error exit delayed from previous errors')) {
-                continue;
-            }
-            // The symlink (or other unsupported special file) that Windows refused to create.
-            if (str_contains($line, "Can't create") && str_contains($line, 'Invalid argument')) {
-                $saw_symlink_error = true;
-                continue;
-            }
-            // Any other error-looking line means this was not a clean symlink-only failure.
-            if (preg_match('/\berror\b|cannot|can\'t|failed|denied|no space|not permitted/i', $line)) {
-                return false;
-            }
-        }
-        return $saw_symlink_error;
-    }
 }

src/StaticPHP/Runtime/Shell/Shell.php

@@ -114,8 +114,8 @@ abstract class Shell
         if (!$this->enable_log_file) {
             return;
         }
-        // write executed command to log file using spc_write_log (shared handle, see spc_log_stream)
+        // write executed command to log file using spc_write_log
-        $log_file = spc_log_stream(SPC_SHELL_LOG);
+        $log_file = fopen(SPC_SHELL_LOG, 'a');
         spc_write_log($log_file, "\n>>>>>>>>>>>>>>>>>>>>>>>>>> [" . date('Y-m-d H:i:s') . "]\n");
         spc_write_log($log_file, "> Executing command: {$cmd}\n");
         // get the backtrace to find the file and line number
@@ -154,8 +154,8 @@ abstract class Shell
     ): array {
         $file_res = null;
         if ($this->enable_log_file) {
-            // write executed command to the log file using spc_write_log (shared handle, see spc_log_stream)
+            // write executed command to the log file using spc_write_log
-            $file_res = spc_log_stream(SPC_SHELL_LOG);
+            $file_res = fopen(SPC_SHELL_LOG, 'a');
         }
         if ($console_output) {
             $console_res = STDOUT;
@@ -263,7 +263,9 @@ abstract class Shell
             }
             fclose($pipes[1]);
             fclose($pipes[2]);
-            // $file_res is a shared, process-wide handle (see spc_log_stream); do not close it here.
+            if ($file_res !== null) {
+                fclose($file_res);
+            }
             proc_close($process);
         }
     }

src/StaticPHP/Util/BuildManifestDumper.php

@@ -1,82 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace StaticPHP\Util;
-
-use StaticPHP\ConsoleApplication;
-use StaticPHP\Exception\SPCInternalException;
-use StaticPHP\Package\Package;
-use StaticPHP\Package\PackageInstaller;
-use StaticPHP\Package\TargetPackage;
-use StaticPHP\Runtime\SystemTarget;
-
-final class BuildManifestDumper
-{
-    public const int SCHEMA_VERSION = 1;
-
-    /**
-     * @param array<string, Package> $packages        Resolved packages in dependency order
-     * @param array<string, Package> $buildPackages   Packages explicitly scheduled for building
-     * @param array<string, Package> $installPackages Packages explicitly scheduled for installation
-     */
-    public function dump(
-        array $packages,
-        array $buildPackages,
-        array $installPackages,
-        PackageInstaller $installer,
-        string $outputPath = BUILD_ROOT_PATH . '/build-manifest.json',
-    ): void {
-        $targets = [];
-        foreach ($packages as $package) {
-            if (!$package instanceof TargetPackage) {
-                continue;
-            }
-
-            $data = $package->getBuildManifestData($installer);
-            if ($data !== []) {
-                $targets[$package->getName()] = $data;
-            }
-        }
-
-        $manifest = [
-            'schema-version' => self::SCHEMA_VERSION,
-            'spc-version' => ConsoleApplication::VERSION,
-            'target' => [
-                'platform' => SystemTarget::getCurrentPlatformString(),
-                'os' => SystemTarget::getTargetOS(),
-                'architecture' => SystemTarget::getTargetArch(),
-                'libc' => SystemTarget::getLibc(),
-                'libc-version' => SystemTarget::getLibcVersion(),
-                'spc-target' => getenv('SPC_TARGET') ?: null,
-                'toolchain' => getenv('SPC_TOOLCHAIN') ?: null,
-            ],
-            'requested-packages' => [
-                'build' => array_keys($buildPackages),
-                'install' => array_keys($installPackages),
-            ],
-            'packages' => array_values(array_map(
-                static function (Package $package): array {
-                    $artifact = $package->getArtifact();
-                    return [
-                        'name' => $package->getName(),
-                        'type' => $package->getType(),
-                        'artifact' => $artifact?->getName(),
-                    ];
-                },
-                $packages,
-            )),
-            'targets' => $targets,
-        ];
-
-        $json = json_encode(
-            $manifest,
-            JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR,
-        );
-        if (FileSystem::writeFile($outputPath, $json . PHP_EOL) === false) {
-            throw new SPCInternalException("Failed to write build manifest: {$outputPath}");
-        }
-
-        logger()->info('Generated build manifest with ' . count($packages) . " package(s): {$outputPath}");
-    }
-}

src/StaticPHP/Util/FileSystem.php

@@ -322,16 +322,7 @@ class FileSystem
             }
             $sub_file = self::convertPath($dir . '/' . $v);
             if (is_link($sub_file) || is_file($sub_file)) {
-                if (!@unlink($sub_file)) {
+                if (!unlink($sub_file)) {
-                    $last_error = error_get_last();
-                    logger()->debug("unlink failed for '{$sub_file}': " . ($last_error['message'] ?? 'unknown error') . ', attempting chmod + unlink');
-
-                    // Go module cache files are often read-only; make writable and retry
-                    if (@chmod($sub_file, 0666) && @unlink($sub_file)) {
-                        continue;
-                    }
-
-                    // Shell fallback: del /f /q forces deletion of read-only files on Windows
                     $cmd = PHP_OS_FAMILY === 'Windows' ? 'del /f /q' : 'rm -f';
                     f_exec("{$cmd} " . escapeshellarg($sub_file), $out, $ret);
                     if ($ret !== 0) {

src/bootstrap.php

@@ -66,10 +66,11 @@ if (filter_var(getenv('SPC_ENABLE_LOG_FILE'), FILTER_VALIDATE_BOOLEAN)) {
         }
     }
 
-    // Use a single shared handle (see spc_log_stream) so the file is opened exactly once;
+    $log_file_fd = fopen(SPC_OUTPUT_LOG, 'a');
-    // on Windows a second concurrent open fails while child processes hold an inherited handle.
+    $ob_logger->addLogCallback(function ($level, $output) use ($log_file_fd) {
-    $ob_logger->addLogCallback(function ($level, $output) {
+        if ($log_file_fd) {
-        spc_write_log(spc_log_stream(SPC_OUTPUT_LOG), strip_ansi_colors($output) . "\n");
+            spc_write_log($log_file_fd, strip_ansi_colors($output) . "\n");
+        }
         return true;
     });
 }

src/globals/functions.php

@@ -137,11 +137,6 @@ function spc_add_log_filter(array|string $filter): void
 
 function spc_write_log(mixed $stream, string $data): false|int
 {
-    // Defensive: a log stream may be false/null when its file could not be opened
-    // (e.g. transient sharing violations on Windows). Never let logging crash the run.
-    if (!is_resource($stream)) {
-        return false;
-    }
     // get filter
     global $spc_log_filters;
     if (is_array($spc_log_filters)) {
@@ -150,29 +145,6 @@ function spc_write_log(mixed $stream, string $data): false|int
     return fwrite($stream, $data);
 }
 
-/**
- * Return a single, process-wide shared append handle for the given log file.
- *
- * The handle is opened lazily once and reused for the lifetime of the process. This is
- * important on Windows: every time a log file is opened with fopen() its handle is inherited
- * by child processes spawned via proc_open() (curl, git, tar, ...). While such a child is
- * alive it keeps the file open, and any *additional* open of the same file fails with a
- * sharing violation ("The process cannot access the file because it is being used by another
- * process."). During parallel downloads many children run at once, so opening a fresh handle
- * per log line crashes. Keeping exactly one handle per file means there is never a second open
- * to violate. Returns null when the file cannot be opened.
- *
- * @internal
- */
-function spc_log_stream(string $file): mixed
-{
-    static $streams = [];
-    if (!isset($streams[$file]) || !is_resource($streams[$file])) {
-        $streams[$file] = @fopen($file, 'a') ?: null;
-    }
-    return $streams[$file];
-}
-
 // ------- function f_* part -------
 // f_ means standard function wrapper
 

tests/StaticPHP/Util/BuildManifestDumperTest.php

@@ -1,187 +0,0 @@
-<?php
-
-declare(strict_types=1);
-
-namespace Tests\StaticPHP\Util;
-
-use Package\Target\php as PhpTargetPackage;
-use PHPUnit\Framework\TestCase;
-use StaticPHP\Artifact\Artifact;
-use StaticPHP\ConsoleApplication;
-use StaticPHP\Package\Package;
-use StaticPHP\Package\PackageInstaller;
-use StaticPHP\Package\PhpExtensionPackage;
-use StaticPHP\Package\TargetPackage;
-use StaticPHP\Runtime\SystemTarget;
-use StaticPHP\Util\BuildManifestDumper;
-
-/**
- * @internal
- */
-class BuildManifestDumperTest extends TestCase
-{
-    private string $tempDir;
-
-    protected function setUp(): void
-    {
-        parent::setUp();
-        $this->tempDir = sys_get_temp_dir() . '/build_manifest_dumper_test_' . uniqid();
-        mkdir($this->tempDir, 0755, true);
-    }
-
-    protected function tearDown(): void
-    {
-        parent::tearDown();
-        if (is_dir($this->tempDir)) {
-            $this->removeDirectory($this->tempDir);
-        }
-    }
-
-    public function testDumpWritesResolvedPackagesAndBuildContext(): void
-    {
-        $phpArtifact = new Artifact('php-src', ['source' => ['type' => 'url', 'url' => 'https://example.com/php.tar.gz']]);
-        $phpManifestData = [
-            'thread-safety' => 'nts',
-            'extensions' => ['all' => ['curl'], 'static' => ['curl'], 'shared' => []],
-        ];
-        $php = $this->createTargetPackage('php', $phpArtifact, $phpManifestData);
-        $openssl = $this->createPackage('openssl', 'library');
-        $curl = $this->createPackage('ext-curl', 'php-extension');
-        $cli = $this->createPackage('php-cli', 'target');
-        $installer = $this->createMock(PackageInstaller::class);
-
-        $outputPath = $this->tempDir . '/nested/build-manifest.json';
-        (new BuildManifestDumper())->dump(
-            [
-                'openssl' => $openssl,
-                'ext-curl' => $curl,
-                'php' => $php,
-                'php-cli' => $cli,
-            ],
-            ['php' => $php],
-            ['php-cli' => $cli],
-            $installer,
-            $outputPath,
-        );
-
-        $this->assertFileExists($outputPath);
-        $manifest = json_decode((string) file_get_contents($outputPath), true, flags: JSON_THROW_ON_ERROR);
-
-        $this->assertSame(BuildManifestDumper::SCHEMA_VERSION, $manifest['schema-version']);
-        $this->assertSame(ConsoleApplication::VERSION, $manifest['spc-version']);
-        $this->assertSame(SystemTarget::getCurrentPlatformString(), $manifest['target']['platform']);
-        $this->assertSame(SystemTarget::getTargetOS(), $manifest['target']['os']);
-        $this->assertSame(SystemTarget::getTargetArch(), $manifest['target']['architecture']);
-        $this->assertSame(['php'], $manifest['requested-packages']['build']);
-        $this->assertSame(['php-cli'], $manifest['requested-packages']['install']);
-        $this->assertSame([
-            ['name' => 'openssl', 'type' => 'library', 'artifact' => null],
-            ['name' => 'ext-curl', 'type' => 'php-extension', 'artifact' => null],
-            ['name' => 'php', 'type' => 'target', 'artifact' => 'php-src'],
-            ['name' => 'php-cli', 'type' => 'target', 'artifact' => null],
-        ], $manifest['packages']);
-        $this->assertSame(['php' => $phpManifestData], $manifest['targets']);
-    }
-
-    public function testPhpTargetExportsPhpSpecificBuildFacts(): void
-    {
-        $curl = new PhpExtensionPackage('curl', extension_config: ['arg-type' => 'with']);
-        $curl->setBuildStatic();
-        $pdo = new PhpExtensionPackage('pdo', extension_config: ['arg-type' => 'enable']);
-        $pdo->setBuildStatic();
-        $pdo->setBuildShared();
-        $xdebug = new PhpExtensionPackage('xdebug', extension_config: ['arg-type' => 'enable']);
-        $xdebug->setBuildShared();
-        $unused = new PhpExtensionPackage('unused', extension_config: ['arg-type' => 'enable']);
-
-        $installer = $this->createMock(PackageInstaller::class);
-        $installer->method('getResolvedPackages')->willReturn([$curl, $pdo, $xdebug, $unused]);
-        $installer->method('isPackageResolved')->willReturnCallback(
-            static fn (string $name): bool => in_array($name, ['php-cli', 'php-micro', 'php-embed'], true),
-        );
-
-        $php = new class('php', 'target') extends PhpTargetPackage {
-            public static function getPHPVersion(?string $from_custom_source = null, bool $return_null_if_failed = false): ?string
-            {
-                return '8.4.10';
-            }
-
-            public function getBuildOption(string $key, mixed $default = null): mixed
-            {
-                return $key === 'enable-zts' ? true : $default;
-            }
-        };
-
-        $data = $php->getBuildManifestData($installer);
-
-        $this->assertSame('8.4.10', $data['version']);
-        $this->assertSame('zts', $data['thread-safety']);
-        $this->assertSame(['cli', 'micro', 'embed'], $data['sapis']);
-        $this->assertSame([
-            'all' => ['curl', 'pdo', 'xdebug'],
-            'static' => ['curl', 'pdo'],
-            'shared' => ['pdo', 'xdebug'],
-        ], $data['extensions']);
-    }
-
-    private function createPackage(string $name, string $type, ?Artifact $artifact = null): Package
-    {
-        return new class($name, $type, $artifact) extends Package {
-            public function __construct(string $name, string $type, private readonly ?Artifact $artifact)
-            {
-                parent::__construct($name, $type);
-            }
-
-            public function getArtifact(): ?Artifact
-            {
-                return $this->artifact;
-            }
-        };
-    }
-
-    /** @param array<string, mixed> $manifestData */
-    private function createTargetPackage(string $name, ?Artifact $artifact, array $manifestData): TargetPackage
-    {
-        return new class($name, 'target', $artifact, $manifestData) extends TargetPackage {
-            /** @param array<string, mixed> $manifestData */
-            public function __construct(
-                string $name,
-                string $type,
-                private readonly ?Artifact $artifact,
-                private readonly array $manifestData,
-            ) {
-                parent::__construct($name, $type);
-            }
-
-            public function getArtifact(): ?Artifact
-            {
-                return $this->artifact;
-            }
-
-            public function getBuildManifestData(PackageInstaller $installer): array
-            {
-                return $this->manifestData;
-            }
-        };
-    }
-
-    private function removeDirectory(string $directory): void
-    {
-        $items = scandir($directory);
-        if ($items === false) {
-            return;
-        }
-        foreach ($items as $item) {
-            if ($item === '.' || $item === '..') {
-                continue;
-            }
-            $path = $directory . DIRECTORY_SEPARATOR . $item;
-            if (is_dir($path)) {
-                $this->removeDirectory($path);
-            } else {
-                unlink($path);
-            }
-        }
-        rmdir($directory);
-    }
-}