react-native-debug-toolkit 3.3.1 → 3.3.3

package/scripts/embed-expo.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function isExpoProject(projectRoot) {
+  // app.json with expo field
+  const appJsonPath = path.join(projectRoot, 'app.json');
+  if (fs.existsSync(appJsonPath)) {
+    try {
+      const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
+      if (appJson.expo) return true;
+    } catch (_) {}
+  }
+
+  // app.config.js or app.config.ts
+  if (
+    fs.existsSync(path.join(projectRoot, 'app.config.js')) ||
+    fs.existsSync(path.join(projectRoot, 'app.config.ts'))
+  ) {
+    return true;
+  }
+
+  // expo in package.json dependencies
+  const pkgPath = path.join(projectRoot, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.expo) return true;
+    } catch (_) {}
+  }
+
+  return false;
+}
+
+function isExpoGo(projectRoot) {
+  // Expo Go doesn't support embedded bundles
+  // If no ios/ or android/ dirs, likely Expo Go
+  const hasNativeDirs =
+    fs.existsSync(path.join(projectRoot, 'ios')) ||
+    fs.existsSync(path.join(projectRoot, 'android'));
+
+  if (!hasNativeDirs) {
+    return true;
+  }
+  return false;
+}
+
+function isPrebuilt(projectRoot) {
+  // Dev client / bare workflow after prebuild
+  return (
+    fs.existsSync(path.join(projectRoot, 'ios')) &&
+    fs.existsSync(path.join(projectRoot, 'android'))
+  );
+}
+
+function getExpoEntryPoint(projectRoot) {
+  const appJsonPath = path.join(projectRoot, 'app.json');
+  if (fs.existsSync(appJsonPath)) {
+    try {
+      const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf-8'));
+      if (appJson.expo && appJson.expo.entryPoint) {
+        return appJson.expo.entryPoint;
+      }
+    } catch (_) {}
+  }
+
+  // Expo default with .expo virtual entry
+  const virtualEntry = path.join(
+    projectRoot,
+    '.expo',
+    '.virtual-metro-entry'
+  );
+  if (fs.existsSync(virtualEntry)) {
+    return '.expo/.virtual-metro-entry';
+  }
+
+  return null;
+}
+
+function checkExpo(projectRoot, options) {
+  const expo = isExpoProject(projectRoot);
+  if (!expo) {
+    return { expo: false, skip: false };
+  }
+
+  if (isExpoGo(projectRoot)) {
+    return {
+      expo: true,
+      skip: true,
+      reason:
+        'Expo Go does not support embedded bundles. Use expo-dev-client or run npx expo prebuild first.',
+    };
+  }
+
+  if (!isPrebuilt(projectRoot)) {
+    return {
+      expo: true,
+      skip: true,
+      reason:
+        'Native directories not found. Run npx expo prebuild first, then retry.',
+    };
+  }
+
+  return { expo: true, skip: false, entryPoint: getExpoEntryPoint(projectRoot) };
+}
+
+module.exports = { isExpoProject, checkExpo, getExpoEntryPoint };

