@crumbsdk/react-native 0.0.1-rc.4 → 0.0.1-rc.5

package/tools/crumb.gradle

@@ -0,0 +1,63 @@
+// Apply in the application module after the React Native plugin.
+import groovy.json.JsonOutput
+
+def crumbPackage = new File(["node", "--print", "require.resolve('@crumbsdk/react-native/package.json')"].execute(null, rootDir).text.trim()).parentFile
+def crumbTool = new File(crumbPackage, 'tools/cli.cjs')
+def crumbNodeWrapper = new File(crumbPackage, 'tools/node.cjs')
+def runCrumb = { args, directory ->
+    def execution = providers.exec {
+        workingDir directory
+        commandLine args
+        ignoreExitValue = true
+    }
+    def stdout = execution.standardOutput.asText.get()
+    def stderr = execution.standardError.asText.get()
+    if (stdout.trim()) logger.lifecycle(stdout.trim())
+    if (stderr.trim()) logger.warn(stderr.trim())
+    execution.result.get().assertNormalExitValue()
+}
+
+plugins.withId('com.facebook.react') {
+    androidComponents.onVariants(androidComponents.selector().all()) { variant ->
+        def suffix = variant.name.capitalize()
+        def bundleName = "createBundle${suffix}JsAndAssets"
+        def releaseDir = layout.buildDirectory.dir("crumb/${variant.name}")
+        def manifest = releaseDir.map { new File(it.asFile, 'release.json') }
+        def uploadTask = tasks.register("uploadCrumb${suffix}SourceMaps") {
+                group = 'react'
+                description = 'Upload exact Crumb release artifacts after JavaScript bundling.'
+                onlyIf {
+                    def bundleTask = tasks.findByName(bundleName)
+                    bundleTask != null && bundleTask.state.executed && bundleTask.state.failure == null && manifest.get().exists()
+                }
+                doLast {
+                    def bundleTask = tasks.getByName(bundleName)
+                    def originalNode = bundleTask.ext.crumbOriginalNode
+                    def outputs = variant.outputs.collect { output ->
+                        [appVersion: output.versionName.get(), nativeBuild: output.versionCode.get().toString()]
+                    }.unique()
+                    outputs.each { target ->
+                        def bundle = new File(bundleTask.jsBundleDir.get().asFile, bundleTask.bundleAssetName.get())
+                        def sourceMap = new File(bundleTask.jsSourceMapsDir.get().asFile, bundleTask.bundleAssetName.get() + '.map')
+                        def input = new File(releaseDir.get().asFile, "input-${target.nativeBuild}.json")
+                        input.text = JsonOutput.toJson(target + [root: bundleTask.root.get().asFile.absolutePath,
+                            manifest: manifest.get().absolutePath, platform: 'android',
+                            bundle: bundle.absolutePath, sourceMap: sourceMap.absolutePath])
+                        runCrumb(originalNode + [crumbTool.absolutePath, 'upload-build', '--input', input.absolutePath], bundleTask.root.get().asFile)
+                    }
+                }
+            }
+        tasks.matching { it.name == bundleName }.configureEach { bundleTask ->
+            def originalNode = new ArrayList(bundleTask.nodeExecutableAndArgs.get())
+            bundleTask.nodeExecutableAndArgs.set(originalNode + [crumbNodeWrapper.absolutePath, manifest.get().absolutePath])
+            bundleTask.outputs.file(manifest)
+            bundleTask.outputs.file(releaseDir.map { new File(it.asFile, 'crumb-release.js') })
+            bundleTask.inputs.file(new File(bundleTask.root.get().asFile, 'crumb.config.json')).optional()
+            bundleTask.doFirst {
+                runCrumb(originalNode + [crumbTool.absolutePath, 'prepare', '--directory', releaseDir.get().asFile.absolutePath], bundleTask.root.get().asFile)
+            }
+            bundleTask.ext.crumbOriginalNode = originalNode
+            bundleTask.finalizedBy(uploadTask)
+        }
+    }
+}

package/tools/expo-export.cjs

