catalyst-core 1.1.0 → 1.2.0-canary.2

package/dist/native/buildAppIos.js

@@ -3,6 +3,7 @@
 const path = require("path");
 const {
   createIosBuild,
+  IOS_BUILD_STEPS,
   pwd
 } = require("./buildIos/index.js");
 const {
@@ -23,30 +24,158 @@ const {
 const {
   loadAppConfig
 } = require("../cli/appConfig.js");
+const {
+  ensureDevServer,
+  migrateLanAddresses
+} = require("./setupServer.js");
+const {
+  parseNativeArgs
+} = require("./utils.js");
+const {
+  ensureXcodeReady,
+  prepareIosDebugTarget
+} = require("./iosToolchain.js");
+const {
+  isReleaseBuildType
+} = require("./buildIos/signing.js");
+const TerminalProgress = require("./terminalProgress.js").default;
 const catalystCorePath = path.dirname(require.resolve("catalyst-core/package.json"));
 const {
   WEBVIEW_CONFIG,
   BUILD_OUTPUT_PATH
 } = loadAppConfig();
+
+/** A coded error (IOS-002 and on, NATIVE-*) is our own; anything else is the toolchain's. */
+const reportCode = error => /^(IOS|NATIVE)-\d{3}$/.test(error?.code) ? error.code : "IOS-000";
+function reportVerbose(error) {
+  // --verbose/--debug add the registry's boxed report, printed with
+  // console.error rather than progress.log, which would prefix every
+  // border line and break the box.
+  if (resolveOutputMode() !== "default") {
+    console.error(formatBuildError({
+      code: reportCode(error),
+      category: reportCode(error).split("-")[0],
+      upstreamName: "Xcode/CocoaPods",
+      error
+    }));
+  } else if (process.env.CATALYST_DEBUG && error.stack) {
+    console.error(error.stack);
+  }
+}
 async function main() {
-  const build = createIosBuild({
-    WEBVIEW_CONFIG,
-    BUILD_OUTPUT_PATH
+  // --release / --url / --device / --yes / --accept-licenses. Xcode is
+  // checked, the simulator or iPhone chosen and the config resolved (start
+  // URL and its guard, app id, version, signing files) before Xcode
+  // builds, so those failures surface first.
+  const cwd = process.cwd();
+  const progress = new TerminalProgress(IOS_BUILD_STEPS, "catalyst buildApp", {
+    subject: "ios"
   });
+  const log = (message, type) => progress.log(message, type);
+  let flags;
+  let build;
+  let devHost = "localhost";
+  try {
+    flags = parseNativeArgs(process.argv.slice(2));
+    // Older setups saved this machine's LAN address in config.json. Put
+    // localhost back once (never for a release or in CI), then read the
+    // config again.
+    const migration = migrateLanAddresses({
+      cwd,
+      release: flags.release,
+      platform: "ios"
+    });
+    const appConfig = migration.changes.length ? loadAppConfig() : {
+      WEBVIEW_CONFIG,
+      BUILD_OUTPUT_PATH
+    };
+    for (const change of migration.changes) {
+      log(`config.json ${change.path}: ${change.from} -> ${change.to}`, "info");
+    }
+    const release = flags.release || isReleaseBuildType(appConfig.WEBVIEW_CONFIG?.ios?.buildType);
+    let target;
+    if (process.platform === "darwin") {
+      progress.start("toolchain");
+      const developerDir = await ensureXcodeReady({
+        flags,
+        log
+      });
+      progress.log(`Using ${developerDir}`, "info");
+      progress.complete("toolchain");
+      // A release archives for any iOS device: no simulator, no phone.
+      if (!release) {
+        progress.start("target");
+        ({
+          target,
+          devHost
+        } = await prepareIosDebugTarget({
+          flags,
+          iosConfig: appConfig.WEBVIEW_CONFIG?.ios || {},
+          cwd,
+          log
+        }));
+        progress.log(target.target === "device" ? `iPhone ${target.name}` : `Simulator ${target.name}`, "info");
+        progress.complete("target");
+      }
+    }
+    build = createIosBuild(appConfig, {
+      ...flags,
+      devHost,
+      target,
+      progress,
+      appRoot: cwd
+    });
+  } catch (error) {
+    if (progress.currentStep) progress.fail(progress.currentStep.id);
+    process.stderr.write(buildFailure({
+      error,
+      stage: "Resolving the iOS build",
+      code: reportCode(error)
+    }));
+    reportVerbose(error);
+    process.exit(1);
+  }
+
+  // One-command dev: a debug build starts the dev server when nothing
+  // answers on its port, and waits until it does. Only on macOS, the one
+  // place an iOS build can run. An iPhone reaches it on devHost, so the
+  // server listens beyond localhost then.
+  if (build.usesDevServer && process.platform === "darwin") {
+    try {
+      progress.start("server");
+      await ensureDevServer({
+        host: devHost,
+        cwd,
+        log
+      });
+      progress.complete("server");
+    } catch (error) {
+      progress.fail("server");
+      process.stderr.write(buildFailure({
+        error,
+        stage: "Starting the dev server",
+        code: reportCode(error)
+      }));
+      build.cleanup();
+      process.exit(1);
+    }
+  }
   const {
-    progress,
     generateConfigConstants,
     updateInfoPlist,
     updateEntitlements,
     syncPluginResources,
     buildForIOS,
+    buildReleaseForIOS,
     PROJECT_DIR
   } = build;
+  // The merged release config when this is a release build.
+  const wvConfig = build.WEBVIEW_CONFIG;
   let building = false;
   try {
-    const aiPlugin = resolveAIPluginSource(WEBVIEW_CONFIG, process.cwd(), (message, status = "info") => progress.log(message, status));
+    const aiPlugin = resolveAIPluginSource(wvConfig, process.cwd(), (message, status = "info") => progress.log(message, status));
     const pluginConfig = {
-      ...resolvePluginConfig(WEBVIEW_CONFIG),
+      ...resolvePluginConfig(wvConfig),
       ...aiPlugin.toggles
     };
     const pluginComposition = composeIosPlugins({
@@ -61,7 +190,7 @@ async function main() {
     await updateEntitlements(pluginComposition);
     await syncPluginResources(pluginComposition);
     building = true;
-    await buildForIOS(pluginComposition);
+    if (build.release) await buildReleaseForIOS(pluginComposition);else await buildForIOS(pluginComposition);
   } catch (error) {
     // buildForIOS already reported this through the progress tree, so the
     // default mode does not repeat it. The steps before it report nothing
@@ -74,21 +203,11 @@ async function main() {
         code: "IOS-000"
       }));
     }
-    // --verbose/--debug add the registry's boxed report, printed with
-    // console.error rather than progress.log, which would prefix every
-    // border line and break the box.
-    if (resolveOutputMode() !== "default") {
-      console.error(formatBuildError({
-        code: "IOS-000",
-        category: "IOS",
-        upstreamName: "Xcode/CocoaPods",
-        error
-      }));
-    } else if (process.env.CATALYST_DEBUG && error.stack) {
-      console.error(error.stack);
-    }
+    reportVerbose(error);
+    build.cleanup();
     process.exit(1);
   }
+  build.cleanup();
   process.exit(0);
 }
 if (require.main === module) {

package/dist/native/buildIos/assets.js

@@ -3,6 +3,9 @@
 const fs = require("fs");
 const path = require("path");
 const crypto = require("crypto");
+const {
+  checkAppIcon
+} = require("../appIcon.js");
 const GOOGLE_SERVICES_FILENAME = "GoogleService-Info.plist";
 const NOTIFICATION_ICONS = [{
   sourceName: "notification-icon",
@@ -468,12 +471,64 @@ module.exports = function createAssetsPhase(ctx) {
       progress.log(`Warning: Error copying splash screen assets: ${error.message}`, "warning");
     }
   }
-  async function copyAppIcon() {
+
+  /**
+   * The single public/icon.png as a one-entry universal 1024 AppIcon, which
+   * Xcode scales to every size. Leftover sized images are removed so the
+   * set holds only what Contents.json lists.
+   */
+  function applySingleAppIcon(iconPath, iconSetDir, {
+    release
+  }) {
+    checkAppIcon(iconPath, {
+      platform: "ios",
+      release,
+      log: (message, type) => progress.log(message, type)
+    });
+    fs.mkdirSync(iconSetDir, {
+      recursive: true
+    });
+    for (const file of fs.readdirSync(iconSetDir)) {
+      if (file !== "Contents.json") fs.rmSync(path.join(iconSetDir, file), {
+        force: true
+      }); // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - iconSetDir is the template's own asset folder; file comes from readdirSync on it.
+    }
+    fs.copyFileSync(iconPath, `${iconSetDir}/icon.png`);
+    const contents = {
+      images: [{
+        filename: "icon.png",
+        idiom: "universal",
+        platform: "ios",
+        size: "1024x1024"
+      }],
+      info: {
+        author: "xcode",
+        version: 1
+      }
+    };
+    fs.writeFileSync(`${iconSetDir}/Contents.json`, JSON.stringify(contents, null, 2));
+    progress.log("Applied the app icon from public/icon.png", "success");
+  }
+
+  /**
+   * App icons, first match wins: the sized files in public/ios/appIcons,
+   * then the single public/icon.png. With neither, the template's icon stays.
+   *
+   * @param {object} [options]
+   * @param {boolean} [options.release] - an icon with alpha fails a release (ITMS-90717)
+   */
+  async function copyAppIcon({
+    release = false
+  } = {}) {
+    const publicDir = `${process.cwd()}/public/ios/appIcons`;
+    const singleIconPath = `${process.cwd()}/public/icon.png`;
+    const assetsDir = `${PROJECT_DIR}/${PROJECT_NAME}/Assets.xcassets`;
+    const iconSetDir = `${assetsDir}/AppIcon.appiconset`;
     try {
-      const publicDir = `${process.cwd()}/public/ios/appIcons`;
-      const assetsDir = `${PROJECT_DIR}/${PROJECT_NAME}/Assets.xcassets`;
-      const iconSetDir = `${assetsDir}/AppIcon.appiconset`;
       if (!fs.existsSync(publicDir)) {
+        if (fs.existsSync(singleIconPath)) applySingleAppIcon(singleIconPath, iconSetDir, {
+          release
+        });
         return;
       }
       const iconSizes = [{
@@ -529,6 +584,16 @@ module.exports = function createAssetsPhase(ctx) {
       };
       const allImages = findImagesRecursively(publicDir, imageExtensions);
       const foundIcons = [];
+      const hasSizedIcon = iconSizes.some(({
+        size,
+        scale
+      }) => allImages.some(imgPath => path.parse(imgPath).name === `icon-${size}-${scale}`));
+      if (!hasSizedIcon && fs.existsSync(singleIconPath)) {
+        applySingleAppIcon(singleIconPath, iconSetDir, {
+          release
+        });
+        return;
+      }
       if (!fs.existsSync(iconSetDir)) fs.mkdirSync(iconSetDir, {
         recursive: true
       });
@@ -546,6 +611,11 @@ module.exports = function createAssetsPhase(ctx) {
           version: 1
         }
       };
+      // Drop a single icon.png left by an earlier build; the sized set replaces it.
+      contents.images = contents.images.filter(img => img.filename !== "icon.png");
+      fs.rmSync(`${iconSetDir}/icon.png`, {
+        force: true
+      });
       for (const {
         size,
         idiom,
@@ -592,6 +662,8 @@ module.exports = function createAssetsPhase(ctx) {
         progress.log("Example: icon-20x20-2x.png, icon-60x60-3x.png, icon-1024x1024-1x.png", "info");
       }
     } catch (error) {
+      // An unusable public/icon.png is the user's to fix, not a warning to scroll past.
+      if (/^IOS-\d{3}$/.test(error?.code)) throw error;
       progress.log(`Warning: Error copying app icons: ${error.message}`, "warning");
     }
   }

package/dist/native/buildIos/build.js

@@ -10,6 +10,9 @@ const {
 const {
   runInteractiveCommand
 } = require("../utils.js");
+const {
+  xcodeAuthArgs
+} = require("./signing.js");
 module.exports = function createBuildPhase(ctx) {
   const {
     WEBVIEW_CONFIG,
@@ -24,6 +27,10 @@ module.exports = function createBuildPhase(ctx) {
 
   // ─── Simulator helpers ────────────────────────────────────────────────────
 
+  // The simulator buildAppIos.js chose (its udid), else whichever is booted.
+  // The udid goes into shell strings, so only hex digits and hyphens pass.
+  const simulatorUdid = () => ctx.target?.target === "simulator" && /^[A-Fa-f0-9-]+$/.test(String(ctx.target.udid || "")) ? ctx.target.udid : null;
+  const simctlDevice = () => simulatorUdid() || "booted";
   async function getBootedSimulatorUUID(modelName) {
     const UUID_RE = /[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}/i;
     try {
@@ -138,7 +145,9 @@ module.exports = function createBuildPhase(ctx) {
         ${action}`;
   }
   async function buildProject(scheme, sdk, destination, bundleId, derivedDataPath, projectName) {
-    const bootedInfo = await getBootedSimulatorInfo();
+    const bootedInfo = simulatorUdid() ? {
+      udid: simulatorUdid()
+    } : await getBootedSimulatorInfo();
     if (!bootedInfo) throw new Error("No booted simulator found");
     progress.status(`simulator ${bootedInfo.udid.slice(0, 8)}`);
     const isNotificationsEnabled = WEBVIEW_CONFIG.notifications?.enabled ?? false;
@@ -161,7 +170,10 @@ module.exports = function createBuildPhase(ctx) {
       const derivedDataPath = path.join(os.homedir(), "Library/Developer/Xcode/DerivedData");
       try {
         progress.status("building for specified simulator");
-        await buildProject(SCHEME_NAME, "iphonesimulator", `platform=iOS Simulator,name=${IPHONE_MODEL}`, APP_BUNDLE_ID, derivedDataPath, PROJECT_NAME);
+        await buildProject(SCHEME_NAME, "iphonesimulator",
+        // Several runtimes can each have a simulator with this
+        // name; the udid buildAppIos.js chose is unambiguous.
+        simulatorUdid() ? `platform=iOS Simulator,id=${simulatorUdid()}` : `platform=iOS Simulator,name=${IPHONE_MODEL}`, APP_BUNDLE_ID, derivedDataPath, PROJECT_NAME);
       } catch (buildError) {
         progress.log("Initial build failed, attempting fallback...", "info");
         const bootedUUID = await getBootedSimulatorUUID(IPHONE_MODEL);
@@ -208,52 +220,20 @@ module.exports = function createBuildPhase(ctx) {
       throw error;
     }
   }
-  async function moveAppToBuildOutput(APP_PATH) {
-    const {
-      BUILD_OUTPUT_PATH,
-      iosConfig
-    } = ctx;
-    try {
-      const buildType = iosConfig.buildType || "debug";
-      const appName = iosConfig.appName || "app";
-      const currentDate = new Date().toLocaleDateString("en-GB").replace(/\//g, "-");
-      // 24-hour and locale-free: "02-05-09 PM" put a space in every
-      // artifact name, which breaks unquoted shell use of the path.
-      const currentTime = new Date().toTimeString().slice(0, 8).replace(/:/g, "-");
-      // The app root, not process.cwd(): the iOS build chdirs into the
-      // Xcode project inside node_modules, so the artifact landed there
-      // and was wiped by the next npm install.
-      const destinationDir = path.join(
-      // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - appRoot is the local project root from the CLI context.
-      ctx.appRoot || process.cwd(), BUILD_OUTPUT_PATH,
-      // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - BUILD_OUTPUT_PATH is trusted application config.
-      "native", "ios", currentDate, buildType // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - buildType is "debug" or "release" from config.
-      );
-      const destinationPath = path.join(destinationDir, `${appName}-${currentTime}.app`); // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
-      if (!fs.existsSync(destinationDir)) fs.mkdirSync(destinationDir, {
-        recursive: true
-      });
-      await runCommand(`cp -R "${APP_PATH}" "${destinationPath}"`);
-      return destinationPath;
-    } catch (error) {
-      console.error("Error moving app to build output:", error.message);
-      throw error;
-    }
-  }
   async function uninstallExistingApp() {
     progress.status("uninstalling previous build");
-    await runCommand(`xcrun simctl uninstall booted "${APP_BUNDLE_ID}"`);
+    await runCommand(`xcrun simctl uninstall ${simctlDevice()} "${APP_BUNDLE_ID}"`);
   }
   async function installApp(APP_PATH) {
     progress.status("installing");
-    await runCommand(`xcrun simctl install booted "${APP_PATH}"`);
+    await runCommand(`xcrun simctl install ${simctlDevice()} "${APP_PATH}"`);
   }
   async function waitForInstallation() {
     progress.status("waiting for install");
     for (let i = 0; i < 30; i++) {
       try {
         // No shell: the bundle id is passed as an argv entry, never interpolated.
-        execFileSync("xcrun", ["simctl", "get_app_container", "booted", APP_BUNDLE_ID], {
+        execFileSync("xcrun", ["simctl", "get_app_container", simctlDevice(), APP_BUNDLE_ID], {
           stdio: ["ignore", "pipe", "ignore"]
         });
         break;
@@ -266,7 +246,7 @@ module.exports = function createBuildPhase(ctx) {
   async function handleLaunchError(error) {
     progress.status("checking app container");
     try {
-      await runCommand(`xcrun simctl get_app_container booted "${APP_BUNDLE_ID}"`);
+      await runCommand(`xcrun simctl get_app_container ${simctlDevice()} "${APP_BUNDLE_ID}"`);
     } catch {
       progress.log("App container not found", "warning");
     }
@@ -276,7 +256,7 @@ module.exports = function createBuildPhase(ctx) {
     progress.status("waiting for launch");
     for (let i = 0; i < 10; i++) {
       try {
-        const launchResult = execFileSync("xcrun", ["simctl", "launch", "booted", APP_BUNDLE_ID], {
+        const launchResult = execFileSync("xcrun", ["simctl", "launch", simctlDevice(), APP_BUNDLE_ID], {
           stdio: ["ignore", "pipe", "ignore"]
         }).toString();
         if (launchResult.includes("already launched")) {
@@ -291,7 +271,7 @@ module.exports = function createBuildPhase(ctx) {
   async function launchAndVerifyApp() {
     progress.status("launching");
     try {
-      await runCommand(`xcrun simctl launch booted "${APP_BUNDLE_ID}"`);
+      await runCommand(`xcrun simctl launch ${simctlDevice()} "${APP_BUNDLE_ID}"`);
       await verifyAppLaunch();
     } catch (error) {
       await handleLaunchError(error);
@@ -326,150 +306,20 @@ module.exports = function createBuildPhase(ctx) {
 
   // ─── Physical device ──────────────────────────────────────────────────────
 
-  // `instruments -s devices` is deprecated and its plain-text output is fragile
-  // to parse. `xcrun devicectl list devices --json-output <path>` is the modern,
-  // structured replacement (Xcode 15+) and is already used elsewhere in this
-  // file for install/launch, so use it as the primary detection source too.
-  // Note: devicectl lists simulators as well as physical devices, so filter on
-  // hardwareProperties.reality === "physical".
-  //
-  // Write to a temp file rather than `--json-output -` (stdout): Apple's own
-  // scripting guidance is a file path, and stdout support for `-` isn't
-  // guaranteed across every Xcode version this needs to run on — a temp file
-  // works the same way on every devicectl version. Falls back to
-  // xcodebuild -showdestinations below on any failure (old devicectl, no
-  // physical device, malformed output), so this only needs to work when it can.
-  // Matches the identifier format Apple's own tooling uses (hex digits and
-  // hyphens only, e.g. a UUID or the shorter legacy 40-char UDID). device.udid
-  // is later interpolated unquoted into shell command strings (xcodebuild
-  // -destination, xcrun devicectl --device, see installAndLaunchOnPhysicalDevice
-  // and buildProjectForPhysicalDevice) — the old instruments-based parser
-  // structurally constrained what could reach that string via its own regex;
-  // this is the equivalent guard for the JSON-based devicectl path, so a
-  // malformed or hostile identifier in devicectl's output can't inject shell
-  // syntax rather than just being rejected as "not a device".
-  const VALID_UDID_RE = /^[A-Fa-f0-9-]+$/;
-  function tryDevicectl() {
-    const tmpPath = path.join(os.tmpdir(), `catalyst-devicectl-${process.pid}-${Date.now()}.json`);
-    try {
-      execSync(`xcrun devicectl list devices --json-output "${tmpPath}"`, {
-        stdio: ["ignore", "ignore", "ignore"],
-        timeout: 30000
-      }); // nosemgrep: javascript.lang.security.audit.dangerous-spawn-shell-command.dangerous-spawn-shell-command - tmpPath is built from os.tmpdir()/process.pid/Date.now(), not user input.
-      const raw = fs.readFileSync(tmpPath, "utf8");
-      const parsed = JSON.parse(raw);
-      const devices = parsed?.result?.devices ?? [];
-      return devices.filter(d => d.hardwareProperties?.reality === "physical")
-      // devicectl lists every device it has ever paired with, reachable or
-      // not — a device that's unplugged or out of range still shows up with
-      // reality: "physical". Only tunnelState !== "unavailable" is actually
-      // installable/launchable right now; "disconnected" (paired, USB/Wi-Fi
-      // not currently active but developer-mode discoverable) still works for
-      // wired installs, so only "unavailable" is excluded here.
-      .filter(d => d.connectionProperties?.tunnelState !== "unavailable").map(d => ({
-        name: d.deviceProperties?.name ?? "Physical Device",
-        version: d.deviceProperties?.osVersionNumber ?? "Unknown",
-        udid: d.hardwareProperties?.udid ?? d.identifier,
-        type: "physical"
-      })).filter(d => typeof d.udid === "string" && VALID_UDID_RE.test(d.udid));
-    } catch (error) {
-      // A fallback is not a failure the user can act on; keep it for --verbose.
-      progress.log(`devicectl detection failed (${error.message}); falling back to xcodebuild destinations`, "info");
-      return [];
-    } finally {
-      try {
-        fs.unlinkSync(tmpPath);
-      } catch {
-        // Nothing to clean up if the command failed before writing the file.
-      }
-    }
-  }
-  async function detectPhysicalDevices() {
-    progress.start("deviceDetection");
-    const {
-      iosConfig
-    } = ctx;
-    try {
-      progress.status("scanning for connected physical devices");
-      let physicalDevices = [];
-      const configuredUDID = iosConfig.deviceUDID;
-      if (configuredUDID) {
-        progress.log(`Using configured device UDID: ${configuredUDID}`, "info");
-        const configuredDevice = tryDevicectl().find(d => d.udid === configuredUDID);
-        if (configuredDevice) {
-          progress.log(`Found configured physical device: ${configuredDevice.name} (${configuredDevice.version})`, "success");
-          progress.complete("deviceDetection");
-          return configuredDevice;
-        }
-        progress.log(`Configured device UDID not found in connected devices`, "warning");
-        progress.log("Falling back to auto-detection...", "info");
-      } else {
-        progress.status("no device udid configured, using auto-detection");
-      }
-      physicalDevices = tryDevicectl();
-      if (physicalDevices.length > 0) progress.log(`Found ${physicalDevices.length} physical device(s) via devicectl`, "success");
-      if (physicalDevices.length === 0) {
-        try {
-          const xcodebuildOutput = execSync(`xcodebuild -scheme "${SCHEME_NAME}" -showdestinations` // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process - SCHEME_NAME is generated from trusted iOS project config.
-          ).toString();
-          progress.status("scanning xcodebuild destinations for physical devices");
-          for (const line of xcodebuildOutput.split("\n")) {
-            const m = line.match(/\{\s*platform:iOS,\s*arch:(\w+),\s*id:([A-F0-9-]+),\s*name:(.+?)\s*\}/);
-            if (m) {
-              const [, arch, udid, name] = m;
-              progress.log(`Found device candidate: ${name.trim()} - ${udid}`, "info");
-              if (!udid.includes("placeholder") && udid.length > 20) {
-                progress.log(`Valid physical device: ${name.trim()}`, "success");
-                physicalDevices.push({
-                  name: name.trim(),
-                  version: "Unknown",
-                  udid,
-                  arch,
-                  type: "physical"
-                });
-              } else {
-                progress.log(`Skipping placeholder: ${name.trim()}`, "info");
-              }
-            }
-          }
-        } catch (error) {
-          progress.log("xcodebuild destinations failed", "info");
-          progress.log(`Error: ${error.message}`, "error");
-        }
-      }
-      if (physicalDevices.length > 0) {
-        progress.log(`Found ${physicalDevices.length} physical device(s):`, "success");
-        physicalDevices.forEach(d => progress.log(`  ${d.name} (${d.version || "Unknown iOS"}) - ${d.udid}`, "info"));
-        progress.complete("deviceDetection");
-        return physicalDevices[0];
-      } else {
-        // The normal case when building for the simulator, not a warning.
-        progress.log("No physical devices detected", "info");
-        progress.complete("deviceDetection");
-        return null;
-      }
-    } catch (error) {
-      progress.fail("deviceDetection", error.message);
-      return null;
-    }
-  }
   async function buildProjectForPhysicalDevice(scheme, bundleId, derivedDataPath, projectName, device) {
     progress.log(`Building for physical device: ${device.name}`, "info");
     const projectPath = `${process.cwd()}/${projectName}.xcodeproj`;
     if (!fs.existsSync(projectPath)) throw new Error(`Xcode project not found at: ${projectPath}. Current directory: ${process.cwd()}`);
     const isNotificationsEnabled = WEBVIEW_CONFIG.notifications?.enabled ?? false;
     progress.log(isNotificationsEnabled ? "Building with notifications enabled" : "Building without notifications", "info");
-    const buildCommand = `xcodebuild \
-        -scheme ${scheme} \
-        -sdk iphoneos \
-        -configuration Debug \
-        -destination platform=iOS,id=${device.udid} \
-        PRODUCT_BUNDLE_IDENTIFIER=${bundleId} \
-        ONLY_ACTIVE_ARCH=YES \
-        build`;
-    // The full command is a dozen wrapped lines of build settings; the
-    // streamed output below is what actually tells you how it is going.
-    return runCommandStreaming(buildCommand);
+    // Automatic signing may create or fetch the development certificate
+    // and profile and register this device: with the App Store Connect
+    // key when one is configured, else with the Apple account signed in
+    // to Xcode. A manual profile (ios.provisioningProfile) needs neither.
+    const signingArgs = ctx.signingPlan?.style === "manual" ? [] : xcodeAuthArgs(ctx.apiKey);
+    // The streamed output is what tells you how it is going; argv, not a
+    // shell string, so a key path with spaces needs no quoting.
+    return runCommandStreaming("xcodebuild", ["-scheme", scheme, "-sdk", "iphoneos", "-configuration", "Debug", "-destination", `platform=iOS,id=${device.udid}`, `PRODUCT_BUNDLE_IDENTIFIER=${bundleId}`, "ONLY_ACTIVE_ARCH=YES", ...signingArgs, "build"]);
   }
   async function findPhysicalDeviceAppPath() {
     const DERIVED_DATA_DIR = path.join(os.homedir(), "Library/Developer/Xcode/DerivedData");
@@ -574,7 +424,9 @@ module.exports = function createBuildPhase(ctx) {
         isBooted = false;
       Object.entries(simulatorsJson.devices).forEach(([, devices]) => {
         devices.forEach(device => {
-          if (device.name !== simulatorName) return;
+          // The chosen udid when there is one: stock simulators share
+          // names across runtimes.
+          if (simulatorUdid() ? device.udid !== simulatorUdid() : device.name !== simulatorName) return;
           const available = isDeviceAvailable(device);
           const alreadyBooted = device.state === "Booted";
           const isBetterMatch = !foundSimulator || available && !isDeviceAvailable(foundSimulator) || available === isDeviceAvailable(foundSimulator) && alreadyBooted && !isBooted;
@@ -663,9 +515,7 @@ module.exports = function createBuildPhase(ctx) {
     buildXcodeProject,
     buildProjectForTesting,
     findAppPath,
-    moveAppToBuildOutput,
     installAndLaunchApp,
-    detectPhysicalDevices,
     buildProjectForPhysicalDevice,
     findPhysicalDeviceAppPath,
     installAndLaunchOnPhysicalDevice,