package/scripts/embed-ios.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const pbxproj = require('pbxproj');
+
+const BUNDLE_PHASE_NAME = 'Bundle React Native code and images';
+const FORCE_BUNDLING_LINE = 'export FORCE_BUNDLING=1';
+const CONFIG_FILE = '.debug-toolkit-embed.json';
+
+function findXcodeproj(projectRoot) {
+  const iosDir = path.join(projectRoot, 'ios');
+  if (!fs.existsSync(iosDir)) {
+    return null;
+  }
+  const entries = fs.readdirSync(iosDir).filter(
+    (e) => e.endsWith('.xcodeproj') && e !== 'Pods.xcodeproj'
+  );
+  if (entries.length === 0) {
+    return null;
+  }
+  return entries;
+}
+
+function findPbxproj(xcodeprojPath) {
+  const pbxPath = path.join(xcodeprojPath, 'project.pbxproj');
+  if (!fs.existsSync(pbxPath)) {
+    throw new Error(`project.pbxproj not found at ${pbxPath}`);
+  }
+  return pbxPath;
+}
+
+function getBundleScriptPhase(pbxFile) {
+  const proj = new pbxproj(pbxFile).parseSync();
+  const sections = proj.hash.project.objects.PBXShellScriptBuildPhase;
+  if (!sections) {
+    return null;
+  }
+  for (const [key, section] of Object.entries(sections)) {
+    if (
+      section.name === BUNDLE_PHASE_NAME ||
+      section.name === `"${BUNDLE_PHASE_NAME}"`
+    ) {
+      return { id: key, section, proj, pbxFile };
+    }
+  }
+  return null;
+}
+
+function injectForceBundling(projectRoot, xcodeprojRelPath, entryFile, options) {
+  const xcodeprojPath = path.join(projectRoot, xcodeprojRelPath);
+  const pbxFile = findPbxproj(xcodeprojPath);
+  const result = getBundleScriptPhase(pbxFile);
+  if (!result) {
+    throw new Error(
+      `"${BUNDLE_PHASE_NAME}" script phase not found in ${xcodeprojRelPath}`
+    );
+  }
+
+  const scriptBody = result.section.shellScript;
+  // Already injected — idempotent
+  if (scriptBody && scriptBody.includes(FORCE_BUNDLING_LINE)) {
+    console.log(`  ${xcodeprojRelPath}: FORCE_BUNDLING already set. Skipping.`);
+    return { xcodeproj: xcodeprojRelPath, scriptPhaseId: result.id, entryFile };
+  }
+
+  // Decode shellScript (it's usually a quoted string)
+  let decoded = scriptBody;
+  try {
+    decoded = JSON.parse(scriptBody);
+  } catch (_) {
+    // Not JSON-encoded, use as-is
+  }
+
+  const newScript = FORCE_BUNDLING_LINE + '\n' + decoded;
+  result.section.shellScript = JSON.stringify(newScript);
+
+  fs.writeFileSync(pbxFile, result.proj.writeSync());
+  console.log(`  ${xcodeprojRelPath}: Injected FORCE_BUNDLING=1`);
+
+  return { xcodeproj: xcodeprojRelPath, scriptPhaseId: result.id, entryFile };
+}
+
+function undoForceBundling(projectRoot, config) {
+  if (!config.ios) {
+    console.log('  No iOS configuration found. Skipping.');
+    return;
+  }
+
+  const xcodeprojPath = path.join(projectRoot, config.ios.xcodeproj);
+  const pbxFile = findPbxproj(xcodeprojPath);
+  const result = getBundleScriptPhase(pbxFile);
+  if (!result) {
+    console.log('  Bundle script phase not found. Skipping.');
+    return;
+  }
+
+  const scriptBody = result.section.shellScript;
+  let decoded = scriptBody;
+  try {
+    decoded = JSON.parse(scriptBody);
+  } catch (_) {}
+
+  if (!decoded.includes(FORCE_BUNDLING_LINE)) {
+    console.log('  FORCE_BUNDLING not found in script. Skipping.');
+    return;
+  }
+
+  const newScript = decoded
+    .split('\n')
+    .filter((line) => line !== FORCE_BUNDLING_LINE)
+    .join('\n');
+  result.section.shellScript = JSON.stringify(newScript);
+
+  fs.writeFileSync(pbxFile, result.proj.writeSync());
+  console.log('  Removed FORCE_BUNDLING=1 from script phase.');
+}
+
+module.exports = { findXcodeproj, injectForceBundling, undoForceBundling };

package/scripts/embed.js

