fix(dist-apple): the bundle executes the staged program, not the tree's entry script (mcpp#634)

From the engine release that reads a Mach-O program's closure, `mcpp
pack` also writes `<tree>/<target>`, a shell script that executes
`bin/<target>` from the tree's root. launcher_in took that root entry
first, so the bundle's executable was the script, and it executed
Contents/MacOS/bin/<target>, which no bundle carries (macos-15, run
34821164486, job 103902829865: "cannot execute: No such file or
directory", exit 126). The search now takes bin/<target> first; the
framework rpath resolves against the program's own directory, which has
to be Contents/MacOS/.

check-apple-plan.sh and check-ios-plan.sh fabricate the entry script
beside the program, as the engine writes it, and assert that the layout
step copies bin/<target>; both fail against the previous member.

Author: Sunrisepeak

dist/apple.cppm

@@ -389,13 +389,24 @@ inline std::string app_name_for(const options& opt) {
     return (n && *n) ? std::string(n) : std::string("app");
 }
 
-// The staged tree's top-level launcher -- the same search
-// `dist/appimage.cppm` performs, and for the same reason: `mcpp pack` writes
-// one per mode and names it after the binary, so this member states no
-// convention mcpp has not already put on disk.
+// The program a bundle executes, found in the staged tree: `bin/<target>`
+// first, then the tree's top-level entry, then `run.sh`.
+//
+// THE PROGRAM, NOT THE TREE'S ENTRY SCRIPT. From the release that reads a
+// Mach-O program's closure (mcpp 2026.9.14.2), the engine also writes
+// `<tree>/<target>`, a shell script that executes `bin/<target>` from the
+// tree's root. The search used to take that root entry first, which is the
+// order `dist/appimage.cppm` needs, and a bundle then executed the script,
+// which executed `Contents/MacOS/bin/<target>` -- a file no bundle carries:
+// "cannot execute: No such file or directory", exit 126 (macos-15, run
+// 34821164486). The script has no work to do inside a bundle, where
+// `CFBundleExecutable` names the program directly, and the framework rpath
+// `@executable_path/../Frameworks` resolves against the program's own
+// directory, which has to be `Contents/MacOS/`. The root entry and `run.sh`
+// remain for a tree that carries no `bin/<target>`.
 inline std::string launcher_in(const std::string& stage, const std::string& target) {
-    for (auto candidate : {stage + "/" + target,
-                           stage + "/bin/" + target,
+    for (auto candidate : {stage + "/bin/" + target,
+                           stage + "/" + target,
                            stage + "/run.sh"})
         if (is_file(candidate)) return candidate;
     return {};
@@ -407,15 +418,9 @@ inline std::string launcher_in(const std::string& stage, const std::string& targ
 // within `Contents/MacOS/`, and real-world bundle tooling has hit this
 // directly enough to be a filed CMake defect: "CFBundleExecutable path in a
 // bundle should not be a relative path into bundle." So this member takes
-// only the basename of whatever `launcher_in` finds. That is exactly correct
-// when the staged tree's launcher sits at the tree's ROOT, which is the
-// default `--mode vendored` shape `dist/appimage.cppm`'s own header comment
-// describes ("a top-level launcher"). A staged tree whose launcher were
-// nested under `bin/` instead would still copy correctly by the layout step
-// below, but the resulting bundle would name an executable that is not at
-// the top of `Contents/MacOS/`, and this member does not flatten that case --
-// it is not exercised by the default staging mode, and nothing here can
-// exercise it on Linux to find out how macOS actually responds.
+// only the basename of whatever `launcher_in` finds, and the layout step
+// copies that file to the top of the executable directory under that name, so
+// the name and the file agree wherever in the staged tree it was found.
 inline std::string bundle_executable_name(const std::string& launcher_path) {
     return std::filesystem::path(launcher_path).filename().string();
 }
@@ -630,7 +635,7 @@ inline plan plan_for(options opt = {}) {
         return refuse(p, "no launcher in the staged tree", std::format(
             "mcpp.dist.apple: the staged tree at {0} carries no launcher for "
             "target '{1}'.\n"
-            "  expected one of: {0}/{1}, {0}/bin/{1}, {0}/run.sh",
+            "  expected one of: {0}/bin/{1}, {0}/{1}, {0}/run.sh",
             stage, target));
     }
     // CFBundleExecutable is a bare filename (see the note above). With no

tests/app-framework-consumer/check-apple-plan.sh

@@ -22,13 +22,16 @@ rm -rf target
 BIN=target/.build-mcpp/build.mcpp.bin
 [ -x "$BIN" ] || fail "no compiled build.mcpp.bin at $BIN" build.log
 
-# stage_tree <closure> : a staged tree with the program, its dylib and a
-# deployed resource, and the stage manifest the engine writes for it.
+# stage_tree <closure> : a staged tree with the program, its dylib, a deployed
+# resource and the entry script the engine writes at the tree's root, and the
+# stage manifest the engine writes for it.
 stage_tree() {
     local stage
     stage=$(mktemp -d)
     mkdir -p "$stage/bin/data"
     head -c 5000 /dev/urandom > "$stage/bin/app-framework-consumer"
+    printf '#!/bin/sh\nhere=$(cd "$(dirname "$0")" && pwd)\nexec "$here/bin/app-framework-consumer" "$@"\n' \
+        > "$stage/app-framework-consumer"
     head -c 4000 /dev/urandom > "$stage/bin/libapp-framework-dep.dylib"
     echo hello > "$stage/bin/data/greeting.txt"
     {
@@ -83,6 +86,11 @@ echo "== --format app on macOS, with a staged dylib =="
 stage=$(stage_tree walked)
 run_program app macos "" "$stage" /tmp/apple-plan-app.log
 check /tmp/apple-plan-app.log '
+layout = actions.get("mcpp.dist.apple.layout")
+if not layout: fail("no layout step")
+if not layout["command"][1].endswith("/bin/app-framework-consumer") or \
+        not layout["command"][2].endswith("/AppFrameworkConsumer.app/Contents/MacOS/app-framework-consumer"):
+    fail("the bundle executable is not the staged program bin/app-framework-consumer: " + repr(layout["command"]))
 fw = actions.get("mcpp.dist.apple.framework.libapp-framework-dep.dylib")
 if not fw: fail("no framework step for the staged dylib")
 if not fw["outputs"] or not fw["outputs"][0].endswith("/AppFrameworkConsumer.app/Contents/Frameworks/libapp-framework-dep.dylib"):
@@ -109,7 +117,7 @@ if "mcpp:link-flag=-Wl,-rpath,@executable_path/../Frameworks" not in lines:
 if "mcpp:runner-named=app:macapp-run" not in lines:
     fail("the app runner was not supplied")
 '
-echo "ok: the dylib is a framework signed ad hoc, not a resource; the bundle is signed after it; the rpath and the runner are declared"
+echo "ok: the program, not the tree's entry script, is the bundle executable; the dylib is a framework signed ad hoc, not a resource; the bundle is signed after it; the rpath and the runner are declared"
 
 echo "== --format dmg on macOS =="
 run_program dmg macos "" "$stage" /tmp/apple-plan-dmg.log

tests/ios-app-consumer/check-ios-plan.sh

@@ -102,6 +102,10 @@ run_row() {
         stage=$(mktemp -d)
         mkdir -p "$stage/bin"
         head -c 5000 /dev/urandom > "$stage/bin/ios-app-consumer"
+        # The entry script the engine writes at the tree's root beside a Mach-O
+        # program (mcpp 2026.9.14.2+), which a bundle must not execute.
+        printf '#!/bin/sh\nhere=$(cd "$(dirname "$0")" && pwd)\nexec "$here/bin/ios-app-consumer" "$@"\n' \
+            > "$stage/ios-app-consumer"
     fi
     out=$(mktemp -d)
     env -i PATH="$PATH" \
@@ -147,9 +151,11 @@ grep -q 'AppIcon76x76@2x~ipad</string>' "$plist" || fail "the icon list is missi
 # bytes in it to stay quiet.
 grep 'mcpp.dist.apple.layout' "$log" | grep -q '\${mcpp\.stage_dir}' \
     || fail "the layout step did not name \${mcpp.stage_dir} for a non-empty staged tree" "$log"
+grep 'mcpp.dist.apple.layout' "$log" | grep -q '"command":\["ditto","[^"]*/bin/ios-app-consumer",' \
+    || fail "the bundle executable is not the staged program bin/ios-app-consumer" "$log"
 grep -q 'holds only' "$log" \
     && fail "a non-empty staged tree still produced the 0-byte staged-tree warning" "$log"
-echo "ok: flat layout, no codesign, a named warning, and every iOS-only plist key"
+echo "ok: flat layout, the staged program as the executable, no codesign, a named warning, and every iOS-only plist key"
 check_terminal_bundle "$log"
 
 echo "== iOS Simulator row, an empty pack_stage_dir (#622 B2 defect 1) =="