@@ -0,0 +1,122 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { randomUUID } = require('node:crypto');
+const {
+  prepareRelease,
+  readRelease,
+  verifyMapIdentity,
+} = require('./release.cjs');
+const { uploadRelease } = require('./upload.cjs');
+const { readConfig } = require('./config.cjs');
+
+function validateTargets(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 100)
+    throw new Error(
+      'Supply between 1 and 100 explicit native release targets.'
+    );
+  const seen = new Set();
+  for (const target of value) {
+    if (
+      !target ||
+      !['ios', 'android'].includes(target.platform) ||
+      Object.keys(target).some(
+        (key) => !['platform', 'appVersion', 'nativeBuild'].includes(key)
+      ) ||
+      ![target.appVersion, target.nativeBuild].every(
+        (item) =>
+          typeof item === 'string' &&
+          /^[A-Za-z0-9][A-Za-z0-9._+-]{0,63}$/.test(item)
+      )
+    ) {
+      throw new Error(
+        'Each target must contain platform (ios/android), appVersion and nativeBuild from an eligible built binary.'
+      );
+    }
+    const key = JSON.stringify([
+      target.platform,
+      target.appVersion,
+      target.nativeBuild,
+    ]);
+    if (seen.has(key)) throw new Error('Duplicate native release target.');
+    seen.add(key);
+  }
+  return value;
+}
+
+function exportArtifacts(directory, targets) {
+  const metadata = JSON.parse(
+    fs.readFileSync(path.join(directory, 'metadata.json'), 'utf8')
+  );
+  if (
+    metadata.version !== 0 ||
+    metadata.bundler !== 'metro' ||
+    !metadata.fileMetadata
+  )
+    throw new Error(
+      'Unsupported Expo export metadata. Use the advanced uploader for this export format.'
+    );
+  return targets.map((target) => {
+    const name = metadata.fileMetadata[target.platform]?.bundle;
+    if (typeof name !== 'string' || path.isAbsolute(name))
+      throw new Error('The export is missing a native platform bundle.');
+    const bundle = path.resolve(directory, name);
+    if (!bundle.startsWith(path.resolve(directory) + path.sep))
+      throw new Error('The export bundle must be inside the export directory.');
+    const sourceMap = bundle + '.map';
+    for (const file of [bundle, sourceMap]) {
+      if (
+        !fs.statSync(file).isFile() ||
+        !fs.realpathSync(file).startsWith(fs.realpathSync(directory) + path.sep)
+      )
+        throw new Error(
+          'Export artifacts must be regular files inside the export directory.'
+        );
+    }
+    return { ...target, bundle, sourceMap };
+  });
+}
+
+function exportRelease(root, output, targetsFile, options = {}) {
+  if (!readConfig(root).sourceMaps.enabled)
+    throw new Error(
+      'Enable source maps with crumb setup before preparing an export.'
+    );
+  const targets = validateTargets(
+    JSON.parse(fs.readFileSync(targetsFile, 'utf8'))
+  );
+  const directory = path.resolve(root, output);
+  if (fs.existsSync(directory))
+    throw new Error(
+      'Choose a new export directory. Crumb does not overwrite an existing export.'
+    );
+  const manifest = prepareRelease(
+    path.join(root, '.crumb', 'exports', randomUUID())
+  );
+  const expo = require.resolve('expo/bin/cli', { paths: [root] });
+  const args = [expo, 'export', '--source-maps', '--output-dir', directory];
+  for (const platform of new Set(targets.map((target) => target.platform)))
+    args.push('--platform', platform);
+  const result = spawnSync(process.execPath, args, {
+    cwd: root,
+    stdio: 'inherit',
+    env: { ...process.env, CRUMB_RELEASE_MANIFEST: manifest },
+  });
+  if (result.error || result.status !== 0)
+    throw new Error(
+      'Expo export failed. Fix the build error before uploading or publishing an update.'
+    );
+  const artifacts = exportArtifacts(directory, targets);
+  for (const artifact of artifacts)
+    verifyMapIdentity(artifact.sourceMap, readRelease(manifest).bundleVersion);
+  for (const artifact of artifacts)
+    uploadRelease(
+      { root, manifest, ...artifact },
+      { dryRun: options.dryRun, strict: true }
+    );
+  console.log(
+    'Crumb: export retained. Publish this exact directory with EAS --input-dir and --skip-bundler; do not rebuild it.'
+  );
+}
+
+module.exports = { validateTargets, exportArtifacts, exportRelease };