@@ -0,0 +1,224 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const ios = require('./embed-ios');
+const android = require('./embed-android');
+const expo = require('./embed-expo');
+
+const CONFIG_FILE = '.debug-toolkit-embed.json';
+
+function readConfig(projectRoot) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+}
+
+function writeConfig(projectRoot, config) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  const payload = { version: 1, ...config };
+  fs.writeFileSync(configPath, JSON.stringify(payload, null, 2) + '\n');
+}
+
+function deleteConfig(projectRoot) {
+  const configPath = path.join(projectRoot, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+}
+
+function detectEntryFile(projectRoot) {
+  const candidates = [
+    'index.js',
+    'index.ts',
+    'index.tsx',
+  ];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(projectRoot, candidate))) {
+      return candidate;
+    }
+  }
+
+  // Expo virtual entry
+  if (fs.existsSync(path.join(projectRoot, '.expo', '.virtual-metro-entry'))) {
+    return '.expo/.virtual-metro-entry';
+  }
+
+  return 'index.js';
+}
+
+function prompt(question, options) {
+  if (options && options.yes) {
+    return Promise.resolve(true);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question + ' [Y/n] ', (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() !== 'n');
+    });
+  });
+}
+
+async function embed(projectRoot, argv) {
+  const args = argv || [];
+  const yes = args.includes('--yes');
+  const platformIdx = args.indexOf('--platform');
+  const platform =
+    platformIdx >= 0 ? args[platformIdx + 1] : null; // 'ios' | 'android'
+
+  console.log('debug-toolkit embed');
+  console.log('---');
+
+  // Check Expo
+  const expoResult = expo.checkExpo(projectRoot, { yes });
+  if (expoResult.expo) {
+    console.log('Detected Expo project.');
+    if (expoResult.skip) {
+      console.log(`  Skipping: ${expoResult.reason}`);
+      if (platform === null || platform === 'ios') {
+        // nothing
+      }
+      return;
+    }
+    console.log('  Native directories found — proceeding.');
+  }
+
+  const existingConfig = readConfig(projectRoot);
+  const config = {};
+
+  // Entry file
+  const entryFile =
+    (expoResult.entryPoint) || detectEntryFile(projectRoot);
+  console.log(`Entry file: ${entryFile}`);
+
+  // iOS
+  if (platform === null || platform === 'ios') {
+    const xcodeprojEntries = ios.findXcodeproj(projectRoot);
+    if (xcodeprojEntries && xcodeprojEntries.length > 0) {
+      let chosen = xcodeprojEntries[0];
+      if (xcodeprojEntries.length > 1) {
+        if (yes) {
+          console.log(
+            `  Multiple Xcode projects found. Using: ${chosen}`
+          );
+        } else {
+          console.log('  Multiple Xcode projects found:');
+          xcodeprojEntries.forEach((e, i) =>
+            console.log(`    ${i + 1}. ${e}`)
+          );
+          const idx = await prompt(
+            `  Select project [1-${xcodeprojEntries.length}]`,
+            { yes }
+          );
+          // Default to first
+          chosen = xcodeprojEntries[0];
+        }
+      }
+
+      const xcodeprojRelPath = path.join('ios', chosen);
+      const shouldEmbed =
+        yes ||
+        (await prompt(
+          `  Inject FORCE_BUNDLING into ${xcodeprojRelPath}?`,
+          { yes }
+        ));
+
+      if (shouldEmbed !== false) {
+        config.ios = ios.injectForceBundling(
+          projectRoot,
+          xcodeprojRelPath,
+          entryFile,
+          { yes }
+        );
+      }
+    } else {
+      console.log('  No Xcode project found. Skipping iOS.');
+    }
+  }
+
+  // Android
+  if (platform === null || platform === 'android') {
+    const buildGradle = android.findBuildGradle(projectRoot);
+    if (buildGradle) {
+      const shouldEmbed =
+        yes ||
+        (await prompt(
+          `  Inject debug bundle task into ${buildGradle}?`,
+          { yes }
+        ));
+
+      if (shouldEmbed !== false) {
+        config.android = android.injectGradleApply(
+          projectRoot,
+          buildGradle,
+          entryFile,
+          { yes }
+        );
+      }
+    } else {
+      console.log('  No Android build.gradle found. Skipping Android.');
+    }
+  }
+
+  // Write config
+  if (Object.keys(config).length > 0) {
+    writeConfig(projectRoot, config);
+    console.log(`\nConfiguration saved to ${CONFIG_FILE}`);
+  }
+
+  console.log('\nDone. Debug builds will now embed a JS bundle.');
+  console.log('Use DevConnect to switch Metro hosts at runtime.');
+}
+
+async function undo(projectRoot, argv) {
+  const args = argv || [];
+  const yes = args.includes('--yes');
+
+  console.log('debug-toolkit embed --undo');
+  console.log('---');
+
+  const config = readConfig(projectRoot);
+  if (!config) {
+    console.log(`No ${CONFIG_FILE} found. Nothing to undo.`);
+    return;
+  }
+
+  const shouldUndo =
+    yes || (await prompt('Remove all debug-toolkit embed injections?', { yes }));
+
+  if (shouldUndo === false) {
+    console.log('Cancelled.');
+    return;
+  }
+
+  ios.undoForceBundling(projectRoot, config);
+  android.undoGradleApply(projectRoot, config);
+
+  deleteConfig(projectRoot);
+  console.log(`\nRemoved ${CONFIG_FILE}.`);
+  console.log('Done.');
+}
+
+function main(argv) {
+  const projectRoot = process.cwd();
+  const args = argv || [];
+
+  if (args.includes('--undo')) {
+    return undo(projectRoot, args);
+  }
+
+  return embed(projectRoot, args);
+}
+
+module.exports = { main, embed, undo };

