0.9.2: dist-apple places deployed files at the bundle's resource destination (mcpp#630) (#22)

* dist-apple: the staged tree's deployed files land at the bundle's resource destination, and the iOS fixture declares its runtime packages (mcpp#630)

* README: dist-apple places deployed files at the resource destination

* the builtins package is 22.1.8.4

* 0.9.2: dist-apple places deployed files at the resource destination; CI measures under mcpp 2026.9.13.2

* the builtins package is 22.1.8.5

* dist-apple: a step owns its id and description; the version literal is 0.9.2

---------

Co-authored-by: speak-agent <x.d2learn.org@gmail.com>

Author: Sunrisepeak

.github/workflows/ci.yml

@@ -29,7 +29,7 @@ env:
   # every dispatched format was unreachable on macOS, including one that never
   # reads the staged tree. Staging is a service to the provider in 2026.9.11.2,
   # and `dist-apple` has been unreachable, not broken, since it was written.
-  MCPP_VERSION: 2026.9.13.1
+  MCPP_VERSION: 2026.9.13.2
   # PINNED, AND WITHOUT IT THE CACHE BELOW CACHED NOTHING.
   #
   # A released mcpp is self-contained: with no `MCPP_HOME`, `mcpp self env`
@@ -1805,7 +1805,16 @@ jobs:
           # hand and got subtly wrong would otherwise fail at launch time on a
           # user's machine and nowhere here.
           plutil -lint "$app/Contents/Info.plist"
-          echo "ok: one bundle, a valid plist, and it launches"
+          # THE DEPLOYED FILE, AT THE RESOURCE DESTINATION AND NOT BESIDE THE
+          # PROGRAM (mcpp#630, item 3a): the engine stages `bin/data/...` and
+          # this member places it under `Contents/Resources/`.
+          test -f "$app/Contents/Resources/data/greeting.txt" \
+            || { echo "FAIL: the deployed file is not under Contents/Resources"; find "$app" -type f; exit 1; }
+          if [ -e "$app/Contents/MacOS/bin" ]; then
+            echo "FAIL: the staged tree was copied whole into Contents/MacOS"; find "$app" -type f; exit 1
+          fi
+          grep -q 'closure = not-walked' pack.log || echo "note: the stage manifest's closure line was not echoed by pack"
+          echo "ok: one bundle, a valid plist, it launches, and the resource is where NSBundle looks"
 
       # THE iOS ROW, FOR REAL (#622 B1's other half). `tests/ios-app-consumer`
       # is the same fixture the Linux `consumers` job checks at the plan
@@ -1868,6 +1877,12 @@ jobs:
           [ "$plat" = "iPhoneSimulator" ] || {
             echo "FAIL: CFBundleSupportedPlatforms is '$plat', expected iPhoneSimulator"
             exit 1; }
+          # THE DEPLOYED FILE, AT THE BUNDLE ROOT (the flat layout), and the
+          # executable at the root by its bare name -- not under `bin/`.
+          test -f "$app/data/greeting.txt" \
+            || { echo "FAIL: the deployed file is not at the bundle root"; find "$app" -type f; exit 1; }
+          test -x "$app/ios-app-consumer" \
+            || { echo "FAIL: the executable is not at the bundle root"; find "$app" -type f; exit 1; }
 
           exe=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$plist")
           test -x "$app/$exe" \

README.md

@@ -73,7 +73,7 @@ engine's own module family and is not used here.
 | `tools-island` | `mcpp.tools.island` | 2026.9.7.1 | nothing beyond mcpp: it reads marked entry points out of an island's own source and writes the `extern "C"` boundary header its compiler reads and the module the C++ side imports. Not a device rule -- it claims no extension, and a project calls it from its own `build.mcpp` |
 | `dist-appimage` | `mcpp.dist.appimage` | 2026.9.11.1 | `xim:appimagetool`, which this feature declares on the `cfg(linux)` axis. Linux only. Turns the tree `mcpp pack` staged into one AppImage: the staged bundle is already an AppDir bar three files, so the member writes an `AppRun`, a `.desktop` entry and an icon into it and invokes one tool -- it never copies or re-lays-out a tree that can be hundreds of megabytes |
 | `dist-wix` | `mcpp.dist.wix` | 2026.9.11.1 | `xim:wix`, which this feature declares on the Windows target axis; the .NET 6 runtime the tool needs is a Windows component the payload does not carry, and `wix --version` names it when it is missing. Windows only. Renders a `.wxs` and passes the program in as a preprocessor variable, because a bind path that resolves to nothing is silent |
-| `dist-apple` | `mcpp.dist.apple` | 2026.9.11.2 (macOS), 2026.9.12.3 (iOS) | the base macOS install (`ditto`, and `codesign` only when an identity is given). 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 unchanged on the device row. 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 |
+| `dist-apple` | `mcpp.dist.apple` | 2026.9.11.2 (macOS), 2026.9.12.3 (iOS) | the base macOS install (`ditto`, and `codesign` only when an identity is given). 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 unchanged on the device row. 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 |
 | `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 |
 | `dist-apk` | `mcpp.dist.apk` | 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`; `android-build-tools`' own runtime dependency provisions a JDK for its OWN wrappers only), `xim:android-debug-keystore`, 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. `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), and this member reads its native library from the staged tree and whatever `mcpp::deploy` placed beside the ordinary build's link output, because Android's own closure stages neither the dependency set nor the deployed files (see `dist/apk.cppm`'s header). CI packages both level 0 and level 1 and checks the archive (`libc++_shared.so` bundled only when the closure's `NEEDED` entries require it, `mcpp::deploy`'d files under `assets/`); 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 |
 

