From b03a78c05d89d67239909296f3d711d51d1063ed Mon Sep 17 00:00:00 2001
From: sunrisepeak <speakshen@163.com>
Date: Sat, 26 Sep 2026 16:36:33 +0800
Subject: [PATCH 1/7] 0.14.0: deps-archive places an archive's tree beside the
 program; deps-vcpkg and deps-cmake deploy named files of their prefix

---
 .github/scripts/check-deps-and-qt.sh     |  58 ++++++-
 .github/workflows/ci.yml                 |   6 +
 README.md                                |  58 ++++++-
 deps/archive.cppm                        | 210 +++++++++++++++++++++++
 deps/cmake.cppm                          |   7 +
 deps/deps.cppm                           |  61 +++++++
 deps/vcpkg.cppm                          |   7 +
 mcpp.toml                                |  16 +-
 src/plugins.cppm                         |   2 +-
 tests/all-rules-compile/build.mcpp       |   2 +
 tests/all-rules-compile/mcpp.toml        |   2 +-
 tests/archive-consumer/assets/bundle.zip | Bin 0 -> 685 bytes
 tests/archive-consumer/build.mcpp        |  11 ++
 tests/archive-consumer/mcpp.toml         |  27 +++
 tests/archive-consumer/src/main.cpp      |  19 ++
 tests/vcpkg-consumer/build.mcpp          |   2 +
 tools/deps_main.cpp                      |  39 ++++-
 17 files changed, 512 insertions(+), 15 deletions(-)
 create mode 100644 deps/archive.cppm
 create mode 100644 tests/archive-consumer/assets/bundle.zip
 create mode 100644 tests/archive-consumer/build.mcpp
 create mode 100644 tests/archive-consumer/mcpp.toml
 create mode 100644 tests/archive-consumer/src/main.cpp

diff --git a/.github/scripts/check-deps-and-qt.sh b/.github/scripts/check-deps-and-qt.sh
index 30d64fe..546da9c 100644
--- a/.github/scripts/check-deps-and-qt.sh
+++ b/.github/scripts/check-deps-and-qt.sh
@@ -65,6 +65,10 @@ vcpkg_consumer() {
     "$MCPP" run | tee target/ci/run.log
     grep -qE '^vcpkg-consumer: fmt [0-9]+ says 42$' target/ci/run.log || fail "the program did not print through fmt"
     assert_not_rerun "$(stamp_of deps-vcpkg)"
+    # A file of the prefix the build program named in options::deploy.
+    find target -path '*/bin/licenses/fmt/copyright' | grep -q . ||
+        fail "share/fmt/copyright was not deployed beside the program"
+    echo "ok: a file of the prefix is deployed beside the program"
 
     if is_windows; then
         # The pack collects it from the runtime search directory.
@@ -74,6 +78,7 @@ vcpkg_consumer() {
             fail "started from the build directory, the program did not find fmt.dll"
         "$MCPP" pack --format dir | tee target/ci/pack.log
         find target/dist -iname 'fmt.dll' | grep -q . || fail "the packed tree carries no fmt.dll"
+        find target/dist -path '*/licenses/fmt/copyright' | grep -q . || fail "the packed tree carries no deployed copyright"
         echo "ok: the packed tree carries fmt.dll"
     fi
 }
@@ -128,6 +133,56 @@ cmake_consumer() {
     echo "ok: a file added to the subproject re-ran its installation"
 }
 
+archive_consumer() {
+    cd "$ROOT/tests/archive-consumer"
+    rm -rf target
+    mkdir -p target/ci
+    # PLANNING EXTRACTS NOTHING. The listing is read from the archive's central
+    # directory; the extraction is an action.
+    "$MCPP" emit build-database --format json > target/ci/db.json 2> target/ci/emit.log ||
+        { cat target/ci/emit.log; fail "emit build-database failed before any extraction"; }
+    [ -z "$(find target -path '*deps-archive*' -type f)" ] || fail "emit build-database extracted something"
+    echo "ok: emit planned the archive and extracted nothing"
+
+    "$MCPP" build 2>&1 | tee target/ci/build.log
+    "$MCPP" run | tee target/ci/run.log
+    grep -q "^archive-consumer: 'greetings from the archive', 'a file two levels down'$" target/ci/run.log ||
+        fail "the program did not read the archive's files from beside itself"
+    # The C++ file among the data `#error`s if compiled; the build succeeded,
+    # and the file is beside the program as data.
+    find target -path '*/bin/runtime/bundle/not-compiled.cpp' | grep -q . ||
+        fail "an archive member was not deployed beside the program"
+    echo "ok: the archive's tree is beside the program, a C++ member included, as data"
+
+    local copy
+    copy=$(find target -path '*deps-archive/bundle/bundle/greeting.txt' | head -1)
+    [ -n "$copy" ] || fail "no extracted copy under target/"
+    touch -r "$copy" target/ci/before-second-build
+    sleep 1
+    "$MCPP" build --profile dev > target/ci/second-build.log 2>&1 ||
+        { cat target/ci/second-build.log; fail "the second build failed"; }
+    [ -z "$(find "$copy" -newer target/ci/before-second-build)" ] ||
+        fail "a second build with nothing changed extracted the archive again"
+    echo "ok: a second build with nothing changed did not extract the archive again"
+
+    touch assets/bundle.zip
+    "$MCPP" build --profile dev > target/ci/third-build.log 2>&1 ||
+        { cat target/ci/third-build.log; fail "the build after touching the archive failed"; }
+    [ -n "$(find "$copy" -newer target/ci/before-second-build)" ] ||
+        fail "a changed archive was not extracted again"
+    echo "ok: a changed archive was extracted again"
+
+    "$MCPP" pack --format dir > target/ci/pack.log 2>&1 || { cat target/ci/pack.log; fail "mcpp pack failed"; }
+    find target/dist -path '*/runtime/bundle/nested/deep.txt' | grep -q . ||
+        fail "the packed tree does not carry the archive's files"
+    local packed
+    packed=$(find target/dist -path '*/bin/archive-consumer*' -type f | grep -vE '\.(pdb|debug)$' | head -1)
+    [ -n "$packed" ] || fail "no packed program"
+    "$packed" | grep -q "^archive-consumer: 'greetings from the archive'" ||
+        fail "the packed program did not read the archive's files"
+    echo "ok: the packed tree carries the archive's files, and the packed program reads them"
+}
+
 qt_consumer() {
     cd "$ROOT/tests/qt-consumer"
     rm -rf target
@@ -179,9 +234,10 @@ qt_widgets_consumer() {
 
 case "${1:-}" in
     vcpkg-consumer)      vcpkg_consumer ;;
+    archive-consumer)    archive_consumer ;;
     vcpkg-workspace)     vcpkg_workspace ;;
     cmake-consumer)      cmake_consumer ;;
     qt-consumer)         qt_consumer ;;
     qt-widgets-consumer) qt_widgets_consumer ;;
-    *) echo "usage: $0 vcpkg-consumer|vcpkg-workspace|cmake-consumer|qt-consumer|qt-widgets-consumer"; exit 2 ;;
+    *) echo "usage: $0 vcpkg-consumer|archive-consumer|vcpkg-workspace|cmake-consumer|qt-consumer|qt-widgets-consumer"; exit 2 ;;
 esac
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c51511c..2618265 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1650,6 +1650,9 @@ jobs:
       - name: deps-vcpkg installs a manifest as an action, and planning installs nothing
         run: bash .github/scripts/check-deps-and-qt.sh vcpkg-consumer
 
+      - name: deps-archive extracts a zip the project keeps and deploys its tree beside the program
+        run: bash .github/scripts/check-deps-and-qt.sh archive-consumer
+
       - name: deps-vcpkg in two workspace members that share no dependency
         run: bash .github/scripts/check-deps-and-qt.sh vcpkg-workspace
 
@@ -2325,6 +2328,9 @@ jobs:
       - name: deps-vcpkg installs a manifest as an action, and planning installs nothing
         run: bash .github/scripts/check-deps-and-qt.sh vcpkg-consumer
 
+      - name: deps-archive extracts a zip the project keeps and deploys its tree beside the program
+        run: bash .github/scripts/check-deps-and-qt.sh archive-consumer
+
       - name: deps-vcpkg in two workspace members that share no dependency
         run: bash .github/scripts/check-deps-and-qt.sh vcpkg-workspace
 
diff --git a/README.md b/README.md
index 369e107..7775835 100644
--- a/README.md
+++ b/README.md
@@ -78,7 +78,7 @@ engine's own module family and is not used here.
 | `rules-cuda` | `mcpp.rules.cuda` | 2026.9.6.6 | `[build] accel = "cuda…"`, a constrained glob for `*.cu`; the clang route with an LLVM toolchain, the nvcc route with a GCC one |
 | `rules-hip` | `mcpp.rules.hip` | 2026.9.6.6 | `[build] accel = "hip, cuda12.9+{sm_89}"`, a constrained glob for `*.hip`. On the NVIDIA platform HIP is a header layer over the CUDA runtime, so the compiler is the project's own clang and there is no ROCm on the machine |
 | `rules-metal` | `mcpp.rules.metal` | 2026.9.8.1 | the Metal toolchain of the macOS host's Xcode, located rather than installed: Xcode is not redistributable, so no payload is declared. `.metal` sources the project names on a macOS or iOS row become one `xcrun --sdk <sdk> metal` action per shader (`-MMD`, so an edited `#include` recompiles the shaders that include it) and one `xcrun --sdk <sdk> metallib` action per library, placed beside the program with `mcpp::deploy` under `metallib/`, which `dist-apple` maps into the bundle's resources. `compile(shaders)` compiles one source several times with definitions of its own, one library per `shader`; `options::library` links every shader into one library (`default` is the one `newDefaultLibrary` finds). Before planning anything the rule asks `xcrun --sdk <sdk> --show-sdk-path` and `--find metal` / `--find metallib`, and refuses naming the command that answered nothing, because a missing SDK and a missing compiler have different remedies (Xcode 26 installs the Metal toolchain as a separate component). A shader on any other row is refused naming the row. CI compiles the fixture on `macos-15` and checks each library's magic, and that a header edit recompiles only the shaders that include it |