package/src/features/devConnect/DevConnectTab.tsx

@@ -35,7 +35,12 @@ import {
   saveDaemonPort,
   saveMetroPort,
 } from './devConnectPreferences';
-import { applyMetroBundle, flushNativeDiagnostic, resetMetroBundle } from './nativeDevConnect';
+import {
+  applyMetroBundle,
+  getNativeDiagnostics,
+  resetMetroBundle,
+  type NativeDiagnostics,
+} from './nativeDevConnect';
 import type { DevConnectFeatureControls, DevConnectSettingsPatch, DevConnectState } from './types';
 
 const CONNECTION_TIMEOUT_MS = 2000;
@@ -72,6 +77,8 @@ export function DevConnectTab({ snapshot, feature }: DebugFeatureRenderProps<Dev
   const [message, setMessage] = useState<string | null>(null);
   const [sending, setSending] = useState(false);
   const [metroBusy, setMetroBusy] = useState(false);
+  const [diagData, setDiagData] = useState<NativeDiagnostics | null>(null);
+  const [diagOpen, setDiagOpen] = useState(false);
 
   const isSim = snapshot.isSimulator;
 
@@ -80,7 +87,20 @@ export function DevConnectTab({ snapshot, feature }: DebugFeatureRenderProps<Dev
   }, [feature]);
 
   useEffect(() => {
-    flushNativeDiagnostic('_devconnect_last_diagnostic', 'DevConnect');
+    getNativeDiagnostics().then((result) => {
+      if (result) {
+        setDiagData(result);
+        console.info(
+          `[DevConnect] debugBuild=${result.isDebugBuild} appDelegate=${result.appDelegateClass} persistedHost=${result.persistedMetroHost ?? 'none'}`,
+        );
+      }
+    }).catch(() => {});
+  }, []);
+
+  const refreshDiag = useCallback(() => {
+    getNativeDiagnostics().then((result) => {
+      if (result) setDiagData(result);
+    }).catch(() => {});
   }, []);
 
   useEffect(() => {
@@ -376,8 +396,11 @@ export function DevConnectTab({ snapshot, feature }: DebugFeatureRenderProps<Dev
     }
   }, [snapshot.nativeMetroAvailable]);
 
+  // Metro host switching only works in Debug builds. diagData is iOS-populated; when we know
+  // it's a Release build, disable the controls (Android reports null → stays enabled).
+  const metroReleaseBlocked = diagData ? !diagData.isDebugBuild : false;
   const canConnect = isSim || (Boolean(normalizeComputerHost(computerHost)) && Boolean(normalizePort(daemonPort)));
-  const canUseMetro = Boolean(metroTarget) && snapshot.nativeMetroAvailable && !metroBusy;
+  const canUseMetro = Boolean(metroTarget) && snapshot.nativeMetroAvailable && !metroBusy && !metroReleaseBlocked;
   const busy = sending || syncState === 'checking';
   const subnetPrefix = snapshot.subnetPrefix;
   const ipPlaceholder = subnetPrefix ? `${subnetPrefix}...` : '192.168.1.10';