dist/apple.cppm

@@ -246,9 +246,12 @@ struct options {
 // a different signing flag -- from becoming a reimplementation of this
 // member, the same trade `dist/appimage.cppm` makes.
 struct step {
-    const char*               id;
-    const char*                role;
-    const char*               description;
+    // Owned strings rather than literals: the resource steps below name one
+    // action per deployed entry, and an id derived from a file name has to
+    // outlive the function that formed it.
+    std::string               id;
+    const char*               role;
+    std::string               description;
     std::vector<std::string>  argv;
     std::vector<std::string>  inputs;
     // MORE THAN ONE OUTPUT ON THE iOS ICON STEP: a directory of PNGs copies
@@ -713,16 +716,66 @@ inline plan plan_for(options opt = {}) {
     // one and the program when there is not, and the `inputs` entry is the
     // same either way: the program is what this bundle is FOR, and naming it
     // is what orders this action after the link.
+    //
+    // WITH A STAGED TREE IT COPIES THE PROGRAM, NOT THE TREE. The engine
+    // stages a Mach-O program as `bin/<name>` with every deployed file under
+    // `bin/<to>/...` beside it (mcpp#630, item 3a: staging precedes the
+    // closure walk, and the tree is handed over with `closure = not-walked`
+    // in its manifest). Copying that tree whole into `Contents/MacOS/` put
+    // the executable at `Contents/MacOS/bin/<name>`, which is not where
+    // `CFBundleExecutable` says it is, and the resources beside a program
+    // rather than in `Contents/Resources/`, where `NSBundle` looks. So the
+    // launcher goes to the executable directory by itself, and the staged
+    // `bin/` entries that are not the launcher go to the bundle's resource
+    // destination below, at the relative path `mcpp::deploy`'s `to` gave
+    // them. `${mcpp.stage_dir}` is still named as an input of the launcher
+    // copy, which is what orders every step here after staging and gives
+    // the action its dependency on the tree's manifest.
     layout.argv         = stage.empty()
         ? std::vector<std::string>{ "ditto",
               std::format("${{mcpp.target_file:{}}}", target),
               execDir + "/" + executableName }
-        : std::vector<std::string>{ "ditto", "${mcpp.stage_dir}", execDir };
+        : std::vector<std::string>{ "ditto", launcher, execDir + "/" + executableName };
     layout.inputs       = { std::format("${{mcpp.target_file:{}}}", target) };
+    if (!stage.empty()) layout.inputs.push_back("${mcpp.stage_dir}");
     layout.outputs      = { execDir + "/" + executableName };
     p.steps.push_back(layout);
     assembled.push_back(execDir + "/" + executableName);
 
+    // THE DEPLOYED FILES, AT THE BUNDLE'S RESOURCE DESTINATION.
+    //
+    // Read at plan time against the staged tree, the way `dist-apk` reads
+    // its assets: the second pass of `mcpp pack --format app` runs this
+    // program after the tree is staged, so the entries exist on disk here.
+    // One action per top-level entry under `bin/` that is not the launcher,
+    // a file or a whole directory, each named by its own path so that the
+    // graph carries an edge per deployed thing rather than one edge for
+    // "everything". `ditto <dir> <dir>` copies the source's CONTENTS into
+    // the destination, which is the flat layout iOS wants at the bundle
+    // root and the `Contents/Resources/<to>/` layout macOS wants.
+    if (!stage.empty()) {
+        const std::filesystem::path stageBin = std::filesystem::path(stage) / "bin";
+        const std::filesystem::path launcherPath = std::filesystem::path(launcher);
+        std::error_code ec;
+        std::vector<std::filesystem::path> entries;
+        if (std::filesystem::is_directory(stageBin, ec))
+            for (auto const& e : std::filesystem::directory_iterator(stageBin, ec))
+                if (!ec && e.path() != launcherPath) entries.push_back(e.path());
+        std::ranges::sort(entries);
+        for (auto const& e : entries) {
+            const std::string rel = e.filename().string();
+            step res;
+            res.id          = "mcpp.dist.apple.resource." + rel;
+            res.role        = "artifact";
+            res.description = "APP RESOURCE " + rel;
+            res.argv        = { "ditto", e.string(), resourceDir + "/" + rel };
+            res.inputs      = { e.string(), "${mcpp.stage_dir}" };
+            res.outputs     = { resourceDir + "/" + rel };
+            p.steps.push_back(res);
+            assembled.push_back(resourceDir + "/" + rel);
+        }
+    }
+
     if (!opt.icon.empty()) {
         step icon;
         icon.id          = "mcpp.dist.apple.icon";
@@ -827,9 +880,9 @@ inline bool submit(const plan& p) {
     if (!p.applies) return true;
     for (auto const& s : p.steps) {
         mcpp::action a;
-        a.id          = s.id;
+        a.id          = s.id.c_str();
         a.role        = s.role;
-        a.description = s.description;
+        a.description = s.description.c_str();
         for (auto const& tok : s.argv)    a.arg(tok.c_str());
         for (auto const& in  : s.inputs)  a.input(in.c_str());
         for (auto const& out : s.outputs) a.output(out.c_str());

mcpp.toml

@@ -1,7 +1,7 @@
 [package]
 name        = "plugins"
 namespace   = "mcpp"
-version     = "0.9.1"
+version     = "0.9.2"
 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"]

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.9.1";
+inline constexpr std::string_view version = "0.9.2";
 
 } // namespace mcpp::plugins
 

tests/app-consumer/mcpp.toml

@@ -23,3 +23,10 @@ plugins = { path = "../..", features = ["dist-apple"], host-module = true }
 [targets.app-consumer]
 kind = "bin"
 main = "src/main.cpp"
+
+# A deployed file, which the bundle must carry at its resource destination
+# (`Contents/Resources/data/greeting.txt` on macOS). The engine stages it at
+# `bin/data/greeting.txt` beside the program (mcpp#630, item 3a), and
+# `dist-apple` places every such entry under the resource directory.
+[runtime]
+deploy = [ { from = "share/greeting.txt", to = "data" } ]

tests/app-consumer/share/greeting.txt

@@ -0,0 +1 @@
+bundled resource

tests/ios-app-consumer/mcpp.toml

@@ -59,6 +59,19 @@ ios_deployment_target = "17.0"
 kind = "bin"
 main = "src/main.cpp"
 
+# THE C++ STANDARD LIBRARY AND THE COMPILER RUNTIME ARE PACKAGES ON THE iOS
+# ROWS (mcpp#630, item 4). The payload's static libc++ is a macOS object and
+# its resource directory carries no iOS builtins archive; without these two
+# lines the engine links the SDK's libc++ under the payload's headers and
+# reports the pairing once. This fixture imports `std`, so it declares them.
+[target.'cfg(os = "ios")'.dependencies]
+llvm.libcxx               = "22.1.8.1"
+llvm.compiler-rt-builtins = "22.1.8.5"
+
+# A deployed file, which the iOS bundle carries at its root (the flat layout).
+[runtime]
+deploy = [ { from = "share/greeting.txt", to = "data" } ]
+
 # THE SIMULATOR ROW ONLY -- the device row (`aarch64-ios`) keeps `runner`
 # unset, as `examples/13-platform-targets/mcpp.toml` does: an artifact cannot
 # be run off an iOS device without a signature the developer owns.

tests/ios-app-consumer/share/greeting.txt

@@ -0,0 +1 @@
+bundled resource