package/tools/ios.cjs

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+const path = require('node:path');
+const fs = require('node:fs');
+const { spawnSync, execFileSync } = require('node:child_process');
+const { readConfig, isStrict } = require('./config.cjs');
+const { prepareRelease } = require('./release.cjs');
+const { uploadRelease } = require('./upload.cjs');
+
+function plistValue(env, key) {
+  const candidates = [
+    env.TARGET_BUILD_DIR && env.INFOPLIST_PATH
+      ? path.resolve(env.TARGET_BUILD_DIR, env.INFOPLIST_PATH)
+      : undefined,
+    env.INFOPLIST_FILE
+      ? path.resolve(env.PROJECT_DIR, env.INFOPLIST_FILE)
+      : undefined,
+  ];
+  for (const file of candidates) {
+    if (!file || !fs.existsSync(file)) continue;
+    try {
+      const value = execFileSync(
+        '/usr/libexec/PlistBuddy',
+        ['-c', `Print :${key}`, file],
+        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }
+      ).trim();
+      return value.replace(
+        /\$\(([^)]+)\)|\$\{([^}]+)\}/g,
+        (expression, a, b) => env[a || b] || expression
+      );
+    } catch {
+      /* Try the build's other plist source. */
+    }
+  }
+  return undefined;
+}
+
+function main() {
+  const env = { ...process.env };
+  const root = path.resolve(
+    env.PROJECT_ROOT || path.join(env.PROJECT_DIR || process.cwd(), '..')
+  );
+  const config = readConfig(root);
+  const enabled =
+    config.sourceMaps.enabled &&
+    !/Debug/i.test(env.CONFIGURATION || '') &&
+    env.SKIP_BUNDLING !== '1';
+  let manifest;
+  if (enabled) {
+    if (!env.DERIVED_FILE_DIR)
+      throw new Error('Run the Crumb iOS hook from an Xcode build.');
+    manifest = prepareRelease(
+      path.join(env.DERIVED_FILE_DIR, 'crumb', env.TARGET_NAME || 'app')
+    );
+    env.CRUMB_RELEASE_MANIFEST = manifest;
+    env.SOURCEMAP_FILE = path.join(path.dirname(manifest), 'bundle.map');
+  }
+  const [command, ...args] = process.argv.slice(2);
+  if (!command)
+    throw new Error('The original Xcode bundle command is required.');
+  const build = spawnSync(command, args, { env, stdio: 'inherit' });
+  if (build.error || build.status !== 0) {
+    process.exitCode = build.status || 1;
+    return;
+  }
+  if (!manifest) return;
+  const bundle = path.join(
+    env.CONFIGURATION_BUILD_DIR,
+    env.UNLOCALIZED_RESOURCES_FOLDER_PATH,
+    `${env.BUNDLE_NAME || 'main'}.jsbundle`
+  );
+  uploadRelease(
+    {
+      root,
+      manifest,
+      platform: 'ios',
+      appVersion: plistValue(env, 'CFBundleShortVersionString'),
+      nativeBuild: plistValue(env, 'CFBundleVersion'),
+      bundle,
+      sourceMap: env.SOURCEMAP_FILE,
+    },
+    { strict: isStrict(config) }
+  );
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.error(`Crumb: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+module.exports = { plistValue };

package/tools/node.cjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+const { spawnSync } = require('node:child_process');
+const { readConfig } = require('./config.cjs');
+const [manifest, ...args] = process.argv.slice(2);
+if (!manifest || !args.length) {
+  console.error(
+    'Crumb build wrapper requires release metadata and the original Node command.'
+  );
+  process.exitCode = 1;
+} else {
+  const result = spawnSync(process.execPath, [...process.execArgv, ...args], {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      CRUMB_RELEASE_MANIFEST: readConfig(process.cwd()).sourceMaps.enabled
+        ? manifest
+        : '',
+    },
+  });
+  process.exitCode = result.status === null ? 1 : result.status;
+}

package/tools/release.cjs

@@ -0,0 +1,65 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID, createHash } = require('node:crypto');
+
+function prepareRelease(directory) {
+  fs.mkdirSync(directory, { recursive: true });
+  const bundleVersion = randomUUID();
+  const polyfill = path.join(directory, 'crumb-release.js');
+  fs.writeFileSync(
+    polyfill,
+    `globalThis.__CRUMB_BUNDLE_VERSION__ = ${JSON.stringify(bundleVersion)};\n`
+  );
+  const manifest = path.join(directory, 'release.json');
+  fs.writeFileSync(
+    manifest,
+    JSON.stringify({ version: 1, bundleVersion, polyfill })
+  );
+  return manifest;
+}
+
+function readRelease(file) {
+  const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (
+    value.version !== 1 ||
+    typeof value.bundleVersion !== 'string' ||
+    !/^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$/.test(value.bundleVersion) ||
+    typeof value.polyfill !== 'string' ||
+    !path.isAbsolute(value.polyfill)
+  ) {
+    throw new Error(
+      'Crumb release metadata is invalid. Rebuild using the configured Crumb build hook.'
+    );
+  }
+  return value;
+}
+
+function hashFile(file) {
+  return createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function verifyMapIdentity(file, bundleVersion) {
+  if (fs.statSync(file).size > 25 * 1024 * 1024)
+    throw new Error('Source map exceeds the 25 MiB upload limit.');
+  const map = JSON.parse(fs.readFileSync(file, 'utf8'));
+  function contains(value, depth = 0) {
+    if (!value || depth > 8) return false;
+    return (
+      (Array.isArray(value.sourcesContent) &&
+        value.sourcesContent.some(
+          (source) =>
+            typeof source === 'string' &&
+            source.includes('__CRUMB_BUNDLE_VERSION__') &&
+            source.includes(JSON.stringify(bundleVersion))
+        )) ||
+      (Array.isArray(value.sections) &&
+        value.sections.some((section) => contains(section.map, depth + 1)))
+    );
+  }
+  if (!contains(map))
+    throw new Error(
+      'The final map does not contain this build’s Crumb identity. Check the Metro integration and rebuild; no artifacts were uploaded.'
+    );
+}
+
+module.exports = { prepareRelease, readRelease, hashFile, verifyMapIdentity };

package/tools/setup.cjs

@@ -0,0 +1,291 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { readConfig, validateOrigin } = require('./config.cjs');
+const {
+  configureXcodeProject,
+  configureGradle,
+} = require('../plugin/build-hooks.cjs');
+
+const metroMarker = '// crumb-metro';
+
+function setupPlan(root, { sourceMaps, uploadUrl } = {}) {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(root, 'package.json'), 'utf8')
+  );
+  const dependencies = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (!dependencies['react-native'])
+    throw new Error('Run crumb setup from the React Native app directory.');
+  const expo = Boolean(dependencies.expo);
+  const manager = [
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'bun.lock',
+    'bun.lockb',
+    'package-lock.json',
+  ].find((name) => fs.existsSync(path.join(root, name)));
+  const changes = [];
+  const instructions = [];
+  const edit = (name, content) => {
+    const file = path.join(root, name);
+    const before = fs.existsSync(file)
+      ? fs.readFileSync(file, 'utf8')
+      : undefined;
+    if (before !== content) changes.push({ name, file, before, content });
+  };
+  const config = readConfig(root);
+  if (sourceMaps !== undefined) config.sourceMaps.enabled = sourceMaps;
+  if (config.sourceMaps.enabled)
+    config.sourceMaps.uploadUrl = validateOrigin(
+      uploadUrl || config.sourceMaps.uploadUrl
+    );
+  edit('crumb.config.json', JSON.stringify(config, null, 2) + '\n');
+  if (!dependencies['react-native-nitro-modules']) {
+    const version =
+      require('../package.json').peerDependencies['react-native-nitro-modules'];
+    const add =
+      manager === 'yarn.lock'
+        ? 'yarn add'
+        : manager === 'pnpm-lock.yaml'
+          ? 'pnpm add'
+          : manager?.startsWith('bun')
+            ? 'bun add'
+            : 'npm install';
+    instructions.push(
+      `Install the required native peer: ${add} react-native-nitro-modules@${JSON.stringify(version)}`
+    );
+  }
+  if (expo) {
+    if (
+      ['app.config.ts', 'app.config.js', 'app.config.mjs'].some((name) =>
+        fs.existsSync(path.join(root, name))
+      )
+    ) {
+      instructions.push(
+        'Add @crumbsdk/react-native to plugins in your dynamic Expo config. Existing dynamic configuration was preserved.'
+      );
+    } else {
+      const appFile = path.join(root, 'app.json');
+      const app = fs.existsSync(appFile)
+        ? JSON.parse(fs.readFileSync(appFile, 'utf8'))
+        : { expo: {} };
+      if (!app.expo)
+        throw new Error(
+          'app.json does not contain an Expo configuration. Add the Crumb plugin manually.'
+        );
+      const plugins = app.expo.plugins || [];
+      if (
+        !plugins.some(
+          (item) =>
+            (Array.isArray(item) ? item[0] : item) === '@crumbsdk/react-native'
+        )
+      ) {
+        app.expo.plugins = [...plugins, '@crumbsdk/react-native'];
+        edit('app.json', JSON.stringify(app, null, 2) + '\n');
+      }
+    }
+    instructions.push(
+      'Run your normal Expo prebuild/development build to apply native configuration. Expo Go cannot load the native SDK.'
+    );
+  } else {
+    const podfile = path.join(root, 'ios/Podfile');
+    if (fs.existsSync(podfile)) {
+      let contents = fs.readFileSync(podfile, 'utf8');
+      if (!contents.includes('crumb_native_pods!')) {
+        if (
+          /pod\s+['"](?:CrumbSDK(?:Core|UI)?|PLCrashReporter)['"]/.test(
+            contents
+          )
+        ) {
+          throw new Error(
+            'Remove manual Crumb/PLCrashReporter pod declarations before using bundled native dependencies.'
+          );
+        }
+        if (/^.*use_native_modules!.*$/m.test(contents)) {
+          contents = contents.replace(
+            /^.*use_native_modules!.*$/m,
+            (line) =>
+              `${line}\n  require File.join(File.dirname(\`node --print "require.resolve('@crumbsdk/react-native/package.json')"\`.strip), 'scripts', 'ios')\n  crumb_native_pods!`
+          );
+          edit('ios/Podfile', contents);
+        } else
+          instructions.push(
+            'Register crumb_native_pods! inside your app target using the manual iOS instructions.'
+          );
+      }
+      instructions.push(
+        'Install the iOS pods using your project’s usual command.'
+      );
+    }
+  }
+  if (config.sourceMaps.enabled) {
+    const ignoreFile = path.join(root, '.gitignore');
+    const ignore = fs.existsSync(ignoreFile)
+      ? fs.readFileSync(ignoreFile, 'utf8')
+      : '';
+    if (!ignore.split(/\r?\n/).includes('/.crumb/'))
+      edit(
+        '.gitignore',
+        `${ignore}\n# Crumb local release artifacts (never commit source maps)\n/.crumb/\n`
+      );
+    const metroFiles = [
+      'metro.config.js',
+      'metro.config.cjs',
+      'metro.config.mjs',
+      'metro.config.ts',
+    ].filter((name) => fs.existsSync(path.join(root, name)));
+    if (metroFiles.length > 1)
+      throw new Error(
+        'Multiple Metro configurations found. Wrap the active configuration with withCrumb manually.'
+      );
+    const metroName =
+      metroFiles[0] ||
+      (pkg.type === 'module' ? 'metro.config.cjs' : 'metro.config.js');
+    const before = metroFiles[0]
+      ? fs.readFileSync(path.join(root, metroName), 'utf8')
+      : undefined;
+    if (
+      before &&
+      !before.includes(metroMarker) &&
+      !before.includes('@crumbsdk/react-native/metro')
+    ) {
+      if (
+        metroName.endsWith('.mjs') ||
+        metroName.endsWith('.ts') ||
+        (pkg.type === 'module' && metroName.endsWith('.js')) ||
+        !before.includes('module.exports')
+      ) {
+        instructions.push(
+          'Wrap your existing Metro config with withCrumb from @crumbsdk/react-native/metro. This configuration format was preserved.'
+        );
+      } else
+        edit(
+          metroName,
+          `${before}\n${metroMarker}\nmodule.exports = require('@crumbsdk/react-native/metro').withCrumb(module.exports);\n`
+        );
+    } else if (!before) {
+      edit(
+        metroName,
+        `const { getDefaultConfig } = require('${expo ? 'expo/metro-config' : '@react-native/metro-config'}');\n${metroMarker}\nmodule.exports = require('@crumbsdk/react-native/metro').withCrumb(getDefaultConfig(__dirname));\n`
+      );
+    }
+    if (!expo) {
+      const gradle = path.join(root, 'android/app/build.gradle');
+      if (fs.existsSync(gradle))
+        edit(
+          'android/app/build.gradle',
+          configureGradle(fs.readFileSync(gradle, 'utf8'))
+        );
+      else
+        instructions.push(
+          'Apply tools/crumb.gradle in your Android application module using the manual instructions.'
+        );
+      const ios = path.join(root, 'ios');
+      const projects = fs.existsSync(ios)
+        ? fs.readdirSync(ios).filter((name) => name.endsWith('.xcodeproj'))
+        : [];
+      if (projects.length === 1) {
+        const name = `ios/${projects[0]}/project.pbxproj`;
+        const project = require('xcode').project(path.join(root, name));
+        project.parseSync();
+        configureXcodeProject(project);
+        // Avoid formatting unrelated project sections on repeat setup.
+        if (
+          !fs
+            .readFileSync(path.join(root, name), 'utf8')
+            .includes('crumb-release-build')
+        )
+          edit(name, project.writeSync());
+      } else
+        instructions.push(
+          'Configure the app’s Xcode bundle phase using the manual instructions; no unique project was selected.'
+        );
+    }
+    instructions.push(
+      'Set CRUMB_SOURCE_MAP_TOKEN as a build secret. Never put it in this config, app initialization, or EXPO_PUBLIC_* variables.'
+    );
+    instructions.push(
+      'Enable diagnostics.javascriptCrashCapture.enabled in Crumb.start. Remove manual release.bundleVersion when using generated build identity.'
+    );
+  }
+  instructions.push(
+    'Keep the native minimum targets at iOS 15.1 and Android API 26 or higher; retain any higher framework requirement.'
+  );
+  instructions.push(
+    'Initialize Crumb with the SDK configuration from your dashboard, then send a test report.'
+  );
+  return { framework: expo ? 'Expo' : 'React Native', changes, instructions };
+}
+
+function applyPlan(plan) {
+  // Check every file before changing any: a preview must not overwrite later user edits.
+  for (const change of plan.changes) {
+    const current = fs.existsSync(change.file)
+      ? fs.readFileSync(change.file, 'utf8')
+      : undefined;
+    if (current !== change.before)
+      throw new Error(
+        `Setup stopped because ${change.name} changed after preview. Run setup again.`
+      );
+  }
+  for (const change of plan.changes) {
+    fs.mkdirSync(path.dirname(change.file), { recursive: true });
+    fs.writeFileSync(change.file, change.content);
+  }
+}
+
+function doctor(root) {
+  const config = readConfig(root);
+  const checks = [];
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(root, 'package.json'), 'utf8')
+  );
+  for (const name of ['@crumbsdk/react-native', 'react-native-nitro-modules']) {
+    try {
+      require.resolve(`${name}/package.json`, { paths: [root] });
+      checks.push({ check: name, status: 'ready' });
+    } catch {
+      checks.push({
+        check: name,
+        status: 'missing',
+        action: 'Install the dependency in this app.',
+      });
+    }
+  }
+  if (config.sourceMaps.enabled) {
+    const metro = [
+      'metro.config.js',
+      'metro.config.cjs',
+      'metro.config.mjs',
+      'metro.config.ts',
+    ].some((name) => {
+      const file = path.join(root, name);
+      return (
+        fs.existsSync(file) &&
+        fs.readFileSync(file, 'utf8').includes('@crumbsdk/react-native/metro')
+      );
+    });
+    checks.push({
+      check: 'Metro release integration',
+      status: metro ? 'configured' : 'missing',
+      action:
+        'Run crumb setup or wrap your existing Metro config with withCrumb.',
+    });
+    checks.push({
+      check: 'Upload credential in this environment',
+      status: process.env.CRUMB_SOURCE_MAP_TOKEN ? 'present' : 'missing',
+      action:
+        'Set the build secret in the environment that runs release builds.',
+    });
+  }
+  return {
+    framework:
+      pkg.dependencies?.expo || pkg.devDependencies?.expo
+        ? 'Expo'
+        : 'React Native',
+    sourceMaps: config.sourceMaps.enabled,
+    checks,
+    note: 'Local checks do not confirm uploaded maps or readable crashes. Build a release and verify a test crash in the dashboard.',
+  };
+}
+
+module.exports = { setupPlan, applyPlan, doctor };