@@ -484,9 +507,20 @@ export function DevConnectTab({ snapshot, feature }: DebugFeatureRenderProps<Dev
         {message ? <Text style={styles.message}>{message}</Text> : null}
 
         <View style={styles.section}>
-          <Text style={styles.sectionTitle}>Remote JS Bundle</Text>
+          <View style={styles.sectionTitleRow}>
+            <Text style={styles.sectionTitle}>Remote JS Bundle</Text>
+            {diagData ? (
+              <View style={styles.swizzleBadge}>
+                <View style={[styles.swizzleDot, diagData.isDebugBuild ? styles.dotGreen : styles.dotRed]} />
+                <Text style={styles.swizzleBadgeText}>
+                  {diagData.isDebugBuild ? 'debug build' : 'release: disabled'}
+                </Text>
+              </View>
+            ) : null}
+          </View>
           <Text style={styles.sectionDesc}>
-            Apply this Metro host to React Native dev settings and reload the app.
+            Starts from the embedded bundle. After you apply a computer IP, hot-reloads from that
+            Metro. Debug builds only — use Reset to go back to the embedded bundle.
           </Text>
 
           {!metroUrls ? (
@@ -530,7 +564,70 @@ export function DevConnectTab({ snapshot, feature }: DebugFeatureRenderProps<Dev
           {!snapshot.nativeMetroAvailable ? (
             <Text style={styles.hint}>Native DevConnect requires pod install / Gradle sync and app rebuild.</Text>
           ) : null}
+
+          {metroReleaseBlocked ? (
+            <Text style={styles.diagWarning}>
+              ⚠ This is a Release build. Metro host switching is disabled — RN loads the embedded
+              bundle and strips the packager machinery in Release. Run a Debug build to switch hosts.
+            </Text>
+          ) : null}
         </View>
+
+        {snapshot.nativeMetroAvailable && diagData ? (
+          <View style={styles.section}>
+            <TouchableOpacity
+              style={styles.diagHeader}
+              onPress={() => { setDiagOpen((v) => !v); refreshDiag(); }}
+              activeOpacity={0.7}
+            >
+              <Text style={styles.sectionTitle}>iOS Bundle Status</Text>
+              <Text style={styles.diagChevron}>{diagOpen ? '▲' : '▼'}</Text>
+            </TouchableOpacity>
+
+            {diagOpen ? (
+              <View style={styles.diagCard}>
+                <View style={styles.diagRow}>
+                  <Text style={styles.diagKey}>AppDelegate</Text>
+                  <Text style={styles.diagVal}>{diagData.appDelegateClass}</Text>
+                </View>
+                <View style={styles.diagRow}>
+                  <Text style={styles.diagKey}>packagerHost</Text>
+                  <Text style={styles.diagVal}>{diagData.persistedMetroHost ?? '—'}</Text>
+                </View>
+                <View style={styles.diagRow}>
+                  <Text style={styles.diagKey}>embedded</Text>
+                  <Text style={[styles.diagVal, diagData.hasEmbeddedBundle ? styles.diagGood : styles.diagWarn]}>
+                    {diagData.hasEmbeddedBundle ? 'main.jsbundle' : 'missing'}
+                  </Text>
+                </View>
+                <View style={styles.diagRow}>
+                  <Text style={styles.diagKey}>build</Text>
+                  <Text style={[styles.diagVal, diagData.isDebugBuild ? styles.diagGood : styles.diagWarn]}>
+                    {diagData.isDebugBuild ? 'Debug' : 'Release'}
+                  </Text>
+                </View>
+                <View style={styles.diagRow}>
+                  <Text style={styles.diagKey}>embedded-first</Text>
+                  <Text style={[styles.diagVal, diagData.embeddedFirstHookInstalled ? styles.diagGood : styles.diagWarn]}>
+                    {diagData.embeddedFirstHookInstalled ? 'active' : 'inactive'}
+                  </Text>
+                </View>
+                {!diagData.embeddedFirstHookInstalled ? (
+                  <Text style={styles.diagWarning}>
+                    ⚠ Embedded-first hook not active (bundleRoot=
+                    {diagData.bundleRootHookInstalled ? 'Y' : 'N'}). Rebuild after pod install.
+                    Without it, Debug may still try Metro on launch.
+                  </Text>
+                ) : diagData.hasEmbeddedBundle === false ? (
+                  <Text style={styles.diagWarning}>
+                    ⚠ main.jsbundle is missing from the app package. Build with an embedded bundle
+                    (e.g. export/bundle) or cold start cannot use offline JS.
+                  </Text>
+                ) : null}
+              </View>
+            ) : null}
+          </View>
+        ) : null}
       </ScrollView>
     </KeyboardAvoidingView>
   );
@@ -635,4 +732,30 @@ const styles = StyleSheet.create({
     paddingVertical: 7,
   },
   urlText: { flex: 1, fontSize: 13, fontFamily: 'Courier', color: Colors.text },
+  sectionTitleRow: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', marginBottom: 4 },
+  swizzleBadge: { flexDirection: 'row', alignItems: 'center', gap: 4, paddingHorizontal: 7, paddingVertical: 3, borderRadius: 10, backgroundColor: Colors.surface, borderWidth: 1, borderColor: Colors.border },
+  swizzleDot: { width: 6, height: 6, borderRadius: 3 },
+  dotGreen: { backgroundColor: '#34C759' },
+  dotRed: { backgroundColor: '#FF3B30' },
+  swizzleBadgeText: { fontSize: 11, color: Colors.textSecondary, fontFamily: 'Courier' },
+  diagHeader: { flexDirection: 'row', alignItems: 'center', justifyContent: 'space-between', marginBottom: 6 },
+  diagChevron: { fontSize: 12, color: Colors.textSecondary },
+  diagCard: {
+    backgroundColor: Colors.surface,
+    borderWidth: 1,
+    borderColor: Colors.border,
+    borderRadius: 10,
+    padding: 10,
+  },
+  diagRow: { flexDirection: 'row', justifyContent: 'space-between', paddingVertical: 4 },
+  diagKey: { fontSize: 12, color: Colors.textSecondary, fontFamily: 'Courier' },
+  diagVal: { fontSize: 12, color: Colors.text, fontFamily: 'Courier', fontWeight: '600' },
+  diagGood: { color: '#34C759' },
+  diagWarn: { color: '#FF9500' },
+  diagWarning: {
+    marginTop: 10,
+    fontSize: 11,
+    color: '#FF9500',
+    lineHeight: 16,
+  },
 });

package/src/features/devConnect/nativeDevConnect.ts

@@ -2,6 +2,18 @@ import { NativeModules } from 'react-native';
 
 import { buildMetroTarget } from './devConnectUtils';
 
+export interface NativeDiagnostics {
+  persistedMetroHost: string | null;
+  appDelegateClass: string;
+  // Metro host switching only works in Debug builds (RN strips the packager machinery in
+  // Release). False means the Remote JS Bundle controls should be disabled.
+  isDebugBuild: boolean;
+  hasEmbeddedBundle?: boolean;
+  embeddedFirstHookInstalled?: boolean;
+  packagerHookInstalled?: boolean;
+  bundleRootHookInstalled?: boolean;
+}
+
 interface DebugToolkitDevConnectNativeModule {
   applyMetroHost: (hostPort: string) => Promise<{ hostPort?: string } | void>;
   resetMetroHost: () => Promise<void>;
@@ -9,6 +21,7 @@ interface DebugToolkitDevConnectNativeModule {
   getLocalIp?: () => Promise<string | null>;
   isDebugBuild?: () => Promise<boolean>;
   getPreference?: (key: string) => Promise<string | null>;
+  getDiagnostics?: () => Promise<NativeDiagnostics>;
 }
 
 type MetroBundleFailureReason =
@@ -154,17 +167,14 @@ export async function nativeIsDebugBuild(): Promise<boolean | null> {
   }
 }
 
-export async function flushNativeDiagnostic(key: string, label: string): Promise<void> {
+export async function getNativeDiagnostics(): Promise<NativeDiagnostics | null> {
   const nativeModule = getNativeModule();
-  if (!nativeModule?.getPreference) {
-    return;
+  if (!nativeModule?.getDiagnostics) {
+    return null;
   }
   try {
-    const raw = await nativeModule.getPreference(key);
-    if (raw && typeof raw === 'string') {
-      console.info(`[${label}] Last native diagnostic:`, raw);
-    }
+    return await nativeModule.getDiagnostics();
   } catch {
-    // Silent - diagnostic is best-effort
+    return null;
   }
 }