@happier-dev/stack 0.2.0 → 0.2.11

package/scripts/utils/mobile/ios_podfile_autolinking.test.mjs

@@ -0,0 +1,79 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  IOS_MEMORY_PROFILING_AUTOLINKING_EXCLUDES,
+  patchIosPodfileAutolinkingForMemoryProfiling,
+} from './ios_podfile_autolinking.mjs';
+
+const GENERATED_PODFILE = `target 'Happierdev' do
+  use_expo_modules!
+
+  if ENV['EXPO_USE_COMMUNITY_AUTOLINKING'] == '1'
+    config_command = ['node', '-e', "process.argv=['', '', 'config'];require('@react-native-community/cli').run()"];
+  else
+    config_command = [
+      'node',
+      '--no-warnings',
+      '--eval',
+      'require(\\'expo/bin/autolinking\\')',
+      'expo-modules-autolinking',
+      'react-native-config',
+      '--json',
+      '--platform',
+      'ios'
+    ]
+  end
+
+  config = use_native_modules!(config_command)
+end
+`;
+
+test('patchIosPodfileAutolinkingForMemoryProfiling excludes dev-client modules from Expo and React Native autolinking', async () => {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-pod-autolinking-'));
+  try {
+    const uiDir = join(tmp, 'apps', 'ui');
+    await mkdir(join(uiDir, 'ios'), { recursive: true });
+    const podfilePath = join(uiDir, 'ios', 'Podfile');
+    await writeFile(podfilePath, GENERATED_PODFILE, 'utf8');
+
+    const result = await patchIosPodfileAutolinkingForMemoryProfiling({ uiDir });
+
+    const podfile = await readFile(podfilePath, 'utf8');
+    const rubyExcludeArray = IOS_MEMORY_PROFILING_AUTOLINKING_EXCLUDES.map((name) => `'${name}'`).join(', ');
+    assert.equal(result.changed, true);
+    assert.match(podfile, new RegExp(`use_expo_modules!\\(\\{ :exclude => \\[${rubyExcludeArray}\\] \\}\\)`));
+    assert.match(
+      podfile,
+      /'react-native-config',[\s\S]*'--platform',\s*'ios',\s*'--exclude',\s*'expo-dev-client',\s*'expo-dev-launcher',\s*'expo-dev-menu',\s*'expo-dev-menu-interface'/,
+    );
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('patchIosPodfileAutolinkingForMemoryProfiling is idempotent', async () => {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-pod-autolinking-'));
+  try {
+    const uiDir = join(tmp, 'apps', 'ui');
+    await mkdir(join(uiDir, 'ios'), { recursive: true });
+    const podfilePath = join(uiDir, 'ios', 'Podfile');
+    await writeFile(podfilePath, GENERATED_PODFILE, 'utf8');
+
+    await patchIosPodfileAutolinkingForMemoryProfiling({ uiDir });
+    const once = await readFile(podfilePath, 'utf8');
+    const result = await patchIosPodfileAutolinkingForMemoryProfiling({ uiDir });
+    const twice = await readFile(podfilePath, 'utf8');
+
+    assert.equal(result.changed, false);
+    assert.equal(twice, once);
+    for (const moduleName of IOS_MEMORY_PROFILING_AUTOLINKING_EXCLUDES) {
+      assert.equal((twice.match(new RegExp(`'${moduleName}'`, 'g')) ?? []).length, 2);
+    }
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/utils/mobile/ios_podfile_properties.mjs

@@ -0,0 +1,50 @@
+import { readFile, writeFile } from 'node:fs/promises';
+
+// `ios.buildReactNativeFromSource` and `ios.deploymentTarget` are owned by the Expo
+// config (`apps/ui/app.config.js`, expo-build-properties), so that EVERY prebuild path
+// produces them — `yarn prebuild`, `expo run:ios`, this command, and EAS. This step used
+// to write them as well, which made the hstack path look healthy while a plain
+// `expo prebuild` produced a project that linked prebuilt React Native core and silently
+// dropped the native patches under `apps/ui/patches/`. Verify here instead of competing.
+const APP_CONFIG_OWNED_PROPERTIES = ['ios.buildReactNativeFromSource', 'ios.deploymentTarget'];
+
+export async function patchIosPodfilePropertiesForMobileBuild({ uiDir, memoryAttribution = false }) {
+  const podPropsPath = `${uiDir}/ios/Podfile.properties.json`;
+  let raw;
+  try {
+    raw = await readFile(podPropsPath, 'utf-8');
+  } catch {
+    // Not generated (e.g. a non-iOS platform build).
+    return false;
+  }
+
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+
+  const missing = APP_CONFIG_OWNED_PROPERTIES.filter((key) => !json[key]);
+  if (json['ios.buildReactNativeFromSource'] && json['ios.buildReactNativeFromSource'] !== 'true') {
+    missing.push('ios.buildReactNativeFromSource');
+  }
+  if (missing.length > 0) {
+    throw new Error(
+      `${podPropsPath} is missing ${missing.join(', ')}.\n`
+      + 'These are owned by the expo-build-properties plugin in apps/ui/app.config.js and must be\n'
+      + 'declared there, not patched in afterwards. Without ios.buildReactNativeFromSource the build\n'
+      + 'links prebuilt React Native core and every native patch under apps/ui/patches/ is discarded\n'
+      + 'at compile time.',
+    );
+  }
+
+  // Build-mode override (not an app-level declaration): memory attribution runs need the
+  // dev-client network inspector off.
+  if (memoryAttribution && json.EX_DEV_CLIENT_NETWORK_INSPECTOR !== 'false') {
+    json.EX_DEV_CLIENT_NETWORK_INSPECTOR = 'false';
+    await writeFile(podPropsPath, `${JSON.stringify(json, null, 2)}\n`, 'utf-8');
+  }
+
+  return true;
+}

package/scripts/utils/mobile/ios_podfile_properties.test.mjs

@@ -0,0 +1,88 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { patchIosPodfilePropertiesForMobileBuild } from './ios_podfile_properties.mjs';
+
+async function createUiDir(podfileProperties) {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-pod-props-'));
+  const uiDir = join(tmp, 'apps', 'ui');
+  await mkdir(join(uiDir, 'ios'), { recursive: true });
+  if (podfileProperties) {
+    await writeFile(
+      join(uiDir, 'ios', 'Podfile.properties.json'),
+      JSON.stringify(podfileProperties, null, 2),
+      'utf8',
+    );
+  }
+  return { tmp, uiDir, podPropsPath: join(uiDir, 'ios', 'Podfile.properties.json') };
+}
+
+test('patchIosPodfilePropertiesForMobileBuild verifies the app-config-owned properties instead of rewriting them', async () => {
+  // app.config.js is the single owner of these two properties; this step used to
+  // write them too, which meant a plain `expo prebuild` silently produced a project
+  // without them and nothing noticed (2026-07 dead-patch incident).
+  const { tmp, uiDir, podPropsPath } = await createUiDir({
+    EX_DEV_CLIENT_NETWORK_INSPECTOR: 'true',
+    'ios.deploymentTarget': '16.4',
+    'ios.buildReactNativeFromSource': 'true',
+  });
+  try {
+    const result = await patchIosPodfilePropertiesForMobileBuild({ uiDir, memoryAttribution: false });
+
+    assert.equal(result, true);
+    const next = JSON.parse(await readFile(podPropsPath, 'utf8'));
+    // Not forced back to this script's old hard-coded value.
+    assert.equal(next['ios.deploymentTarget'], '16.4');
+    assert.equal(next['ios.buildReactNativeFromSource'], 'true');
+    assert.equal(next.EX_DEV_CLIENT_NETWORK_INSPECTOR, 'true');
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('patchIosPodfilePropertiesForMobileBuild disables dev-client network inspector for memory attribution builds', async () => {
+  const { tmp, uiDir, podPropsPath } = await createUiDir({
+    EX_DEV_CLIENT_NETWORK_INSPECTOR: 'true',
+    'ios.deploymentTarget': '16.0',
+    'ios.buildReactNativeFromSource': 'true',
+  });
+  try {
+    await patchIosPodfilePropertiesForMobileBuild({ uiDir, memoryAttribution: true });
+
+    const next = JSON.parse(await readFile(podPropsPath, 'utf8'));
+    assert.equal(next.EX_DEV_CLIENT_NETWORK_INSPECTOR, 'false');
+    assert.equal(next['ios.buildReactNativeFromSource'], 'true');
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('patchIosPodfilePropertiesForMobileBuild fails loudly when the generated project lacks the source build', async () => {
+  // Silently repairing this is what hid the regression: the hstack path looked fine
+  // while every other prebuild path produced a project with dead native patches.
+  const { tmp, uiDir } = await createUiDir({ EX_DEV_CLIENT_NETWORK_INSPECTOR: 'true' });
+  try {
+    await assert.rejects(
+      () => patchIosPodfilePropertiesForMobileBuild({ uiDir, memoryAttribution: false }),
+      (error) => {
+        assert.match(error.message, /buildReactNativeFromSource/);
+        assert.match(error.message, /app\.config\.js/);
+        return true;
+      },
+    );
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('patchIosPodfilePropertiesForMobileBuild tolerates a missing properties file', async () => {
+  const { tmp, uiDir } = await createUiDir(null);
+  try {
+    assert.equal(await patchIosPodfilePropertiesForMobileBuild({ uiDir, memoryAttribution: false }), false);
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/utils/mobile/ios_profiling_runtime.mjs

@@ -0,0 +1,171 @@
+import { join } from 'node:path';
+
+import { run as defaultRun, runCapture as defaultRunCapture } from '../proc/proc.mjs';
+
+const DEFAULT_WORKSPACE = 'ios/Happierdev.xcworkspace';
+const DEFAULT_SCHEME = 'Happierdev';
+const DEFAULT_CONFIGURATION = 'Release';
+
+export function parseXcodeBuildSettings(stdout) {
+  const settings = {};
+  for (const line of String(stdout ?? '').split(/\r?\n/)) {
+    const match = line.match(/^\s*([A-Za-z0-9_]+)\s*=\s*(.*?)\s*$/);
+    if (!match) continue;
+    settings[match[1]] = match[2];
+  }
+  return settings;
+}
+
+function parseSimctlDevices(stdout) {
+  const parsed = JSON.parse(String(stdout ?? '{}'));
+  const devicesByRuntime = parsed && typeof parsed === 'object' && parsed.devices && typeof parsed.devices === 'object' ? parsed.devices : {};
+  const devices = [];
+  for (const [runtime, entries] of Object.entries(devicesByRuntime)) {
+    if (!Array.isArray(entries)) continue;
+    for (const entry of entries) {
+      if (!entry || typeof entry !== 'object') continue;
+      if (entry.isAvailable === false) continue;
+      const udid = String(entry.udid ?? '').trim();
+      const name = String(entry.name ?? '').trim();
+      if (!udid || !name) continue;
+      devices.push({
+        udid,
+        name,
+        runtime,
+        state: String(entry.state ?? '').trim(),
+      });
+    }
+  }
+  return devices;
+}
+
+function formatSimulatorList(devices) {
+  return devices.map((device) => `${device.name} (${device.udid}, ${device.state || 'unknown'}, ${device.runtime})`).join('\n');
+}
+
+export async function resolveIosSimulatorDevice({
+  device = '',
+  runCapture = defaultRunCapture,
+  cwd = process.cwd(),
+  env = process.env,
+} = {}) {
+  const raw = await runCapture('xcrun', ['simctl', 'list', 'devices', '--json'], { cwd, env });
+  const devices = parseSimctlDevices(raw);
+  const selector = String(device ?? '').trim();
+
+  if (!selector) {
+    const booted = devices.filter((entry) => entry.state === 'Booted');
+    if (booted.length === 1) return booted[0];
+    if (booted.length === 0) {
+      throw new Error('No booted iOS simulator found for --profiling-runtime. Pass --device=<simulator-udid> after booting one.');
+    }
+    throw new Error(
+      `Multiple booted iOS simulators found for --profiling-runtime. Pass --device=<simulator-udid>.\n${formatSimulatorList(booted)}`,
+    );
+  }
+
+  const udidMatch = devices.find((entry) => entry.udid === selector);
+  if (udidMatch) return udidMatch;
+
+  const nameMatches = devices.filter((entry) => entry.name === selector);
+  if (nameMatches.length === 1) return nameMatches[0];
+  const bootedNameMatches = nameMatches.filter((entry) => entry.state === 'Booted');
+  if (bootedNameMatches.length === 1) return bootedNameMatches[0];
+  if (nameMatches.length > 1) {
+    throw new Error(`Multiple iOS simulators matched "${selector}". Pass --device=<simulator-udid>.\n${formatSimulatorList(nameMatches)}`);
+  }
+
+  throw new Error(`No iOS simulator matched "${selector}". Available simulators:\n${formatSimulatorList(devices)}`);
+}
+
+function xcodeBuildBaseArgs({ workspace, scheme, configuration, udid }) {
+  return [
+    '-workspace',
+    workspace,
+    '-scheme',
+    scheme,
+    '-configuration',
+    configuration,
+    '-destination',
+    `id=${udid}`,
+    'ENABLE_DEBUG_DYLIB=NO',
+    'ONLY_ACTIVE_ARCH=YES',
+    'SENTRY_DISABLE_AUTO_UPLOAD=true',
+  ];
+}
+
+function requireBuildSetting(settings, key) {
+  const value = String(settings[key] ?? '').trim();
+  if (!value) {
+    throw new Error(`xcodebuild -showBuildSettings did not report ${key}.`);
+  }
+  return value;
+}
+
+function buildMemoryAttributionLaunchEnv(env) {
+  return {
+    ...env,
+    SIMCTL_CHILD_MallocStackLogging: '1',
+    SIMCTL_CHILD_MallocStackLoggingNoCompact: '1',
+  };
+}
+
+export async function runIosProfilingRuntime({
+  uiDir,
+  device = '',
+  configuration = DEFAULT_CONFIGURATION,
+  workspace = DEFAULT_WORKSPACE,
+  scheme = DEFAULT_SCHEME,
+  memoryAttribution = false,
+  run = defaultRun,
+  runCapture = defaultRunCapture,
+  env = process.env,
+} = {}) {
+  const projectDir = String(uiDir ?? '').trim();
+  if (!projectDir) {
+    throw new Error('runIosProfilingRuntime requires uiDir.');
+  }
+
+  const simulator = await resolveIosSimulatorDevice({ device, runCapture, cwd: projectDir, env });
+  const normalizedConfiguration = String(configuration ?? '').trim() || DEFAULT_CONFIGURATION;
+  const baseArgs = xcodeBuildBaseArgs({
+    workspace,
+    scheme,
+    configuration: normalizedConfiguration,
+    udid: simulator.udid,
+  });
+
+  const settingsOut = await runCapture('xcodebuild', ['-showBuildSettings', ...baseArgs], { cwd: projectDir, env });
+  const settings = parseXcodeBuildSettings(settingsOut);
+  const debugDylib = requireBuildSetting(settings, 'ENABLE_DEBUG_DYLIB');
+  if (debugDylib !== 'NO') {
+    throw new Error(`Expected ENABLE_DEBUG_DYLIB=NO for profiling runtime, got ${debugDylib}.`);
+  }
+
+  const targetBuildDir = requireBuildSetting(settings, 'TARGET_BUILD_DIR');
+  const productName = requireBuildSetting(settings, 'FULL_PRODUCT_NAME');
+  const bundleId = requireBuildSetting(settings, 'PRODUCT_BUNDLE_IDENTIFIER');
+  const appPath = join(targetBuildDir, productName);
+
+  await run('xcodebuild', [...baseArgs, 'build'], { cwd: projectDir, env });
+  await run('xcrun', ['simctl', 'install', simulator.udid, appPath], { cwd: projectDir, env });
+  const launchEnv = memoryAttribution ? buildMemoryAttributionLaunchEnv(env) : env;
+  const launchArgs = [
+    'simctl',
+    'launch',
+    '--terminate-running-process',
+    ...(memoryAttribution ? ['--checked-allocations'] : []),
+    simulator.udid,
+    bundleId,
+  ];
+  await run('xcrun', launchArgs, { cwd: projectDir, env: launchEnv });
+
+  return {
+    appPath,
+    bundleId,
+    configuration: normalizedConfiguration,
+    debugDylib,
+    device: simulator,
+    memoryAttribution: memoryAttribution === true,
+  };
+}

package/scripts/utils/mobile/ios_profiling_runtime.test.mjs

@@ -0,0 +1,145 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  parseXcodeBuildSettings,
+  resolveIosSimulatorDevice,
+  runIosProfilingRuntime,
+} from './ios_profiling_runtime.mjs';
+
+test('parseXcodeBuildSettings reads indented xcodebuild key/value rows', () => {
+  const settings = parseXcodeBuildSettings(`
+      ENABLE_DEBUG_DYLIB = NO
+      TARGET_BUILD_DIR = /tmp/Build/Products/Release-iphonesimulator
+      FULL_PRODUCT_NAME = Happier-Local.app
+      PRODUCT_BUNDLE_IDENTIFIER = dev.happier.stack.test
+  `);
+
+  assert.equal(settings.ENABLE_DEBUG_DYLIB, 'NO');
+  assert.equal(settings.TARGET_BUILD_DIR, '/tmp/Build/Products/Release-iphonesimulator');
+  assert.equal(settings.FULL_PRODUCT_NAME, 'Happier-Local.app');
+  assert.equal(settings.PRODUCT_BUNDLE_IDENTIFIER, 'dev.happier.stack.test');
+});
+
+test('resolveIosSimulatorDevice resolves an explicit simulator UDID from simctl JSON', async () => {
+  const device = await resolveIosSimulatorDevice({
+    device: 'SIM-2',
+    runCapture: async () =>
+      JSON.stringify({
+        devices: {
+          'iOS 26.4': [
+            { udid: 'SIM-1', name: 'iPhone 17', state: 'Shutdown', isAvailable: true },
+            { udid: 'SIM-2', name: 'Happier Perf', state: 'Booted', isAvailable: true },
+          ],
+        },
+      }),
+  });
+
+  assert.deepEqual(device, { udid: 'SIM-2', name: 'Happier Perf', runtime: 'iOS 26.4', state: 'Booted' });
+});
+
+test('runIosProfilingRuntime builds with debug dylib disabled then installs and launches the same bundle', async () => {
+  const calls = [];
+  const result = await runIosProfilingRuntime({
+    uiDir: '/repo/apps/ui',
+    device: 'SIM-1',
+    configuration: 'Release',
+    runCapture: async (cmd, args) => {
+      calls.push(['capture', cmd, args]);
+      if (cmd === 'xcrun') {
+        return JSON.stringify({
+          devices: {
+            'iOS 26.4': [{ udid: 'SIM-1', name: 'Happier Perf', state: 'Booted', isAvailable: true }],
+          },
+        });
+      }
+      if (cmd === 'xcodebuild') {
+        assert.ok(args.includes('ENABLE_DEBUG_DYLIB=NO'), `expected show settings to disable debug dylib: ${args.join(' ')}`);
+        assert.ok(args.includes('ONLY_ACTIVE_ARCH=YES'), `expected show settings to use active simulator arch: ${args.join(' ')}`);
+        assert.ok(args.includes('SENTRY_DISABLE_AUTO_UPLOAD=true'), `expected show settings to disable Sentry uploads: ${args.join(' ')}`);
+        return `
+          ENABLE_DEBUG_DYLIB = NO
+          TARGET_BUILD_DIR = /tmp/Derived/Release-iphonesimulator
+          FULL_PRODUCT_NAME = Happier-Local.app
+          PRODUCT_BUNDLE_IDENTIFIER = dev.happier.stack.prof
+        `;
+      }
+      throw new Error(`unexpected capture command ${cmd}`);
+    },
+    run: async (cmd, args) => {
+      calls.push(['run', cmd, args]);
+    },
+  });
+
+  const buildCall = calls.find((entry) => entry[0] === 'run' && entry[1] === 'xcodebuild');
+  assert.ok(buildCall, `expected xcodebuild run call: ${JSON.stringify(calls)}`);
+  assert.ok(buildCall[2].includes('ENABLE_DEBUG_DYLIB=NO'), `expected build to disable debug dylib: ${buildCall[2].join(' ')}`);
+  assert.ok(buildCall[2].includes('ONLY_ACTIVE_ARCH=YES'), `expected build to use active simulator arch: ${buildCall[2].join(' ')}`);
+  assert.ok(buildCall[2].includes('SENTRY_DISABLE_AUTO_UPLOAD=true'), `expected build to disable Sentry uploads: ${buildCall[2].join(' ')}`);
+  assert.deepEqual(calls.at(-2), ['run', 'xcrun', ['simctl', 'install', 'SIM-1', '/tmp/Derived/Release-iphonesimulator/Happier-Local.app']]);
+  assert.deepEqual(calls.at(-1), [
+    'run',
+    'xcrun',
+    ['simctl', 'launch', '--terminate-running-process', 'SIM-1', 'dev.happier.stack.prof'],
+  ]);
+  assert.deepEqual(result, {
+    appPath: '/tmp/Derived/Release-iphonesimulator/Happier-Local.app',
+    bundleId: 'dev.happier.stack.prof',
+    configuration: 'Release',
+    debugDylib: 'NO',
+    device: { udid: 'SIM-1', name: 'Happier Perf', runtime: 'iOS 26.4', state: 'Booted' },
+    memoryAttribution: false,
+  });
+});
+
+test('runIosProfilingRuntime applies malloc launch settings only for memory attribution mode', async () => {
+  const calls = [];
+  await runIosProfilingRuntime({
+    uiDir: '/repo/apps/ui',
+    device: 'SIM-1',
+    configuration: 'Release',
+    memoryAttribution: true,
+    env: { BASE: '1' },
+    runCapture: async (cmd, args, options) => {
+      calls.push(['capture', cmd, args, options?.env]);
+      if (cmd === 'xcrun') {
+        return JSON.stringify({
+          devices: {
+            'iOS 26.4': [{ udid: 'SIM-1', name: 'Happier Perf', state: 'Booted', isAvailable: true }],
+          },
+        });
+      }
+      if (cmd === 'xcodebuild') {
+        assert.equal(options?.env?.SIMCTL_CHILD_MallocStackLogging, undefined);
+        return `
+          ENABLE_DEBUG_DYLIB = NO
+          TARGET_BUILD_DIR = /tmp/Derived/Release-iphonesimulator
+          FULL_PRODUCT_NAME = Happier-Local.app
+          PRODUCT_BUNDLE_IDENTIFIER = dev.happier.stack.prof
+        `;
+      }
+      throw new Error(`unexpected capture command ${cmd}`);
+    },
+    run: async (cmd, args, options) => {
+      calls.push(['run', cmd, args, options?.env]);
+    },
+  });
+
+  const buildCall = calls.find((entry) => entry[0] === 'run' && entry[1] === 'xcodebuild');
+  const installCall = calls.find((entry) => entry[0] === 'run' && entry[1] === 'xcrun' && entry[2][1] === 'install');
+  const launchCall = calls.find((entry) => entry[0] === 'run' && entry[1] === 'xcrun' && entry[2][1] === 'launch');
+
+  assert.equal(buildCall?.[3]?.SIMCTL_CHILD_MallocStackLogging, undefined);
+  assert.equal(installCall?.[3]?.SIMCTL_CHILD_MallocStackLogging, undefined);
+  assert.equal(launchCall?.[3]?.SIMCTL_CHILD_MallocStackLogging, '1');
+  assert.equal(launchCall?.[3]?.SIMCTL_CHILD_MallocStackLoggingNoCompact, '1');
+  assert.equal(launchCall?.[3]?.BASE, '1');
+  assert.deepEqual(launchCall?.[2], [
+    'simctl',
+    'launch',
+    '--terminate-running-process',
+    '--checked-allocations',
+    'SIM-1',
+    'dev.happier.stack.prof',
+  ]);
+});

package/scripts/utils/mobile/ios_xcodeproj_patch.mjs

@@ -21,7 +21,12 @@ async function listIosAppXcodeprojNames({ iosDir }) {
   }
 
   const names = entries
-    .filter((e) => e.isDirectory() && e.name.endsWith('.xcodeproj') && e.name.startsWith('Happy'))
+    .filter(
+      (e) =>
+        e.isDirectory() &&
+        e.name.endsWith('.xcodeproj') &&
+        (e.name.startsWith('Happy') || e.name.startsWith('Happier'))
+    )
     .map((e) => e.name);
 
   // Prefer the common names first to keep behavior stable if multiple projects exist.

package/scripts/utils/mobile/ios_xcodeproj_patch.test.mjs

@@ -93,6 +93,47 @@ test('patchIosXcodeProjectsForSigningAndIdentity patches both Happydev + Happy p
   assert.match(pbxprojDev, /PRODUCT_BUNDLE_IDENTIFIER = dev\.happier\.stack\.stack\.user\.pre-pr272;/);
 });
 
+test('patchIosXcodeProjectsForSigningAndIdentity patches generated Happier app projects', async (t) => {
+  const uiDir = await withTempUiDir(t);
+  const iosDir = join(uiDir, 'ios');
+  await mkdir(join(iosDir, 'Happierinternaldev.xcodeproj'), { recursive: true });
+  await mkdir(join(iosDir, 'Happierinternaldev'), { recursive: true });
+
+  const pbxprojPath = join(iosDir, 'Happierinternaldev.xcodeproj', 'project.pbxproj');
+  await writeFile(
+    pbxprojPath,
+    [
+      'DevelopmentTeam = L86V3EF623;',
+      'ProvisioningStyle = Automatic;',
+      'CODE_SIGN_IDENTITY = "Apple Development";',
+      'DEVELOPMENT_TEAM = L86V3EF623;',
+      'PRODUCT_BUNDLE_IDENTIFIER = "dev.happier.app.dev.internal";',
+      'PRODUCT_NAME = Happierinternaldev;',
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  const infoPlistPath = join(iosDir, 'Happierinternaldev', 'Info.plist');
+  await writeFile(infoPlistPath, '<key>CFBundleDisplayName</key><string>Happier</string>\n', 'utf-8');
+
+  await patchIosXcodeProjectsForSigningAndIdentity({
+    uiDir,
+    iosBundleId: 'dev.happier.app.dev.remotedev-devclient',
+    iosAppName: 'Happier (remote-dev)',
+  });
+
+  const pbxproj = await readFile(pbxprojPath, 'utf-8');
+  assert.match(pbxproj, /PRODUCT_BUNDLE_IDENTIFIER = dev\.happier\.app\.dev\.remotedev-devclient;/);
+  assert.doesNotMatch(pbxproj, /DevelopmentTeam\s*=/);
+  assert.doesNotMatch(pbxproj, /DEVELOPMENT_TEAM\s*=/);
+  assert.doesNotMatch(pbxproj, /CODE_SIGN_IDENTITY\s*=/);
+  assert.match(pbxproj, /PRODUCT_NAME = Happier-remote-dev;/);
+
+  const plist = await readFile(infoPlistPath, 'utf-8');
+  assert.match(plist, /<key>CFBundleDisplayName<\/key><string>Happier \(remote-dev\)<\/string>/);
+});
+
 test('patchIosXcodeProjectsForSigningAndIdentity tolerates missing Info.plist and leaves pre-patched pbxproj unchanged', async (t) => {
   const uiDir = await withTempUiDir(t);
   const iosDir = join(uiDir, 'ios');

package/scripts/utils/mobile/profiling_runtime_mode.mjs

@@ -0,0 +1,35 @@
+export const IOS_PROFILING_RUNTIME_MODE = {
+  off: 'off',
+  standard: 'standard',
+  memory: 'memory',
+};
+
+function normalizeProfilingRuntimeMode(value) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!normalized || normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on') {
+    return IOS_PROFILING_RUNTIME_MODE.standard;
+  }
+  if (normalized === IOS_PROFILING_RUNTIME_MODE.standard || normalized === 'cpu') {
+    return IOS_PROFILING_RUNTIME_MODE.standard;
+  }
+  if (normalized === IOS_PROFILING_RUNTIME_MODE.memory || normalized === 'memory-attribution' || normalized === 'allocations') {
+    return IOS_PROFILING_RUNTIME_MODE.memory;
+  }
+  throw new Error(`Unsupported iOS profiling runtime mode "${value}". Use --profiling-runtime or --profiling-runtime=memory.`);
+}
+
+export function resolveIosProfilingRuntimeMode({ flags, kv } = {}) {
+  if (flags?.has('--memory-attribution')) return IOS_PROFILING_RUNTIME_MODE.memory;
+  if (kv?.has('--profiling-runtime')) return normalizeProfilingRuntimeMode(kv.get('--profiling-runtime'));
+  if (kv?.has('--profiling')) return normalizeProfilingRuntimeMode(kv.get('--profiling'));
+  if (flags?.has('--profiling-runtime') || flags?.has('--profiling')) return IOS_PROFILING_RUNTIME_MODE.standard;
+  return IOS_PROFILING_RUNTIME_MODE.off;
+}
+
+export function isIosProfilingRuntimeEnabled(mode) {
+  return mode === IOS_PROFILING_RUNTIME_MODE.standard || mode === IOS_PROFILING_RUNTIME_MODE.memory;
+}
+
+export function isIosMemoryAttributionRuntime(mode) {
+  return mode === IOS_PROFILING_RUNTIME_MODE.memory;
+}

package/scripts/utils/mobile/profiling_runtime_mode.test.mjs

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { parseArgs } from '../cli/args.mjs';
+import { resolveIosProfilingRuntimeMode } from './profiling_runtime_mode.mjs';
+
+function modeFor(argv) {
+  return resolveIosProfilingRuntimeMode(parseArgs(argv));
+}
+
+test('resolveIosProfilingRuntimeMode keeps profiling runtime off by default', () => {
+  assert.equal(modeFor([]), 'off');
+});
+
+test('resolveIosProfilingRuntimeMode supports the existing standard profiling flags', () => {
+  assert.equal(modeFor(['--profiling-runtime']), 'standard');
+  assert.equal(modeFor(['--profiling']), 'standard');
+});
+
+test('resolveIosProfilingRuntimeMode supports explicit memory-attribution mode', () => {
+  assert.equal(modeFor(['--memory-attribution']), 'memory');
+  assert.equal(modeFor(['--profiling-runtime=memory']), 'memory');
+  assert.equal(modeFor(['--profiling=memory']), 'memory');
+});
+
+test('resolveIosProfilingRuntimeMode rejects unknown profiling runtime modes', () => {
+  assert.throws(() => modeFor(['--profiling-runtime=turbo']), /Unsupported iOS profiling runtime mode/);
+});