-| `rules-qt` | `mcpp.rules.qt` | 2026.9.26.2 (mcpp#702) | a Qt 6 SDK: `rules-qt-xim` declares `xim:qt` 6.11.1 on the target axis, `rules-qt-xim-addons` adds `xim:qt-addons` (the additional libraries) as a second prefix, and `options::root` names an SDK from elsewhere. From 0.13.0. `moc` for every header under the package root that declares `Q_OBJECT`, `Q_GADGET` or `Q_NAMESPACE` and for a source that includes its own `<stem>.moc`; `uic` for `.ui`, `rcc` for `.qrc`, `lrelease` for `.ts` (named in `[build] sources` or in the options), each a `role = "source"` action with declared inputs. The modules are linked by full path, and the SDK's `bin/` (Windows) or `lib/` is a runtime search directory: the program's run path, `mcpp run`'s load path, `mcpp pack`'s closure, and on Windows the Qt DLLs the program imports placed beside it by the engine. The plugin directories `deploy_plugins` names are deployed beside the program. See [`deps-vcpkg`, `deps-cmake` and `rules-qt`](#deps-vcpkg-deps-cmake-and-rules-qt) |
+| `rules-qt` | `mcpp.rules.qt` | 2026.9.26.2 (mcpp#702) | a Qt 6 SDK: `rules-qt-xim` declares `xim:qt` 6.11.1 on the target axis, `rules-qt-xim-addons` adds `xim:qt-addons` (the additional libraries) as a second prefix, and `options::root` names an SDK from elsewhere. From 0.13.0. `moc` for every header under the package root that declares `Q_OBJECT`, `Q_GADGET` or `Q_NAMESPACE` and for a source that includes its own `<stem>.moc`; `uic` for `.ui`, `rcc` for `.qrc`, `lrelease` for `.ts` (named in `[build] sources` or in the options), each a `role = "source"` action with declared inputs. The modules are linked by full path, and the SDK's `bin/` (Windows) or `lib/` is a runtime search directory: the program's run path, `mcpp run`'s load path, `mcpp pack`'s closure, and on Windows the Qt DLLs the program imports placed beside it by the engine. The plugin directories `deploy_plugins` names are deployed beside the program. See [`deps-vcpkg`, `deps-cmake`, `deps-archive` and `rules-qt`](#deps-vcpkg-deps-cmake-deps-archive-and-rules-qt) |
 | `rules-slang` | `mcpp.rules.slang` | 2026.9.7.1 | `[build] accel = "vulkan1.2"`, a constrained glob for `*.slang`. Slang is a different language from GLSL rather than a second driver for it -- its own module system, generics, and targets beyond SPIR-V -- so it is a rule of its own. `.slang` is **not** in the engine's device-source table: this feature declares `device_extensions = [".slang"]` and `rule_module = "mcpp.rules.slang"`, and the engine routes it from there. That is the criterion for the whole arrangement -- a new device language costs no engine release. Since 0.7.0 it has the same `options::storage` axis as `rules-spirv` (header / object / sidecar), `options::extra_args` for the arguments the rule has no field for, and `options::per_file` for what one shader gets that the others do not -- a project with a `-fvk-use-gl-layout` and one shader needing `-emit-spirv-via-glsl` writes both without leaving one `compile()` call |
 | `rules-spirv` | `mcpp.rules.spirv` | 2026.9.6.6 | `[build] accel = "vulkan1.2"`, a constrained glob for the shader stages; compiles each shader through a `role = "source"` action and states which of the two compilers produced it |
 | `rules-swift` | `mcpp.rules.swift` | 2026.9.8.1 | the Swift compiler of the macOS host's Xcode or Command Line Tools, located rather than installed, as `rules-metal` locates its toolchain. From 0.12.0. The `.swift` sources a project names on a macOS or iOS row compile as one module named after the package: one whole-module `xcrun --sdk <sdk> swiftc -wmo -emit-object -target <triple>` action whose role is `object`, so the object joins every image of the package, and one `swiftc -typecheck -emit-objc-header-path` action whose role is `source`, whose directory `mcpp::include_dir` adds, so the package's C and C++ sources include `<module>-Swift.h`. `options::bridging_header` names a C header Swift sees without an import. The link receives the toolchain's `usr/lib/swift/<platform>` and the SDK's `usr/lib/swift` as search directories and `/usr/lib/swift` as a run path through `mcpp::link_flag`. Before planning anything the rule asks `xcrun --sdk <sdk> --show-sdk-path` and `--find swiftc`, and refuses naming the command that answered nothing; a Swift source on any other row is refused naming the row. Not supported: a Swift `import` of another package's module, and another package's C++ including this package's generated header, which both need an engine channel that publishes a package's interface directory to its dependents; and SwiftPM dependencies. CI builds `tests/swift-consumer` on `macos-15` -- a C++ program calling a `@_cdecl` Swift function that calls back into C -- and runs it |
@@ -90,8 +90,9 @@ engine's own module family and is not used here.
 | `dist-apple` | `mcpp.dist.apple` | 2026.9.14.2 (0.10.0); 2026.9.11.2 (macOS) and 2026.9.12.3 (iOS) before it | the base macOS install (`ditto`, `codesign`, `hdiutil`), and `xim:macapp-run` for `mcpp run` on macOS, which this feature declares with `when = "run"`. macOS: `Contents/`-shaped, as always. iOS (`aarch64-ios-sim`, `aarch64-ios`): a flat bundle at the same call site -- no separate feature, no separate module -- with `MinimumOSVersion` from `mcpp::min_platform_version()` (#622 A11), `CFBundleSupportedPlatforms` read from `env == "sim"`, `UIDeviceFamily`, `LSRequiresIPhoneOS`, and a directory of flat PNGs listed under `CFBundleIcons` in place of macOS's single `.icns` file. Signing is skipped on the simulator row (`options::identity` is ignored, with a `mcpp::warning` naming why), and the device row signs only with an identity. The iOS row is measured end to end on `macos-15`: a real `mcpp build`, `mcpp pack --format app` and `mcpp run` against `aarch64-ios-sim`, through `xim:apple-simulator-tools`' `simctl-run`. **The macOS floor is one release higher than its siblings** and the reason is not this member: under 2026.9.11.1 `mcpp pack` staged before dispatching and let a staging failure fail the command, so on a Mach-O program -- which the built-in closure walk refuses, because it uses `LD_TRACE_LOADED_OBJECTS` and dyld answers that by running the program -- every dispatched format was unreachable, including one that reads no staged tree. 2026.9.11.2 makes staging a service to the provider. From 0.9.2 the staged tree's deployed files (`bin/<to>/...`, which the engine stages for a Mach-O program before the closure walk since the release for mcpp#630) land at the bundle's resource destination -- `Contents/Resources/<to>/...` on macOS, the bundle root on iOS -- and the launcher alone goes to the executable directory, so `CFBundleExecutable` names a file that is where it says. The iOS fixture declares `llvm.libcxx` and `llvm.compiler-rt-builtins` under `cfg(os = "ios")`, which is what an application that imports `std` on those rows declares. From 0.10.0, with mcpp 2026.9.14.2: the dylibs the engine stages beside a Mach-O program, which the stage manifest's `needs` lines name, go to `Contents/Frameworks/` (`Frameworks/` on iOS) and not to the resources; the program is linked with the rpath that finds them there (`@executable_path/../Frameworks`, `@executable_path/Frameworks` on iOS) through `mcpp::link_flag`, so no file is edited after the link; a macOS bundle without `options::identity` is signed ad hoc, frameworks first and the bundle second, which `codesign --verify --deep --strict` requires of a bundle that carries a framework; an incomplete closure is a `mcpp::warning` naming the unresolved libraries; every refusal is a `mcpp::warning` as well, because the engine discards a build program's output when it exits 0. On macOS the member supplies the runner named `app` (`macapp-run`), so `mcpp run --format app` runs the bundle's executable in the foreground and returns its status with no runner in the manifest; a manifest runner of that name wins. `--format dmg` stages the bundle beside an `Applications` link and writes a UDZO image with `hdiutil create` (`options::volume_name`, `options::dmg`); it is refused on iOS. An engine below 2026.9.14.2 stages no `needs` lines, so the bundle carries no framework, anchors the rpath to the package directory, and hands the bundle directory to the kernel under `mcpp run --format app` unless `--runner app` is typed. CI measures the bundle on `macos-15`: the load command, the signature, the program with and without its framework (exit 7, then "Library not loaded"), `mcpp run --format app` with and without `--runner app`, and `hdiutil verify` and an attached image. From 0.11.0: a project's own Info.plist entries (`options::info_plist`), an iOS device bundle's provisioning profile (`options::provisioning_profile`), and `devicectl-run` (`xim:apple-device-tools`) as the device row's runner named `app` -- see [`dist-apple`: a project's Info.plist, and an iOS device](#dist-apple-a-projects-infoplist-and-an-ios-device). From 0.12.0 `options::omit_keys` leaves out a key the member only defaults -- see [`dist-apple`: a project's Info.plist, and an iOS device](#dist-apple-a-projects-infoplist-and-an-ios-device). From 0.12.0 a package in the resolved graph contributes Info.plist entries through `[package.metadata.dist-apple]`, applied before the application's own |
 | `dist-web` | `mcpp.dist.web` | 2026.9.13.1, the release that carries `${mcpp.self}` and `mcpp stage`'s argument shape as an engine contract (`stage --verify content --output <dst> <src>`) -- what lets this member's copy run on every host mcpp does, Windows included, in place of the `cp` this member used through 0.8.0 | nothing beyond mcpp: `wasm32-emscripten` only. Copies `${mcpp.stage_dir}/bin/` -- the `.js` launcher, the implicit `.wasm`, the `.data` when present, and every `mcpp::deploy`'d file, all of which #622 A5 and A4 already stage there -- to `<out_dir>/web/`, dropping the `bin/` prefix a browser has no use for, and writes an `index.html` rendered from a project template or a built-in default that loads the script with a plain `<script src>`. Each staged file and the rendered page are copied with `${mcpp.self} stage --verify content --output <dst> <src>`, the same copier every `stage_file` edge in `build.ninja` already runs -- no host-specific copy tool, no plan-time `create_directories` (`stage` creates the destination's parent), and a second `mcpp pack --format web` with nothing changed copies nothing. From 0.12.0 `options::page` names the page (`index.html` by default), for a project whose other build names it after the target; a name that is not a bare `*.html` file name is refused at plan time |
 | `dist-apk` | `mcpp.dist.apk` | 2026.9.14.2 from 0.10.0, which stages the closure this member reads; before it 2026.9.13.1, raised alongside `dist-web` in the same 0.9.0 release: this member's own manifest-template and Java-array changes ask nothing new of the engine, but this collection publishes one package at one version, and this is the release CI verifies it under from here on | `xim:android-build-tools`, `xim:android-platform` (versioned by API level, read back for `targetSdkVersion`), `xim:jdk-temurin` (`javac`/`jar`/`jarsigner`; `android-build-tools`' own runtime dependency provisions a JDK for its OWN wrappers only), `xim:android-debug-keystore`, `xim:bundletool` (0.10.0, for `--format aab`), all on the `cfg(env = "android")` axis. Generates `AndroidManifest.xml` and signs with the published Android debug key by default. Level 0 needs no Java (`hasCode="false"`, `android.app.NativeActivity`); `options::java_sources` adds `javac` + `d8` and a real `<activity>`. `options::manifest_template` renders a project manifest with six tokens substituted verbatim; `{{application_id}}` and `{{activity}}` are required always and `{{lib_name}}` at level 0, each refused by name at plan time when missing (naming `assets/mcpp-run.json`, which `adb-run` reads them from too) or when the template names an unknown token; empty renders 0.8.0's manifest byte-identically. From 0.9.3 the manifest template gains `{{version_name}}` / `{{version_code}}` (the package version, and `major * 1000000 + minor * 1000 + patch`). `options::resources` is a project's own `res/`, linked as the application's base resources from 0.9.1 (0.9.0 linked it as an aapt2 overlay, which refuses every resource the base does not already define -- a launcher icon could not be supplied). `options::java_sources` is an array: one `javac` over every root's `.java` files and one `d8` over the result, so a project's own sources and a path dependency's join without being merged into one directory first, and `rerun_if_changed_glob` is declared only for a root under `mcpp::manifest_dir()` -- a dependency root's files are already inputs of the `javac` action and its version is already in the build's fingerprint. Android only -- an `app` target is a shared object on this row (#622 A3). From 0.10.0, with mcpp 2026.9.14.2, the member reads the native closure the engine stages -- the application object, the graph's shared libraries and `libc++_shared.so` under `lib/` for one `--target`, `lib/<abi>/` for several -- and packs every ABI the tree carries into one APK; its own `NEEDED` walk and the stamp that lost a dependency's library on a second pack are gone. A stage manifest without `needs` lines comes from an engine below 2026.9.14.2 and is refused naming that floor, as is an incomplete closure, naming the unresolved libraries; every refusal is also a `mcpp::warning`, because the engine discards a build program's output when it exits 0. `--format aab` shares every step but the last three: `aapt2 link --proto-format` (with `--version-code` / `--version-name`, which bundletool requires), a base module in the layout bundletool reads, `bundletool build-bundle` from `xim:bundletool` (declared on the same axis), and `jarsigner` with the same keystore. CI packages both level 0 and level 1 and checks the archive (`mcpp::deploy`'d files under `assets/`), and on `tests/apk-consumer-shared` two packs in a row, a two-ABI APK (`aapt2` reports both, `apksigner` verifies it), an App Bundle (`bundletool validate`, `jarsigner -verify`, a universal APK from `bundletool build-apks`), a refusal's reason in `mcpp pack`'s output, and the floor refusal; the runner has no emulator or device, so the two rows that actually run were measured locally on 2026-09-12, through `adb-run`, against a KVM-accelerated x86_64 emulator and a physical arm64-v8a phone, both printing `1-2-3` and exiting 0. From 0.11.0: Kotlin sources (`dist-apk-kotlin`, which declares `xim:kotlin`), R classes, Android libraries from source, local AARs and JARs, a Maven graph through a lock file (`dist-apk-maven`, which declares `xim:coursier`), a manifest merge, and an unsigned package -- see [`dist-apk`: Kotlin, libraries and a Maven graph](#dist-apk-kotlin-libraries-and-a-maven-graph). From 0.11.1 the native libraries are packed as the Android Gradle plugin packs them: each is stripped with the build's own `llvm-strip --strip-unneeded` (the NDK's, beside the compiler `mcpp::toolchain_dir()` reports; `options::keep_debug_symbols` packs them as staged), and a manifest stating `android:extractNativeLibs="false"` gets them stored uncompressed on a 16 KB page, which loading them from the APK in place requires; CI checks both, and the symbol table `keep_debug_symbols` keeps. From 0.12.0 the engine's strip decision governs these libraries as well: under mcpp 2026.9.16.1, which publishes it to build programs as `MCPP_PACK_STRIP` and `MCPP_PACK_DEBUG_SYMBOLS_DIR`, that engine strips and separates the libraries it stages itself and the member packs them as staged, while the libraries the engine did not stage -- an archive's `jni/` libraries -- follow the same decision inside the member: `--no-strip` packs them as they are, and `--debug-symbols <dir>` separates each one's debug information into `<dir>/<abi>/<library>.debug` with `llvm-objcopy` before stripping it and linking the packed copy to that file (`.gnu_debuglink`). A library is stripped unless either `keep_debug_symbols` or the engine says to keep it, and under an older engine, which publishes neither variable, the member strips every library as before. Because that engine strips before the member reads the tree, `keep_debug_symbols` keeps only the member's own strip off and `--no-strip` is what ships the symbols of the libraries the graph built; the member warns when the option is set and the engine stripped. From 0.12.0 a library in the resolved graph contributes libraries and archives through `[package.metadata.dist-apk]`, ranked below the application's own -- see [A library states its contribution](#a-library-states-its-contribution-packagemetadatadist-apk) |
-| `deps-vcpkg` | `mcpp.deps.vcpkg` | 2026.9.26.2 (mcpp#702) | `xim:vcpkg` (the tool and the scripts released with it), which this feature declares on the host axis, and `tools = ["mcpp-deps"]` on the edge. From 0.13.0. Installs a `vcpkg.json` manifest as a `prepare` action and maps `<install root>/<triplet>` into the build by name, its shared-library directory a runtime search directory; `mcpp emit build-database` installs nothing. See [`deps-vcpkg`, `deps-cmake` and `rules-qt`](#deps-vcpkg-deps-cmake-and-rules-qt) |
+| `deps-vcpkg` | `mcpp.deps.vcpkg` | 2026.9.26.2 (mcpp#702) | `xim:vcpkg` (the tool and the scripts released with it), which this feature declares on the host axis, and `tools = ["mcpp-deps"]` on the edge. From 0.13.0. Installs a `vcpkg.json` manifest as a `prepare` action and maps `<install root>/<triplet>` into the build by name, its shared-library directory a runtime search directory; `mcpp emit build-database` installs nothing. See [`deps-vcpkg`, `deps-cmake`, `deps-archive` and `rules-qt`](#deps-vcpkg-deps-cmake-deps-archive-and-rules-qt) |
 | `deps-cmake` | `mcpp.deps.cmake` | 2026.9.26.2 (mcpp#702) | `xim:cmake`, which this feature declares on the host axis, and `tools = ["mcpp-deps"]` on the edge. From 0.13.0. Configures, builds and installs a CMake subproject as one `prepare` action whose inputs are the subproject's files, and maps the prefix as `deps-vcpkg` does |
+| `deps-archive` | `mcpp.deps.archive` | 2026.9.26.2 | `xim:cmake`, which this feature declares on the host axis, and `tools = ["mcpp-deps"]` on the edge. From 0.14.0. Extracts a zip archive the project keeps and places its tree beside the program: one action names every member as an output, read from the archive's central directory while the build program runs, and each is deployed, so `mcpp run` finds the files and `mcpp pack` carries them. See [`deps-vcpkg`, `deps-cmake`, `deps-archive` and `rules-qt`](#deps-vcpkg-deps-cmake-deps-archive-and-rules-qt) |
 
 ### Each rule brings its own environment
 
@@ -846,13 +847,13 @@ CI measures the rest:
 - On `macos-15`: the entries in a real macOS bundle that `plutil` accepts and
   that launches, and in a simulator bundle that the simulator runs.
 
-## `deps-vcpkg`, `deps-cmake` and `rules-qt`
+## `deps-vcpkg`, `deps-cmake`, `deps-archive` and `rules-qt`
 
 ### `deps-vcpkg`: the libraries a vcpkg manifest names
 
 ```toml
 [build-dependencies.mcpp]
-plugins = { version = "0.13.1", features = ["deps-vcpkg"], host-module = true, tools = ["mcpp-deps"] }
+plugins = { version = "0.14.0", features = ["deps-vcpkg"], host-module = true, tools = ["mcpp-deps"] }
 ```
 
 ```cpp
@@ -885,7 +886,10 @@ workspace finds a manifest kept at the workspace root. It then:
   (elsewhere) with `mcpp::runtime_search_dir`: the program's run path on ELF and
   Mach-O, `mcpp run`'s load path, `mcpp pack`'s closure, and on Windows the
   DLLs the program imports placed beside it after the link;
-- returns the prefix (`root`, `include`, `lib`, `bin`, `share`, `triplet`).
+- copies each file `options::deploy` names out of the prefix, by an action
+  that names the copy as its output, and deploys the copy beside the program;
+- returns the prefix (`root`, `include`, `lib`, `bin`, `share`, `triplet`, and
+  `deployed`, the copies, for a project that lays out a directory of its own).
 
 A vcpkg tool that is not installed is a warning and not a failure: the plan
 states every path it can, and the build is where the absence fails.
@@ -899,6 +903,7 @@ states every path it can, and the build is where the absence fails.
 | `overlay_triplets` | further overlay-triplet directories |
 | `install_args` | arguments appended to `vcpkg install` |
 | `vcpkg_root` | a vcpkg root other than the `xim:vcpkg` payload |
+| `deploy` | files of the prefix the program reads at run time, each `{file, to}`: `file` relative to the prefix root, `to` the directory beside the program (`{"share/opencc/t2s.json", "BaseConfig/opencc"}`) |
 
 The payload `xim:vcpkg` is vcpkg-tool's release binary with the standalone
 bundle published beside it, so the scripts a port calls are the ones that tool
@@ -912,7 +917,11 @@ an exclusive lock on the installation root while vcpkg runs. vcpkg fetches its
 own CMake, Ninja and 7-Zip, and on Windows a portable git; on Linux and macOS
 its documented host prerequisites (git, curl, zip, unzip, tar, a C compiler)
 are the host's. Ports are compiled with vcpkg's default toolchain for the
-triplet: the Visual Studio toolset on Windows, the host compiler elsewhere.
+triplet: the Visual Studio toolset on Windows, the host compiler elsewhere. The
+program links them, so its C++ runtime must be theirs: mcpp's clang on the MSVC
+ABI links a Windows port as it stands, while on Linux a toolchain whose C++
+library is libc++ does not link a port built against the host's libstdc++, and
+such a project builds with a gcc toolchain.
 
 Not supported: vcpkg's classic mode; the debug libraries under `debug/lib`.
 
@@ -938,13 +947,44 @@ maps its own. `layout` names install directories other than `include/`, `lib/`
 and `bin/`; `prefix_path` becomes `CMAKE_PREFIX_PATH` (`mcpp::rules::qt::root()`
 for a subproject that finds Qt); `cache_args` carries `-D…`, `-G …` and a
 toolchain file. The subproject is compiled with the toolchain CMake selects by
-default unless `cache_args` names another.
+default unless `cache_args` names another. `deploy` places files of the prefix
+beside the program, as `deps-vcpkg` takes it.
+
+### `deps-archive`: files a program reads at run time, from an archive
+
+```cpp
+import mcpp.deps.archive;
+
+int main() {
+    mcpp::deps::archive::options o;
+    o.archive = "assets/python-embed.zip";
+    o.to      = "runtime";
+    return mcpp::deps::archive::unpack(o) ? 0 : 1;
+}
+```
+
+`unpack()` reads the archive's central directory while the build program runs,
+so every file it holds is named before anything is extracted. One `artifact`
+action, `mcpp-deps unpack`, extracts it into `<out dir>/deps-archive/<name>` with
+`cmake -E tar xf --touch`, naming each file as an output; each file is then
+deployed under `to`, so `mcpp run` finds it beside the program and `mcpp pack`
+carries it. The action's inputs are the archive and the tool, so an edited
+archive is extracted again and an unchanged one is not; `mcpp emit
+build-database` extracts nothing. `result::files` lists the extracted copies
+with their paths beside the program, for a project that lays out a directory of
+its own. A C++ file inside the archive is data: the action's outputs never join
+the package's compile set.
+
+Only zip is read, because a compressed tar has no index to list without
+decompressing it while planning; a ZIP64 archive is refused by name, as is a
+member whose path would leave the extraction directory. A missing `cmake` is a
+warning, and the plan then extracts and deploys nothing.
 
 ### `rules-qt`: Qt's code generators and Linguist tools
 
 ```toml
 [build-dependencies.mcpp]
-plugins = { version = "0.13.1", features = ["rules-qt-xim"], host-module = true }
+plugins = { version = "0.14.0", features = ["rules-qt-xim"], host-module = true }
 
 [build]
 sources = ["src/*.cpp", "res/*.qrc", "i18n/*.ts", "ui/*.ui"]
@@ -1023,7 +1063,7 @@ src/plugins.cppm   export module mcpp.plugins;  the lib root: the version,
 rules/<x>.cppm     export module mcpp.rules.<x>;
 tools/<x>.cppm     export module mcpp.tools.<x>;
 dist/<x>.cppm      export module mcpp.dist.<x>;
-deps/<x>.cppm      export module mcpp.deps.<x>;  deps/deps.cppm is what both
+deps/<x>.cppm      export module mcpp.deps.<x>;  deps/deps.cppm is what the
                    deps members share
 tools/deps_main.cpp  mcpp-deps, the command of every deps installation
 tests/<consumer>/  one project per member, built by CI with the pinned mcpp
diff --git a/deps/archive.cppm b/deps/archive.cppm
new file mode 100644
index 0000000..352831c
--- /dev/null
+++ b/deps/archive.cppm
@@ -0,0 +1,210 @@
+// mcpp.deps.archive -- files a program reads at run time, from an archive the
+// project keeps.
+//
+//   import mcpp.deps.archive;
+//
+//   mcpp::deps::archive::options o;
+//   o.archive = "assets/python-embed.zip";
+//   o.to      = "runtime";                  // beside the program
+//   if (!mcpp::deps::archive::unpack(o)) return 1;
+//
+// The archive is extracted by an action, and every file it holds is placed
+// beside the program (`mcpp::deploy`): `mcpp run` finds the files there, and
+// `mcpp pack` carries them. A project that lays out a directory of its own
+// takes `result::files`, the extracted copies, as the inputs of its own
+// actions.
+//
+// THE FILE NAMES ARE READ WHEN THE BUILD PROGRAM RUNS, THE CONTENT ARRIVES WHEN
+// THE ACTION DOES. A zip archive lists its members in a central directory at
+// its end, which is read without extracting anything; the action therefore
+// names each file it writes as an output (SPEC-007 R3.2), and each output can
+// be deployed. The archive is a file of the project, so reading its listing is
+// configuration, not a construction result (R1.3); the listing is read again
+// when the archive changes.
+//
+// Only zip is listed: a compressed tar has no index, and naming its members
+// would mean decompressing it while planning. The extraction itself is CMake's
+// `-E tar`, from the `xim:cmake` payload this feature declares.
+
+export module mcpp.deps.archive;
+
+import std;
+import mcpp;
+import mcpp.plugins;
+import mcpp.deps;
+
+export namespace mcpp::deps::archive {
+
+struct options {
+    // The archive, relative to the package root. A `.zip`.
+    std::string archive;
+    // The directory beside the program the archive's tree is placed in. Empty
+    // or `.` is the program's own directory.
+    std::string to;
+    // Names the action and the directory the archive is extracted into. Empty
+    // takes the archive's file name without its extension.
+    std::string name;
+    // The `cmake` executable. Empty is the `xim:cmake` payload.
+    std::string cmake;
+};
+
+struct result {
+    // One entry per file of the archive: the extracted copy and its path
+    // beside the program.
+    std::vector<mcpp::deps::deployed_file> files;
+    bool ok = false;
+    explicit operator bool() const { return ok; }
+};
+
+// The member names of a zip archive, directories left out, or an error. Reads
+// the end-of-central-directory record and the central directory, nothing
+// else; a ZIP64 archive (4 GiB and beyond, or 65 535 members and beyond) is
+// refused by name rather than misread.
+inline std::expected<std::vector<std::string>, std::string>
+zip_members(const std::filesystem::path& file) {
+    std::ifstream in(file, std::ios::binary);
+    if (!in) return std::unexpected("cannot be opened");
+    in.seekg(0, std::ios::end);
+    const auto size = static_cast<std::uint64_t>(in.tellg());
+    if (size < 22) return std::unexpected("is not a zip archive (too short)");
+    const std::uint64_t tail = std::min<std::uint64_t>(size, 22 + 65535);
+    std::string buf(tail, '\0');
+    in.seekg(static_cast<std::streamoff>(size - tail));
+    in.read(buf.data(), static_cast<std::streamsize>(tail));
+
+    auto u16 = [](const std::string& b, std::size_t at) {
+        return static_cast<std::uint32_t>(static_cast<unsigned char>(b[at])) |
+               static_cast<std::uint32_t>(static_cast<unsigned char>(b[at + 1])) << 8;
+    };
+    auto u32 = [&](const std::string& b, std::size_t at) {
+        return u16(b, at) | u16(b, at + 2) << 16;
+    };
+
+    std::size_t eocd = std::string::npos;
+    for (std::size_t i = tail - 22 + 1; i-- > 0; )
+        if (u32(buf, i) == 0x06054b50u) { eocd = i; break; }
+    if (eocd == std::string::npos) return std::unexpected("is not a zip archive (no central directory)");
+
+    const std::uint32_t count  = u16(buf, eocd + 10);
+    const std::uint32_t cdSize = u32(buf, eocd + 12);
+    const std::uint32_t cdOff  = u32(buf, eocd + 16);
+    if (count == 0xFFFFu || cdSize == 0xFFFFFFFFu || cdOff == 0xFFFFFFFFu)
+        return std::unexpected("is a ZIP64 archive, which this member does not list");
+    if (static_cast<std::uint64_t>(cdOff) + cdSize > size)
+        return std::unexpected("has a central directory beyond its end");
+
+    std::string cd(cdSize, '\0');
+    in.seekg(cdOff);
+    in.read(cd.data(), static_cast<std::streamsize>(cdSize));
+    if (!in) return std::unexpected("cannot be read");
+
+    std::vector<std::string> names;
+    std::size_t at = 0;
+    for (std::uint32_t n = 0; n < count; ++n) {
+        if (at + 46 > cd.size() || u32(cd, at) != 0x02014b50u)
+            return std::unexpected("has a malformed central directory");
+        const std::size_t nameLen = u16(cd, at + 28), extraLen = u16(cd, at + 30),
+                          commentLen = u16(cd, at + 32);
+        if (at + 46 + nameLen > cd.size()) return std::unexpected("has a malformed central directory");
+        std::string name = cd.substr(at + 46, nameLen);
+        at += 46 + nameLen + extraLen + commentLen;
+        for (std::size_t i = 0; i < name.size(); ++i) if (name[i] == '\\') name[i] = '/';
+        if (name.empty() || name.back() == '/') continue;   // a directory
+        names.push_back(std::move(name));
+    }
+    return names;
+}
+
+inline result unpack(const options& opt) {
+    namespace fs = std::filesystem;
+    constexpr std::string_view who = "mcpp.deps.archive";
+    mcpp::fact("mcpp.plugins", std::string(mcpp::plugins::version).c_str());
+
+    // THE ARCHIVE. A missing or unreadable one is a mistake in the project,
+    // not a state of the machine, so it is refused.
+    std::error_code ec;
+    const fs::path archive = mcpp::deps::absolute_from_root(opt.archive);
+    if (opt.archive.empty() || !fs::is_regular_file(archive, ec)) {
+        std::cerr << std::format("{}: options::archive must name a file; got '{}'.\n", who, opt.archive);
+        return {};
+    }
+    mcpp::rerun_if_changed(mcpp::deps::generic(archive).c_str());
+    auto members = zip_members(archive);
+    if (!members) {
+        std::cerr << std::format("{}: {} {}.\n", who, mcpp::deps::generic(archive), members.error());
+        return {};
+    }
+    // A member that would land outside the extraction directory is refused:
+    // the path it names is the path it is written to.
+    for (auto const& m : *members) {
+        const fs::path rel = fs::path(m).lexically_normal();
+        if (rel.is_absolute() || rel.has_root_name() || rel.empty() || *rel.begin() == "..") {
+            std::cerr << std::format("{}: {} holds '{}', which leaves the directory it is "
+                                     "extracted into.\n", who, mcpp::deps::generic(archive), m);
+            return {};
+        }
+    }
+
+    const std::string name = opt.name.empty() ? archive.stem().string() : opt.name;
+    const fs::path into = fs::path(mcpp::out_dir()) / "deps-archive" / name;
+    const std::string dir = opt.to.empty() ? std::string(".") : opt.to;
+
+    result r;
+    r.ok = true;
+    for (auto const& m : *members) {
+        const fs::path rel = fs::path(m).lexically_normal();
+        r.files.push_back({mcpp::deps::generic(into / rel),
+                           mcpp::deps::generic(fs::path(dir) / rel)});
+    }
+
+    // ── the tool ──
+    std::string cmake;
+    if (!opt.cmake.empty()) {
+        cmake = mcpp::deps::generic(mcpp::deps::absolute_from_root(opt.cmake));
+    } else if (const std::string root = mcpp::xpkg_dir("xim", "cmake"); !root.empty()) {
+        const bool win = std::string(mcpp::host()).find("windows") != std::string::npos;
+        for (auto const& sub : { fs::path("bin"), fs::path("CMake.app") / "Contents" / "bin" }) {
+            const auto exe = fs::path(root) / sub / (win ? "cmake.exe" : "cmake");
+            if (fs::is_regular_file(exe, ec)) { cmake = mcpp::deps::generic(exe); break; }
+        }
+    }
+    if (cmake.empty()) {
+        // Nothing is extracted, so nothing can be deployed: a deployed file
+        // must be an output of some action.
+        mcpp::deps::warn(std::format(
+            "{}: cmake is not installed (xpkg_dir(\"xim\", \"cmake\") answered \"{}\"), so this plan "
+            "extracts nothing from {}. The `deps-archive` feature declares `xim:cmake`; "
+            "`mcpp build` provisions it before this program runs.",
+            who, std::string(mcpp::xpkg_dir("xim", "cmake")), mcpp::deps::generic(archive)));
+        r.files.clear();
+        return r;
+    }
+    const std::string tool = mcpp::deps::launcher(who, "deps-archive");
+    if (tool.empty()) return {};
+
+    // ── the extraction, as an edge ──
+    const std::string id   = "deps-archive:" + name;
+    const std::string desc = "UNPACK " + archive.filename().string();
+    const std::string arc  = mcpp::deps::generic(archive);
+    const std::string dst  = mcpp::deps::generic(into);
+    mcpp::action a;
+    a.id          = id.c_str();
+    a.role        = mcpp::roles::artifact;
+    a.description = desc.c_str();
+    a.arg(tool.c_str()).arg("unpack")
+     .arg("--cmake").arg(cmake.c_str())
+     .arg("--archive").arg(arc.c_str())
+     .arg("--into").arg(dst.c_str())
+     .input(tool.c_str()).input(cmake.c_str()).input(arc.c_str());
+    for (auto const& f : r.files) a.output(f.path.c_str());
+    a.submit();
+
+    // ── each file, beside the program ──
+    for (auto const& f : r.files) {
+        const std::string parent = fs::path(f.to).parent_path().generic_string();
+        mcpp::deploy(f.path.c_str(), parent.empty() ? "." : parent.c_str());
+    }
+    return r;
+}
+
+} // namespace mcpp::deps::archive
diff --git a/deps/cmake.cppm b/deps/cmake.cppm
index ae7e2d2..a15b92a 100644
--- a/deps/cmake.cppm
+++ b/deps/cmake.cppm
@@ -65,11 +65,16 @@ struct options {
     bool shared = false;
     // The `cmake` executable. Empty is the `xim:cmake` payload.
     std::string cmake;
+    // Files of the prefix placed beside the program, as `mcpp.deps.vcpkg`
+    // takes them (`{"bin/tool.cfg", "."}`).
+    std::vector<mcpp::deps::deploy_entry> deploy;
 };
 
 // The prefix, by name (SPEC-007 R1.3).
 struct prefix {
     std::string root, include, lib, bin;
+    // The copies `options::deploy` produced, for a project's own layout.
+    std::vector<mcpp::deps::deployed_file> deployed;
     explicit operator bool() const { return !root.empty(); }
 };
 
@@ -145,11 +150,13 @@ inline prefix use(const options& opt) {
         }
         for (auto const& x : opt.cache_args) a.arg(x.c_str());
         a.input(tool.c_str());
+        a.input(cmake.c_str());
         for (auto const& f : mcpp::deps::files_under(source)) a.input(f.c_str());
         mcpp::deps::watch_tree(source);
         a.output(stamp.c_str());
         a.output_dir(p.root.c_str());
         a.submit();
+        p.deployed = mcpp::deps::deploy_after("deps-cmake-" + name, stamp, fs::path(p.root), opt.deploy);
     }
 
     mcpp::include_dir(p.include.c_str());
diff --git a/deps/deps.cppm b/deps/deps.cppm
index 7e7d834..499f0c7 100644
--- a/deps/deps.cppm
+++ b/deps/deps.cppm
@@ -180,4 +180,65 @@ inline void runtime_directory(const std::string& bin, const std::string& lib) {
     mcpp::runtime_search_dir(dir.c_str());
 }
 
+// ── Files beside the program ───────────────────────────────────────────────
+//
+// Data a program reads at run time from beside itself -- a dictionary, a
+// configuration, an embedded interpreter -- is DEPLOYED (`mcpp::deploy`): the
+// engine places it beside the program after the build, `mcpp run` finds it
+// there, and `mcpp pack` carries it. A deployed file must be one the build
+// graph knows how to produce, and a file that a `prepare` action installs is
+// not: its name is unknown to the graph until the action has run. So the file
+// is first copied by an action that NAMES it as an output (SPEC-007 R3.2), and
+// the copy is deployed. Everything here is declared before anything exists, so
+// `mcpp emit build-database` plans it on a machine that never built.
+
+// One file of a prefix to place beside the program: `file` relative to the
+// prefix root (`share/opencc/t2s.json`), `to` the directory beside the program
+// it is placed in (`BaseConfig/opencc`; empty or `.` is the program's own
+// directory).
+struct deploy_entry {
+    std::string file;
+    std::string to;
+};
+
+// A file this package deploys: `path`, the copy the build produces (a node of
+// the build graph, which a project's own actions may take as an input), and
+// `to`, its path beside the program.
+struct deployed_file {
+    std::string path;
+    std::string to;
+};
+
+// Copies each entry's file out of `root` once the action that writes `stamp`
+// has run, and deploys the copy. `who` names the member in action ids.
+inline std::vector<deployed_file> deploy_after(std::string_view who, const std::string& stamp,
+                                               const std::filesystem::path& root,
+                                               std::span<const deploy_entry> entries) {
+    namespace fs = std::filesystem;
+    std::vector<deployed_file> out;
+    const fs::path base = fs::path(mcpp::out_dir()) / "deps-deploy" / std::string(who);
+    for (auto const& e : entries) {
+        const fs::path rel = fs::path(e.file).lexically_normal();
+        const std::string src  = generic(root / rel);
+        const std::string copy = generic(base / rel);
+        // Index loops over a string: GCC 16 fails to inline a string iterator
+        // inside a module's interface.
+        std::string key = rel.generic_string();
+        for (std::size_t i = 0; i < key.size(); ++i) if (key[i] == '/') key[i] = '.';
+        const std::string id   = std::format("{}:deploy:{}", who, key);
+        const std::string desc = std::format("DEPLOY {}", rel.generic_string());
+        mcpp::action a;
+        a.id          = id.c_str();
+        a.role        = mcpp::roles::artifact;
+        a.description = desc.c_str();
+        a.arg("${mcpp.self}").arg("stage").arg("--output").arg(copy.c_str()).arg(src.c_str())
+         .input(stamp.c_str()).output(copy.c_str()).submit();
+        const std::string dir = e.to.empty() ? std::string(".") : e.to;
+        mcpp::deploy(copy.c_str(), dir.c_str());
+        const std::string to = generic(fs::path(dir) / rel.filename());
+        out.push_back({copy, to});
+    }
+    return out;
+}
+
 } // namespace mcpp::deps
diff --git a/deps/vcpkg.cppm b/deps/vcpkg.cppm
index 5b5c55a..c02b508 100644
--- a/deps/vcpkg.cppm
+++ b/deps/vcpkg.cppm
@@ -67,6 +67,10 @@ struct options {
     std::vector<std::string> install_args;
     // The vcpkg root. Empty is the `xim:vcpkg` payload this feature declares.
     std::string vcpkg_root;
+    // Files of the prefix the program reads at run time, placed beside it
+    // (`{"share/opencc/t2s.json", "BaseConfig/opencc"}`): `mcpp run` finds them
+    // and `mcpp pack` carries them. See `mcpp::deps::deploy_after`.
+    std::vector<mcpp::deps::deploy_entry> deploy;
 };
 
 // The prefix, by name: the installation fills it during the build, and the
@@ -78,6 +82,8 @@ struct prefix {
     std::string bin;        // root/bin
     std::string share;      // root/share
     std::string triplet;
+    // The copies `options::deploy` produced, for a project's own layout.
+    std::vector<mcpp::deps::deployed_file> deployed;
     explicit operator bool() const { return !root.empty(); }
 };
 
@@ -267,6 +273,7 @@ inline prefix use(const options& opt = {}) {
         a.output(stamp.c_str());
         a.output_dir(p.root.c_str());
         a.submit();
+        p.deployed = mcpp::deps::deploy_after("deps-vcpkg-" + triplet, stamp, root, opt.deploy);
     }
 
     // ── the prefix, into the build ──
diff --git a/mcpp.toml b/mcpp.toml
index b512b0c..6df5700 100644
--- a/mcpp.toml
+++ b/mcpp.toml
@@ -1,7 +1,7 @@
 [package]
 name        = "plugins"
 namespace   = "mcpp"
-version     = "0.13.1"
+version     = "0.14.0"
 description = "Official mcpp build plugins: rule packages under mcpp.rules.*, build-time utilities under mcpp.tools.*, each member selected by a feature"
 license     = "Apache-2.0"
 authors     = ["mcpp-community"]
@@ -259,6 +259,14 @@ implies = ["deps"]
 sources = ["deps/cmake.cppm"]
 implies = ["deps"]
 
+# Files a program reads at run time, from a zip archive the project keeps:
+# extracted by an action that names every file (the archive's central
+# directory lists them while the build program runs) and deployed beside the
+# program. 0.14.0.
+[features.deps-archive]
+sources = ["deps/archive.cppm"]
+implies = ["deps"]
+
 [features.tools-embed]
 sources = ["tools/embed.cppm"]
 implies           = ["surface"]
@@ -461,6 +469,10 @@ implies           = ["surface"]
 [feature-xlings.deps-cmake]
 "xim:cmake" = ">=3.31"
 
+# `cmake -E tar xf --touch` extracts a zip on every host; `--touch` is 3.24+.
+[feature-xlings.deps-archive]
+"xim:cmake" = ">=3.31"
+
 # AN EXACT VERSION: `moc`'s output is tied to the Qt libraries it is linked
 # against, so the SDK is a choice a project may change, not a floor. The
 # additional libraries share the base's version, and `xim:qt-addons` depends on
@@ -653,7 +665,7 @@ main = "tools/embed_main.cpp"
 # it by a release.
 #
 #   [build-dependencies.mcpp]
-#   plugins = { version = "0.13.1", features = ["deps-vcpkg"],
+#   plugins = { version = "0.14.0", features = ["deps-vcpkg"],
 #               host-module = true, tools = ["mcpp-deps"] }
 [targets.mcpp-deps]
 kind = "bin"
diff --git a/src/plugins.cppm b/src/plugins.cppm
index 3e084f1..29cff09 100644
--- a/src/plugins.cppm
+++ b/src/plugins.cppm
@@ -49,7 +49,7 @@ export namespace mcpp::plugins {
 //
 // One package, one version: the number lives in mcpp.toml, and the CI step
 // `the collection states its own version` compares the two.
-inline constexpr std::string_view version = "0.13.1";
+inline constexpr std::string_view version = "0.14.0";
 
 } // namespace mcpp::plugins
 
diff --git a/tests/all-rules-compile/build.mcpp b/tests/all-rules-compile/build.mcpp
index 3688000..ba86a6f 100644
--- a/tests/all-rules-compile/build.mcpp
+++ b/tests/all-rules-compile/build.mcpp
@@ -24,6 +24,7 @@ import mcpp.dist.apk;
 import mcpp.deps;
 import mcpp.deps.vcpkg;
 import mcpp.deps.cmake;
+import mcpp.deps.archive;
 
 int main() {
     // No accelerator is named, so each of these returns true without looking
@@ -87,6 +88,7 @@ int main() {
     // derive without one -- the triplet this target defaults to, and the file
     // a library name denotes.
     ok = ok && !mcpp::deps::vcpkg::default_triplet().empty();
+    ok = ok && !mcpp::deps::archive::zip_members("mcpp.toml").has_value();   // not a zip: refused, not misread
     ok = ok && mcpp::deps::library_file("lib", "fmt", false).filename().string().find("fmt")
                    != std::string::npos;
 
diff --git a/tests/all-rules-compile/mcpp.toml b/tests/all-rules-compile/mcpp.toml
index 4d778fc..7826616 100644
--- a/tests/all-rules-compile/mcpp.toml
+++ b/tests/all-rules-compile/mcpp.toml
@@ -45,7 +45,7 @@ plugins = { path = "../..", features = [
   "tools-embed", "tools-island",
   "dist-appimage", "dist-wix", "dist-apple", "dist-web", "dist-apk",
   "dist-apk-kotlin", "dist-apk-maven",
-  "deps-cmake", "deps-vcpkg",
+  "deps-archive", "deps-cmake", "deps-vcpkg",
 ], host-module = true }
 
 # NO `accel`, and that is the whole design: with none, every rule returns
diff --git a/tests/archive-consumer/assets/bundle.zip b/tests/archive-consumer/assets/bundle.zip
new file mode 100644
index 0000000000000000000000000000000000000000..70f3a26970e4f11d2cdc2b4ed62336323363ef25
GIT binary patch
literal 685
zcmaJ;u};G<5OpX8i2)%|!N77ALSlfju`nR!4&(zm;3k(eBC&(xwtN613m?GNmCxum
z@Cyiuf8dVBEpY{Boqdwuz2|!l`>oB6SVVVF7eB`~?ZdH(bG!%}pxfuumm|95++TrG
zgJ?6A_Uxl|bp?sh1=taSG|?!V;7*f^+Ly6QRV}EnvKV{1ck}nBL&9(#tYKrslBFdi
zS&m?*8giUqUO}v<%9H)PeCu8l1t-%vS#8fFU6e!+_oA{qMq{)Asod+Kz+#97GGdih
zo`KR9Bvg8AA_Se#q;yrv=w7BgYOv91{p~IZQ|yVa8$Op_H=BI78OkvWPH3;2oZoD~
zf2wTpB3Si-N;kPPyeaNm?z(5e>sqh-0AJttdd2bai^Fq1?6<cV*rs(A2r-}(;v3{u
BjOG9U

literal 0
HcmV?d00001

diff --git a/tests/archive-consumer/build.mcpp b/tests/archive-consumer/build.mcpp
new file mode 100644
index 0000000..5e5e032
--- /dev/null
+++ b/tests/archive-consumer/build.mcpp
@@ -0,0 +1,11 @@
+// The whole integration: the archive and where its tree goes.
+import std;
+import mcpp;
+import mcpp.deps.archive;
+
+int main() {
+    mcpp::deps::archive::options o;
+    o.archive = "assets/bundle.zip";
+    o.to      = "runtime";
+    return mcpp::deps::archive::unpack(o) ? 0 : 1;
+}
diff --git a/tests/archive-consumer/mcpp.toml b/tests/archive-consumer/mcpp.toml
new file mode 100644
index 0000000..f97c6ae
--- /dev/null
+++ b/tests/archive-consumer/mcpp.toml
@@ -0,0 +1,27 @@
+# Fixture: files a program reads at run time, from a zip archive the project
+# keeps, through `deps-archive`.
+#
+#   assets/bundle.zip   bundle/greeting.txt, bundle/nested/deep.txt, and
+#                       bundle/not-compiled.cpp, which `#error`s if it is ever
+#                       compiled: an archive member is data
+#
+# The program prints what it reads from beside itself, so `mcpp run`, the
+# build directory and the packed tree are all checked by running it.
+[package]
+name        = "archive-consumer"
+version     = "0.1.0"
+description = "Fixture: an archive extracted and deployed beside the program through deps-archive"
+license     = "Apache-2.0"
+authors     = ["mcpp-community"]
+
+[language]
+standard   = "c++23"
+modules    = true
+import_std = false
+
+[build-dependencies.mcpp]
+plugins = { path = "../..", features = ["deps-archive"], host-module = true, tools = ["mcpp-deps"] }
+
+[targets.archive-consumer]
+kind = "bin"
+main = "src/main.cpp"
diff --git a/tests/archive-consumer/src/main.cpp b/tests/archive-consumer/src/main.cpp
new file mode 100644
index 0000000..1aea835
--- /dev/null
+++ b/tests/archive-consumer/src/main.cpp
@@ -0,0 +1,19 @@
+// Reads two files of the archive from beside the executable.
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+static std::string first_line(const std::filesystem::path& p) {
+    std::ifstream in(p);
+    std::string line;
+    std::getline(in, line);
+    return line;
+}
+
+int main(int, char** argv) {
+    const auto dir = std::filesystem::absolute(argv[0]).parent_path() / "runtime" / "bundle";
+    std::printf("archive-consumer: '%s', '%s'\n",
+                first_line(dir / "greeting.txt").c_str(),
+                first_line(dir / "nested" / "deep.txt").c_str());
+}
diff --git a/tests/vcpkg-consumer/build.mcpp b/tests/vcpkg-consumer/build.mcpp
index d67d920..b5f7ea2 100644
--- a/tests/vcpkg-consumer/build.mcpp
+++ b/tests/vcpkg-consumer/build.mcpp
@@ -13,5 +13,7 @@ int main() {
     // rebuild `mcpp-deps` and run again, so it goes under `target/`. A project
     // that takes `mcpp:plugins` from the index keeps vcpkg's default.
     o.install_root = "target/vcpkg_installed";
+    // A file the program would read at run time, placed beside it.
+    o.deploy = {{"share/fmt/copyright", "licenses/fmt"}};
     return mcpp::deps::vcpkg::use(o) ? 0 : 1;
 }
diff --git a/tools/deps_main.cpp b/tools/deps_main.cpp
index dae1234..de58af8 100644
--- a/tools/deps_main.cpp
+++ b/tools/deps_main.cpp
@@ -30,6 +30,7 @@
 //   mcpp-deps cmake --cmake <exe> --source <dir> --build <dir> --prefix <dir>
 //             [--config <Release>] [--generator <g>]
 //             [-- <extra configure args>...]
+//   mcpp-deps unpack --cmake <exe> --archive <file> --into <dir>
 #if defined(_WIN32)
 #  define WIN32_LEAN_AND_MEAN
 #  define NOMINMAX
@@ -56,7 +57,8 @@ namespace fs = std::filesystem;
                  "--install-root <dir> --triplet <t> [--overlay-triplets <dir>]... "
                  "[-- <args>...]\n"
               << "       mcpp-deps cmake --cmake <exe> --source <dir> --build <dir> --prefix <dir> "
-                 "[--config <c>] [--generator <g>] [-- <args>...]\n";
+                 "[--config <c>] [--generator <g>] [-- <args>...]\n"
+              << "       mcpp-deps unpack --cmake <exe> --archive <file> --into <dir>\n";
     std::exit(2);
 }
 
@@ -323,6 +325,40 @@ int cmake_install(const args& a) {
     return 0;
 }
 
+// ── An archive ─────────────────────────────────────────────────────────────
+
+// Extracts `--archive` into `--into`, which it empties first: the member that
+// planned this action named every file the archive holds as an output, and a
+// file left over from a previous archive would be one it did not name. CMake's
+// `-E tar` reads zip as well as tar on every host; `--touch` gives each file
+// the time of extraction, so the outputs are newer than the archive and the
+// next build finds them up to date. `-E tar` extracts into its working
+// directory, which an action cannot set, so this program sets it.
+int unpack(const args& a) {
+    const fs::path cmake   = a.one("cmake");
+    const fs::path archive = fs::absolute(a.one("archive"));
+    const fs::path into    = fs::absolute(a.one("into"));
+
+    std::error_code ec;
+    fs::remove_all(into, ec);
+    fs::create_directories(into, ec);
+    if (ec) {
+        std::cerr << std::format("mcpp-deps: cannot create {}: {}\n", into.string(), ec.message());
+        return 1;
+    }
+    fs::current_path(into, ec);
+    if (ec) {
+        std::cerr << std::format("mcpp-deps: cannot enter {}: {}\n", into.string(), ec.message());
+        return 1;
+    }
+    std::cerr << "mcpp-deps: unpack " << archive.string() << " -> " << into.string() << "\n";
+    if (int code = run({cmake.string(), "-E", "tar", "xf", archive.string(), "--touch"}); code != 0) {
+        std::cerr << std::format("mcpp-deps: cmake -E tar exited {}\n", code);
+        return code;
+    }
+    return 0;
+}
+
 } // namespace
 
 int main(int argc, char** argv) {
@@ -331,5 +367,6 @@ int main(int argc, char** argv) {
     const args a = parse(argc, argv, 2);
     if (sub == "vcpkg") return vcpkg_install(a);
     if (sub == "cmake") return cmake_install(a);
+    if (sub == "unpack") return unpack(a);
     usage(std::format("unknown subcommand `{}`", sub));
 }

From 6b1f379d8909509624240a65b6ea48eaa1a8781e Mon Sep 17 00:00:00 2001
From: sunrisepeak <speakshen@163.com>
Date: Sat, 26 Sep 2026 16:47:07 +0800
Subject: [PATCH 2/7] 0.14.0: rules-qt-xim-base declares xim:qt-base, qtbase
 and qttools with the QtQml library lupdate loads; the console Qt fixture uses
 it

---
 .github/workflows/ci.yml    |  4 ++--
 README.md                   |  5 +++--
 mcpp.toml                   | 14 ++++++++++++++
 rules/qt.cppm               | 13 +++++++++----
 tests/qt-consumer/mcpp.toml |  6 ++++--
 5 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2618265..bda882c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1662,7 +1662,7 @@ jobs:
       # A console program: QtCore, which is what Linux is served for. QtGui
       # loads libdbus, which the ecosystem does not publish, so the Widgets
       # fixture runs on Windows only.
-      - name: rules-qt runs moc, rcc and lrelease, with the SDK from xim:qt
+      - name: rules-qt runs moc, rcc, lupdate and lrelease, with the SDK from xim:qt-base
         run: bash .github/scripts/check-deps-and-qt.sh qt-consumer
 
   # ── THE SAME RULE ON THE OTHER TWO PLATFORMS ────────────────────────────────
@@ -2337,7 +2337,7 @@ jobs:
       - name: deps-cmake builds a CMake subproject as an action and links it
         run: bash .github/scripts/check-deps-and-qt.sh cmake-consumer
 
-      - name: rules-qt runs moc, rcc and lrelease, with the SDK from xim:qt
+      - name: rules-qt runs moc, rcc, lupdate and lrelease, with the SDK from xim:qt-base
         run: bash .github/scripts/check-deps-and-qt.sh qt-consumer
 
       # Windows and macOS: QtGui's dependencies are the system's there. On Linux
diff --git a/README.md b/README.md
index 7775835..75ea36d 100644
--- a/README.md
+++ b/README.md
@@ -78,7 +78,7 @@ engine's own module family and is not used here.
 | `rules-cuda` | `mcpp.rules.cuda` | 2026.9.6.6 | `[build] accel = "cuda…"`, a constrained glob for `*.cu`; the clang route with an LLVM toolchain, the nvcc route with a GCC one |
 | `rules-hip` | `mcpp.rules.hip` | 2026.9.6.6 | `[build] accel = "hip, cuda12.9+{sm_89}"`, a constrained glob for `*.hip`. On the NVIDIA platform HIP is a header layer over the CUDA runtime, so the compiler is the project's own clang and there is no ROCm on the machine |
 | `rules-metal` | `mcpp.rules.metal` | 2026.9.8.1 | the Metal toolchain of the macOS host's Xcode, located rather than installed: Xcode is not redistributable, so no payload is declared. `.metal` sources the project names on a macOS or iOS row become one `xcrun --sdk <sdk> metal` action per shader (`-MMD`, so an edited `#include` recompiles the shaders that include it) and one `xcrun --sdk <sdk> metallib` action per library, placed beside the program with `mcpp::deploy` under `metallib/`, which `dist-apple` maps into the bundle's resources. `compile(shaders)` compiles one source several times with definitions of its own, one library per `shader`; `options::library` links every shader into one library (`default` is the one `newDefaultLibrary` finds). Before planning anything the rule asks `xcrun --sdk <sdk> --show-sdk-path` and `--find metal` / `--find metallib`, and refuses naming the command that answered nothing, because a missing SDK and a missing compiler have different remedies (Xcode 26 installs the Metal toolchain as a separate component). A shader on any other row is refused naming the row. CI compiles the fixture on `macos-15` and checks each library's magic, and that a header edit recompiles only the shaders that include it |
-| `rules-qt` | `mcpp.rules.qt` | 2026.9.26.2 (mcpp#702) | a Qt 6 SDK: `rules-qt-xim` declares `xim:qt` 6.11.1 on the target axis, `rules-qt-xim-addons` adds `xim:qt-addons` (the additional libraries) as a second prefix, and `options::root` names an SDK from elsewhere. From 0.13.0. `moc` for every header under the package root that declares `Q_OBJECT`, `Q_GADGET` or `Q_NAMESPACE` and for a source that includes its own `<stem>.moc`; `uic` for `.ui`, `rcc` for `.qrc`, `lrelease` for `.ts` (named in `[build] sources` or in the options), each a `role = "source"` action with declared inputs. The modules are linked by full path, and the SDK's `bin/` (Windows) or `lib/` is a runtime search directory: the program's run path, `mcpp run`'s load path, `mcpp pack`'s closure, and on Windows the Qt DLLs the program imports placed beside it by the engine. The plugin directories `deploy_plugins` names are deployed beside the program. See [`deps-vcpkg`, `deps-cmake`, `deps-archive` and `rules-qt`](#deps-vcpkg-deps-cmake-deps-archive-and-rules-qt) |
+| `rules-qt` | `mcpp.rules.qt` | 2026.9.26.2 (mcpp#702) | a Qt 6 SDK: `rules-qt-xim` declares `xim:qt` 6.11.1 on the target axis, `rules-qt-xim-base` declares `xim:qt-base` instead (qtbase and qttools with the QtQml library lupdate loads, about a third of the download; 0.14.0), `rules-qt-xim-addons` adds `xim:qt-addons` (the additional libraries) as a second prefix, and `options::root` names an SDK from elsewhere. From 0.13.0. `moc` for every header under the package root that declares `Q_OBJECT`, `Q_GADGET` or `Q_NAMESPACE` and for a source that includes its own `<stem>.moc`; `uic` for `.ui`, `rcc` for `.qrc`, `lrelease` for `.ts` (named in `[build] sources` or in the options), each a `role = "source"` action with declared inputs. The modules are linked by full path, and the SDK's `bin/` (Windows) or `lib/` is a runtime search directory: the program's run path, `mcpp run`'s load path, `mcpp pack`'s closure, and on Windows the Qt DLLs the program imports placed beside it by the engine. The plugin directories `deploy_plugins` names are deployed beside the program. See [`deps-vcpkg`, `deps-cmake`, `deps-archive` and `rules-qt`](#deps-vcpkg-deps-cmake-deps-archive-and-rules-qt) |
 | `rules-slang` | `mcpp.rules.slang` | 2026.9.7.1 | `[build] accel = "vulkan1.2"`, a constrained glob for `*.slang`. Slang is a different language from GLSL rather than a second driver for it -- its own module system, generics, and targets beyond SPIR-V -- so it is a rule of its own. `.slang` is **not** in the engine's device-source table: this feature declares `device_extensions = [".slang"]` and `rule_module = "mcpp.rules.slang"`, and the engine routes it from there. That is the criterion for the whole arrangement -- a new device language costs no engine release. Since 0.7.0 it has the same `options::storage` axis as `rules-spirv` (header / object / sidecar), `options::extra_args` for the arguments the rule has no field for, and `options::per_file` for what one shader gets that the others do not -- a project with a `-fvk-use-gl-layout` and one shader needing `-emit-spirv-via-glsl` writes both without leaving one `compile()` call |
 | `rules-spirv` | `mcpp.rules.spirv` | 2026.9.6.6 | `[build] accel = "vulkan1.2"`, a constrained glob for the shader stages; compiles each shader through a `role = "source"` action and states which of the two compilers produced it |
 | `rules-swift` | `mcpp.rules.swift` | 2026.9.8.1 | the Swift compiler of the macOS host's Xcode or Command Line Tools, located rather than installed, as `rules-metal` locates its toolchain. From 0.12.0. The `.swift` sources a project names on a macOS or iOS row compile as one module named after the package: one whole-module `xcrun --sdk <sdk> swiftc -wmo -emit-object -target <triple>` action whose role is `object`, so the object joins every image of the package, and one `swiftc -typecheck -emit-objc-header-path` action whose role is `source`, whose directory `mcpp::include_dir` adds, so the package's C and C++ sources include `<module>-Swift.h`. `options::bridging_header` names a C header Swift sees without an import. The link receives the toolchain's `usr/lib/swift/<platform>` and the SDK's `usr/lib/swift` as search directories and `/usr/lib/swift` as a run path through `mcpp::link_flag`. Before planning anything the rule asks `xcrun --sdk <sdk> --show-sdk-path` and `--find swiftc`, and refuses naming the command that answered nothing; a Swift source on any other row is refused naming the row. Not supported: a Swift `import` of another package's module, and another package's C++ including this package's generated header, which both need an engine channel that publishes a package's interface directory to its dependents; and SwiftPM dependencies. CI builds `tests/swift-consumer` on `macos-15` -- a C++ program calling a `@_cdecl` Swift function that calls back into C -- and runs it |
@@ -1006,6 +1006,7 @@ int main() {
 |---|---|
 | `rules-qt` | `options::root`; nothing is downloaded |
 | `rules-qt-xim` | `xim:qt` 6.11.1: the official base package without documentation (qtbase, qtsvg, qtdeclarative, qttools, qttranslations) |
+| `rules-qt-xim-base` | `xim:qt-base` 6.11.1 in place of `xim:qt`: qtbase and qttools with the QtQml library `lupdate` loads, about a third of the download (56–73 MB); every module a widgets or console program links, without Qt Quick, qtsvg or Qt's own translations |
 | `rules-qt-xim-addons` | adds `xim:qt-addons` 6.11.1, every additional library, as a second prefix |
 
 | option | meaning |
@@ -1031,7 +1032,7 @@ A missing SDK, module or tool is a warning: the rule states what it can, and
 the build is where the absence fails.
 
 On Linux, Qt's official QtCore links glib, zstd and zlib and the shared
-`libstdc++`. `rules-qt-xim` declares the first three on Linux, and the rule
+`libstdc++`. `rules-qt-xim` and `rules-qt-xim-base` declare the first three on Linux, and the rule
 declares their `lib/` directories as runtime search directories; the program
 states `[build] cxx_runtime = "toolchain-coupled"` (mcpp's docs/20), so the
 process has one C++ runtime. The statement is project-wide because mcpp reads a
diff --git a/mcpp.toml b/mcpp.toml
index 6df5700..9cc2db3 100644
--- a/mcpp.toml
+++ b/mcpp.toml
@@ -157,6 +157,12 @@ implies = ["rules-qt"]
 [features.rules-qt-xim-addons]
 implies = ["rules-qt-xim"]
 
+# `xim:qt-base`: qtbase and qttools with the QtQml library qttools' Linguist
+# tools load, without Qt Quick -- about a third of `xim:qt`'s download. For a
+# widgets or console program. 0.14.0.
+[features.rules-qt-xim-base]
+implies = ["rules-qt"]
+
 # NOT device rules: these embed or declare things a project already has, so they
 # claim no extension and name no rule module. A consumer calls them from its own
 # `build.mcpp`.
@@ -495,6 +501,14 @@ implies           = ["surface"]
 [target.'cfg(any(windows, linux, macos))'.feature-xlings.rules-qt-xim-addons]
 "xim:qt-addons" = "6.11.1"
 
+[target.'cfg(any(windows, linux, macos))'.feature-xlings.rules-qt-xim-base]
+"xim:qt-base" = "6.11.1"
+
+[target.'cfg(linux)'.feature-xlings.rules-qt-xim-base]
+"xim:glib" = ""
+"xim:zstd" = ""
+"xim:zlib" = ""
+
 # ── The environment `dist-appimage` needs ──────────────────────────────────
 #
 # ONE PAYLOAD, AND IT CARRIES TWO FILES. `appimagetool` builds the image, and
diff --git a/rules/qt.cppm b/rules/qt.cppm
index aff30a1..6698526 100644
--- a/rules/qt.cppm
+++ b/rules/qt.cppm
@@ -252,7 +252,11 @@ inline std::vector<std::filesystem::path> roots(const options& opt = {}) {
     };
     if (!opt.root.empty()) add(opt.root);
     else {
-        add(mcpp::xpkg_dir("xim", "qt"));
+        // `xim:qt` is the full base; `xim:qt-base` is its qtbase + qttools
+        // subset (`rules-qt-xim-base`). A project that declares both uses the
+        // full one.
+        const std::string full = mcpp::xpkg_dir("xim", "qt");
+        add(full.empty() ? std::string(mcpp::xpkg_dir("xim", "qt-base")) : full);
         add(mcpp::xpkg_dir("xim", "qt-addons"));
     }
     for (auto const& r : opt.extra_roots) add(r);
@@ -270,7 +274,7 @@ inline std::string root(const options& opt = {}) {
 
 // The SDK's shared-library directories, and on Linux those of the libraries
 // Qt's official QtCore expects the distribution to provide (glib, zstd, zlib,
-// declared from xim by `rules-qt-xim`), as runtime search directories
+// declared from xim by `rules-qt-xim` and `rules-qt-xim-base`), as runtime search directories
 // (SPEC-007 R4.1). The engine renders them as the program's run path, puts
 // them on `mcpp run`'s load path -- which reaches a library's dependencies
 // where the program's run path does not, because QtCore carries a RUNPATH of
@@ -308,8 +312,9 @@ inline bool compile(options opt = {}) {
     if (sdks.empty()) {
         detail::warn(std::format(
             "{}: no Qt SDK: options::root is {} and xpkg_dir(\"xim\", \"qt\") answered \"{}\". "
-            "Nothing Qt-specific is planned. The `rules-qt-xim` feature declares `xim:qt`, "
-            "which `mcpp build` provisions; a Qt from elsewhere is named with options::root.",
+            "Nothing Qt-specific is planned. The `rules-qt-xim` feature declares `xim:qt` and "
+            "`rules-qt-xim-base` declares `xim:qt-base`, which `mcpp build` provisions; a Qt "
+            "from elsewhere is named with options::root.",
             who, opt.root.empty() ? "empty" : "'" + opt.root + "' (no such directory)",
             std::string(mcpp::xpkg_dir("xim", "qt"))));
         return true;
diff --git a/tests/qt-consumer/mcpp.toml b/tests/qt-consumer/mcpp.toml
index e818f4b..de3f2f3 100644
--- a/tests/qt-consumer/mcpp.toml
+++ b/tests/qt-consumer/mcpp.toml
@@ -1,5 +1,7 @@
 # Fixture: a Qt 6 program that exercises each of Qt's code generators and its
-# Linguist tool through `rules-qt`, with the SDK from `xim:qt`.
+# Linguist tools through `rules-qt`, with the SDK from `xim:qt-base` (qtbase,
+# qttools and the QtQml library lupdate loads); tests/qt-widgets-consumer
+# uses `xim:qt`.
 #
 # A console program on purpose: QtCore needs no display and no platform plugin,
 # so the same program is built and RUN on every host in the matrix. What it
@@ -31,7 +33,7 @@ modules    = true
 import_std = false
 
 [build-dependencies.mcpp]
-plugins = { path = "../..", features = ["rules-qt-xim"], host-module = true }
+plugins = { path = "../..", features = ["rules-qt-xim-base"], host-module = true }
 
 [build]
 # Qt's Linux libraries load the shared libstdc++ (`libstdc++.so.6`), so the

From c69c61dd46a7be06620e4e58e4c2f40aad86b713 Mon Sep 17 00:00:00 2001
From: sunrisepeak <speakshen@163.com>
Date: Sat, 26 Sep 2026 16:54:07 +0800
Subject: [PATCH 3/7] 0.14.0: rules-qt places Qt's own translations
 (translations::qt_languages): lconvert combines the linked modules' catalogs
 into qt_<language>.qm, as windeployqt does

---
 .github/scripts/check-deps-and-qt.sh |  3 ++
 README.md                            |  2 +-
 rules/qt.cppm                        | 69 ++++++++++++++++++++++++++++
 tests/qt-consumer/build.mcpp         |  3 ++
 tests/qt-consumer/src/main.cpp       | 21 +++++++--
 5 files changed, 92 insertions(+), 6 deletions(-)

diff --git a/.github/scripts/check-deps-and-qt.sh b/.github/scripts/check-deps-and-qt.sh
index 546da9c..674e62e 100644
--- a/.github/scripts/check-deps-and-qt.sh
+++ b/.github/scripts/check-deps-and-qt.sh
@@ -201,6 +201,9 @@ qt_consumer() {
         fail "moc, rcc or lrelease did not reach the program"
     find target -name 'qt_consumer_de.qm' | grep -q . || fail "no .qm was produced"
     echo "ok: moc (header and inline), rcc and lrelease reached the program"
+    grep -q "Qt's own 'Abbrechen'$" target/ci/run.log ||
+        fail "Qt's own strings were not translated from the combined qt_de.qm"
+    echo "ok: lconvert combined Qt's catalogs into qt_de.qm, and the program loads it"
     "$MCPP" build --profile dev -v > target/ci/second-build.log 2>&1 ||
         { cat target/ci/second-build.log; fail "the second build failed"; }
     ! grep -qE '/(lupdate|lrelease)[^ ]* ' target/ci/second-build.log ||
diff --git a/README.md b/README.md
index 75ea36d..2d282cc 100644
--- a/README.md
+++ b/README.md
@@ -1015,7 +1015,7 @@ int main() {
 | `private_modules` | modules whose private headers are included |
 | `moc`, `moc_headers` | `moc_scan::project_headers` (default) scans the package's headers by content; `moc_scan::listed` takes `moc_headers` only |
 | `forms`, `resources` | `.ui` and `.qrc` files beside those in `[build] sources` |
-| `i18n` | `.ts` files beside those in `[build] sources`; `update_sources` runs `lupdate` before `lrelease`, as an action whose output is the `.ts` file it rewrites; `tr_function_alias`; `deploy_to` (default `translations`); `out_dir`, where `lrelease` writes (default `<out dir>/qt/translations`) |
+| `i18n` | `.ts` files beside those in `[build] sources`; `update_sources` runs `lupdate` before `lrelease`, as an action whose output is the `.ts` file it rewrites; `tr_function_alias`; `deploy_to` (default `translations`); `out_dir`, where `lrelease` writes (default `<out dir>/qt/translations`); `qt_languages`, Qt's own strings for each language: the catalogs of the linked modules combined by `lconvert` into `qt_<language>.qm` under `deploy_to`, the file windeployqt writes |
 | `deploy_plugins` | plugin directories placed beside the program; default `platforms` |
 | `deploy_software_gl` | Windows: `opengl32sw.dll` and `d3dcompiler_47.dll` beside the program |
 | `root`, `extra_roots` | an SDK, and further prefixes |
diff --git a/rules/qt.cppm b/rules/qt.cppm
index 6698526..6652e34 100644
--- a/rules/qt.cppm
+++ b/rules/qt.cppm
@@ -69,6 +69,11 @@ struct translations {
     // Where `lrelease` writes them. Empty is `<out dir>/qt/translations`; a
     // project whose own release step copies them names a directory it knows.
     std::string out_dir;
+    // Qt's own UI strings for these languages (`de`, `zh_CN`): the catalogs of
+    // the modules the program links, from the SDK's `translations/`, combined
+    // by `lconvert` into one `qt_<language>.qm` with no dependency left to
+    // resolve, and placed under `deploy_to` -- the file windeployqt writes.
+    std::vector<std::string> qt_languages;
 };
 
 struct options {
@@ -131,6 +136,26 @@ inline std::string module_name(std::string m) {
     return m;
 }
 
+// The translation catalog Qt ships a module's strings in: `qtbase` for the
+// modules of qtbase, the repository's name for the others. A module with no
+// catalog of its own has its strings in qtbase's.
+inline std::string catalog_of(const std::string& module) {
+    static const std::vector<std::pair<std::string, std::vector<std::string>>> table = {
+        {"qtdeclarative", {"Qml", "Quick", "QuickControls2", "QuickWidgets", "QuickDialogs2"}},
+        {"qtmultimedia",  {"Multimedia", "MultimediaWidgets"}},
+        {"qtserialport",  {"SerialPort"}},
+        {"qtwebsockets",  {"WebSockets"}},
+        {"qtconnectivity", {"Bluetooth", "Nfc"}},
+        {"qtlocation",    {"Location"}},
+        {"qtwebengine",   {"WebEngineCore", "WebEngineWidgets", "WebEngineQuick"}},
+        {"qt_help",       {"Help"}},
+    };
+    for (auto const& [catalog, modules] : table)
+        for (auto const& m : modules)
+            if (m == module) return catalog;
+    return "qtbase";
+}
+
 // By index, as `mcpp.deps.vcpkg` lowers a triplet line: GCC 16 cannot inline a
 // non-const std::string iterator in a module unit.
 inline std::string upper(std::string s) {
@@ -579,6 +604,50 @@ inline bool compile(options opt = {}) {
         }
     }
 
+    // ── Qt's own translations ──
+    if (!opt.i18n.qt_languages.empty()) {
+        const std::string lconvert = detail::tool(sdks, "lconvert");
+        const fs::path qmDir = opt.i18n.out_dir.empty() ? gen / "translations"
+                                                        : detail::absolute_from_root(opt.i18n.out_dir);
+        std::vector<std::string> catalogs = {"qtbase"};
+        for (auto const& m : opt.modules) {
+            const std::string c = detail::catalog_of(detail::module_name(m));
+            if (std::ranges::find(catalogs, c) == catalogs.end()) catalogs.push_back(c);
+        }
+        if (lconvert.empty()) {
+            detail::warn(std::format("{}: `lconvert` not found under {}; it is part of qttools, and "
+                                     "Qt's own translations are not placed.", who, generic(main)));
+        } else {
+            for (auto const& lang : opt.i18n.qt_languages) {
+                std::vector<std::string> inputs;
+                for (auto const& c : catalogs)
+                    for (auto const& r : sdks)
+                        if (const auto qm = r / "translations" / (c + "_" + lang + ".qm"); fs::is_regular_file(qm, ec)) {
+                            inputs.push_back(generic(qm));
+                            break;
+                        }
+                if (inputs.empty()) {
+                    detail::warn(std::format("{}: the SDK has no Qt translation for '{}' (no "
+                                             "translations/qtbase_{}.qm under {}).", who, lang, lang, generic(main)));
+                    continue;
+                }
+                const std::string name = "qt_" + lang + ".qm";
+                if (!claim(name, fs::path(inputs.front()))) return false;
+                const std::string out  = generic(qmDir / name);
+                const std::string id   = "qt:lconvert:" + lang;
+                const std::string desc = "LCONVERT " + name;
+                mcpp::action a;
+                a.id = id.c_str();
+                a.role = mcpp::roles::source;
+                a.description = desc.c_str();
+                a.arg(lconvert.c_str()).arg("-o").arg(out.c_str());
+                for (auto const& in : inputs) a.arg("-i").arg(in.c_str()).input(in.c_str());
+                a.output(out.c_str()).submit();
+                mcpp::deploy(out.c_str(), opt.i18n.deploy_to.c_str());
+            }
+        }
+    }
+
     // ── what Qt loads at run time ──
     for (auto const& dir : opt.deploy_plugins) {
         bool any = false;
diff --git a/tests/qt-consumer/build.mcpp b/tests/qt-consumer/build.mcpp
index fe2f62d..fe24d8c 100644
--- a/tests/qt-consumer/build.mcpp
+++ b/tests/qt-consumer/build.mcpp
@@ -10,5 +10,8 @@ int main() {
     // lupdate brings the `.ts` up to date with src/ before lrelease reads it.
     // The committed file is lupdate's own output, so a build leaves it as is.
     o.i18n.update_sources = true;
+    // Qt's own strings in German, combined from the catalogs of the modules
+    // linked into `translations/qt_de.qm`, as windeployqt writes it.
+    o.i18n.qt_languages = {"de"};
     return mcpp::rules::qt::compile(o) ? 0 : 1;
 }
diff --git a/tests/qt-consumer/src/main.cpp b/tests/qt-consumer/src/main.cpp
index 890ae19..d2a75af 100644
--- a/tests/qt-consumer/src/main.cpp
+++ b/tests/qt-consumer/src/main.cpp
@@ -40,11 +40,22 @@ int main(int argc, char** argv) {
         return 1;
     }
     QCoreApplication::installTranslator(&translator);
-    const QString hello = QCoreApplication::translate("main", "hello");
-
-    std::printf("qt-consumer: signal %d, resource '%s', translation '%s', Qt %s\n",
-                relay.seen, text.constData(), hello.toUtf8().constData(), qVersion());
-    return relay.seen == 42 && text == "greetings from rcc" && hello == "hallo" ? 0 : 1;
+    // Qt's own strings, from the qt_de.qm rules-qt combined: it loads only
+    // when no catalog it depends on is missing.
+    QTranslator qtTranslator;
+    if (!qtTranslator.load("qt_de", dir)) {
+        std::printf("qt-consumer: translations/qt_de.qm does not load\n");
+        return 1;
+    }
+    QCoreApplication::installTranslator(&qtTranslator);
+    const QString hello  = QCoreApplication::translate("main", "hello");
+    const QString cancel = QCoreApplication::translate("QProgressDialog", "Cancel");
+
+    std::printf("qt-consumer: signal %d, resource '%s', translation '%s', Qt %s, Qt's own '%s'\n",
+                relay.seen, text.constData(), hello.toUtf8().constData(), qVersion(),
+                cancel.toUtf8().constData());
+    return relay.seen == 42 && text == "greetings from rcc" && hello == "hallo" &&
+           cancel == "Abbrechen" ? 0 : 1;
 }
 
 #include "main.moc"

From 6cd62ebe5884e3f0b237abb883983da5bfca3c0f Mon Sep 17 00:00:00 2001
From: sunrisepeak <speakshen@163.com>
Date: Sat, 26 Sep 2026 16:57:31 +0800
Subject: [PATCH 4/7] plan: 0.14.0, the runtime data and the smaller Qt

---
 .../docs/2026-09-26-deps-vcpkg-rules-qt-plan.md  | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/.agents/docs/2026-09-26-deps-vcpkg-rules-qt-plan.md b/.agents/docs/2026-09-26-deps-vcpkg-rules-qt-plan.md
index f69dd9f..c05b740 100644
--- a/.agents/docs/2026-09-26-deps-vcpkg-rules-qt-plan.md
+++ b/.agents/docs/2026-09-26-deps-vcpkg-rules-qt-plan.md
@@ -69,3 +69,19 @@ T1 mcpp#702 实现并发布（mcpp 侧）─────────┴──►
 - `path` 包的宿主工具以整棵目录树的 stamp 为键，嵌套其中的消费方写出的文件改变该键（mcpp#705）。fixture
   位于插件仓库之内，因此其安装位于 `target/` 之下，检查脚本的日志写入 `target/ci/`，第二次构建以
   `--profile dev` 绕过快路径，使 Linux 与 Windows、macOS 走同一条规划路径。从索引取得插件的项目不受影响。
+
+## 6. 0.14.0：运行时数据与精简 Qt（GalTranslPP 验证后的第二轮）
+
+GalTranslPP 在 0.13.1 上构建成功后仍有两个手动步骤（解压嵌入式 Python、运行 `Release.py`），Qt 下载量为
+完整基础包。第二轮把固定步骤程序化，并补齐 windeployqt 的 Qt 翻译：
+
+| 交付 | 仓库 | 机制 |
+|---|---|---|
+| `deps-archive` | mcpp-plugins | 配置期读 zip 中央目录，一个 `artifact` action 解压并逐一命名输出（SPEC-007 R3.2），每个输出 `mcpp::deploy`；`mcpp run` 与 `mcpp pack` 均可见 |
+| `deps-vcpkg` / `deps-cmake` 的 `deploy` | mcpp-plugins | 前缀中的文件由命名输出的复制 action 取出再部署；不依赖引擎「deploy 等待 prepare」 |
+| `translations::qt_languages` | mcpp-plugins | `lconvert` 合并所链接模块的目录为 `qt_<lang>.qm`，即 windeployqt 的产物 |
+| `rules-qt-xim-base` / `xim:qt-base` | mcpp-plugins、xim-pkgindex、xlings-res | qtbase + qttools + qttranslations + 单独重发布的 QtQml 库；下载量约为 `xim:qt` 的三分之一 |
+| `libs/qtsdk.lua` | xim-pkgindex | qt、qt-base、qt-addons 共享的下载、镜像、解压与标记逻辑 |
+
+实测：库包中的 `artifact` 输出经 `mcpp::deploy` 传播到依赖它的程序的 `bin/` 与 `mcpp pack` 目录；依赖包中无下游
+消费者的 `artifact` action 随下游构建执行。

From e4a58aebb2c41729edf8372f3d0a71f4e833c328 Mon Sep 17 00:00:00 2001
From: sunrisepeak <speakshen@163.com>
Date: Sat, 26 Sep 2026 17:01:43 +0800
Subject: [PATCH 5/7] The Qt fixture's .ts is lupdate's output for the program
 as it now reads

---
 tests/qt-consumer/qt_consumer_de.ts | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/tests/qt-consumer/qt_consumer_de.ts b/tests/qt-consumer/qt_consumer_de.ts
index 08e26d3..449e8d9 100644
--- a/tests/qt-consumer/qt_consumer_de.ts
+++ b/tests/qt-consumer/qt_consumer_de.ts
@@ -1,10 +1,18 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS>
 <TS version="2.1" language="de_DE">
+<context>
+    <name>QProgressDialog</name>
+    <message>
+        <location filename="src/main.cpp" line="52"/>
+        <source>Cancel</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>main</name>
     <message>
-        <location filename="src/main.cpp" line="43"/>
+        <location filename="src/main.cpp" line="51"/>
         <source>hello</source>
         <translation>hallo</translation>
     </message>

From 3f885d04860dbfbed4abef9e3faa779b25ee3535 Mon Sep 17 00:00:00 2001
From: sunrisepeak <speakshen@163.com>
Date: Sat, 26 Sep 2026 17:02:09 +0800
Subject: [PATCH 6/7] The Qt fixture reads Qt's own string through variables,
 so lupdate keeps it out of the program's .ts

---
 tests/qt-consumer/qt_consumer_de.ts | 8 --------
 tests/qt-consumer/src/main.cpp      | 6 +++++-
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/tests/qt-consumer/qt_consumer_de.ts b/tests/qt-consumer/qt_consumer_de.ts
index 449e8d9..bd29912 100644
--- a/tests/qt-consumer/qt_consumer_de.ts
+++ b/tests/qt-consumer/qt_consumer_de.ts
@@ -1,14 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS>
 <TS version="2.1" language="de_DE">
-<context>
-    <name>QProgressDialog</name>
-    <message>
-        <location filename="src/main.cpp" line="52"/>
-        <source>Cancel</source>
-        <translation type="unfinished"></translation>
-    </message>
-</context>
 <context>
     <name>main</name>
     <message>
diff --git a/tests/qt-consumer/src/main.cpp b/tests/qt-consumer/src/main.cpp
index d2a75af..e2c15f4 100644
--- a/tests/qt-consumer/src/main.cpp
+++ b/tests/qt-consumer/src/main.cpp
@@ -49,7 +49,11 @@ int main(int argc, char** argv) {
     }
     QCoreApplication::installTranslator(&qtTranslator);
     const QString hello  = QCoreApplication::translate("main", "hello");
-    const QString cancel = QCoreApplication::translate("QProgressDialog", "Cancel");
+    // Through variables, so lupdate does not take Qt's own string into this
+    // program's .ts: it extracts literals only.
+    const char* qtContext = "QProgressDialog";
+    const char* qtSource  = "Cancel";
+    const QString cancel = QCoreApplication::translate(qtContext, qtSource);
 
     std::printf("qt-consumer: signal %d, resource '%s', translation '%s', Qt %s, Qt's own '%s'\n",
                 relay.seen, text.constData(), hello.toUtf8().constData(), qVersion(),

From 9b16cbcf932cc66d97ab9a2ed5d0816d0795e867 Mon Sep 17 00:00:00 2001
From: sunrisepeak <speakshen@163.com>
Date: Sat, 26 Sep 2026 17:22:49 +0800
Subject: [PATCH 7/7] The archive criterion finds the packed program where the
 platform puts it: the root of the tree for a PE program, bin/ otherwise

---
 .github/scripts/check-deps-and-qt.sh | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/scripts/check-deps-and-qt.sh b/.github/scripts/check-deps-and-qt.sh
index 674e62e..3b087be 100644
--- a/.github/scripts/check-deps-and-qt.sh
+++ b/.github/scripts/check-deps-and-qt.sh
@@ -175,9 +175,11 @@ archive_consumer() {
     "$MCPP" pack --format dir > target/ci/pack.log 2>&1 || { cat target/ci/pack.log; fail "mcpp pack failed"; }
     find target/dist -path '*/runtime/bundle/nested/deep.txt' | grep -q . ||
         fail "the packed tree does not carry the archive's files"
+    # A PE program sits at the root of the packed tree, an ELF or Mach-O one
+    # under bin/; the deployed files are beside it either way.
     local packed
-    packed=$(find target/dist -path '*/bin/archive-consumer*' -type f | grep -vE '\.(pdb|debug)$' | head -1)
-    [ -n "$packed" ] || fail "no packed program"
+    packed=$(find target/dist -type f \( -name archive-consumer -o -name archive-consumer.exe \) | head -1 || true)
+    [ -n "$packed" ] || fail "no packed program under target/dist"
     "$packed" | grep -q "^archive-consumer: 'greetings from the archive'" ||
         fail "the packed program did not read the archive's files"
     echo "ok: the packed tree carries the archive's files, and the packed program reads them"