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

package/src/log-buffer.ts

@@ -48,25 +48,39 @@ export function configureLogBuffer(options: CrumbLogOptions | undefined): void {
 export function markNativeStarted(): void {
   nativeStarted = true;
   NativeCrumbReactNative.clearLogs();
+  if (!canCollectLogs()) {
+    clearBufferedEntries();
+    return;
+  }
   for (const entry of entries) {
     NativeCrumbReactNative.addLog(JSON.stringify(entry));
   }
 }
 
 export function clearLogs(): void {
-  entries = [];
-  usedBytes = 0;
+  clearBufferedEntries();
   if (nativeStarted) {
     NativeCrumbReactNative.clearLogs();
   }
 }
 
+export function snapshotLogEntries(): readonly CrumbLogEntry[] {
+  if (!canCollectLogs()) {
+    clearBufferedEntries();
+    return [];
+  }
+  prune(Date.now());
+  return entries.slice();
+}
+
 export function writeLog(
   level: CrumbLogLevel,
   message: string,
   metadata?: CrumbLogMetadata,
   category: CrumbLogEntry['category'] = 'javascript'
 ): void {
+  if (!canCollectLogs()) return;
+
   const timestampMs = Date.now();
   const metadataText = metadata ? serializeMetadata(metadata) : undefined;
   const entry: CrumbLogEntry = {
@@ -121,6 +135,8 @@ export function disableConsoleCapture(): void {
 }
 
 function writeConsoleLog(level: 'warning' | 'error', data: unknown[]): void {
+  if (!canCollectLogs()) return;
+
   const suppliedError = data.find(
     (value): value is Error => value instanceof Error
   );
@@ -130,6 +146,15 @@ function writeConsoleLog(level: 'warning' | 'error', data: unknown[]): void {
   writeLog(level, message, undefined, 'console');
 }
 
+function canCollectLogs(): boolean {
+  return !nativeStarted || NativeCrumbReactNative.canCollectLogs();
+}
+
+function clearBufferedEntries(): void {
+  entries = [];
+  usedBytes = 0;
+}
+
 function renderConsoleValue(value: unknown): string {
   if (value instanceof Error) return value.stack ?? value.message;
   if (typeof value === 'string') return value;

package/src/screen-context.ts

@@ -0,0 +1,154 @@
+import { useEffect } from 'react';
+import NativeCrumbReactNative from './NativeCrumbReactNative';
+
+export interface CrumbScreenOptions {
+  /** Static names from root to focused screen, never route parameters. Maximum eight. */
+  readonly route?: readonly string[];
+}
+
+interface ScreenContext {
+  readonly name: string;
+  readonly route: readonly string[];
+  readonly source: 'manual' | 'react_navigation' | 'expo_router';
+}
+
+/** Compatible with a React Navigation container ref; no navigation dependency required. */
+export interface CrumbNavigationRef {
+  isReady(): boolean;
+  getRootState(): unknown;
+  addListener(event: 'ready' | 'state', listener: () => void): () => void;
+}
+
+let owner: object | null = null;
+let screenJson = 'null';
+
+/** Snapshot before crossing the async native UI dispatch boundary. */
+export function currentScreenJson(): string {
+  return screenJson;
+}
+
+function validLabel(value: unknown): value is string {
+  // UTF-8 bytes, including surrogate pairs, without requiring TextEncoder in Hermes.
+  if (
+    typeof value !== 'string' ||
+    !value.trim() ||
+    value.length > 128 ||
+    // Reject control characters in untrusted screen labels.
+    // eslint-disable-next-line no-control-regex
+    /[\u0000-\u001f\u007f-\u009f?#]|:\/\//.test(value)
+  )
+    return false;
+  let bytes = 0;
+  for (const char of value) {
+    const point = char.codePointAt(0) ?? 0;
+    bytes += point <= 0x7f ? 1 : point <= 0x7ff ? 2 : point <= 0xffff ? 3 : 4;
+  }
+  return bytes <= 128;
+}
+
+function publish(context: ScreenContext | null, token: object): void {
+  owner = token;
+  screenJson = JSON.stringify(context);
+  NativeCrumbReactNative.setScreenContext(screenJson);
+}
+
+function release(token: object): void {
+  if (owner === token) publish(null, token);
+}
+
+/** Supply a static screen name. Call with null when the app no longer has an active screen. */
+export function setScreen(
+  name: string | null,
+  options?: CrumbScreenOptions
+): void {
+  const token = {};
+  if (name === null) {
+    publish(null, token);
+    return;
+  }
+  const route = options?.route ?? [name];
+  if (
+    !validLabel(name) ||
+    route.length < 1 ||
+    route.length > 8 ||
+    !route.every(validLabel)
+  ) {
+    publish(null, token);
+    throw new Error(
+      'Crumb screen names must be static labels of at most 128 UTF-8 bytes, with one to eight route names and no URL, query or fragment.'
+    );
+  }
+  publish({ name, route: [...route], source: 'manual' }, token);
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** Register once at the container; handles initial ready, nested state changes and cleanup. */
+export function trackReactNavigation(ref: CrumbNavigationRef): () => void {
+  const token = {};
+  let active = true;
+  const update = () => {
+    if (!active) return;
+    try {
+      if (!ref.isReady()) {
+        publish(null, token);
+        return;
+      }
+      let state: unknown = ref.getRootState();
+      const route: string[] = [];
+      while (record(state) && Array.isArray(state.routes)) {
+        if (route.length === 8 || !Number.isInteger(state.index)) {
+          publish(null, token);
+          return;
+        }
+        const focused: unknown = state.routes[Number(state.index)];
+        if (!record(focused) || !validLabel(focused.name)) {
+          publish(null, token);
+          return;
+        }
+        route.push(focused.name);
+        state = focused.state;
+      }
+      const name = route[route.length - 1];
+      publish(name ? { name, route, source: 'react_navigation' } : null, token);
+    } catch {
+      publish(null, token);
+    }
+  };
+  const ready = ref.addListener('ready', update);
+  const state = ref.addListener('state', update);
+  update();
+  return () => {
+    active = false;
+    ready();
+    state();
+    release(token);
+  };
+}
+
+/** Pass Expo Router useSegments(), never usePathname() or search parameters. */
+export function useExpoRouterScreen(segments: readonly string[]): void {
+  const key = JSON.stringify(segments);
+  useEffect(() => {
+    const token = {};
+    // Reconstruct only validated strings; dynamic segments remain templates such as [id].
+    const value: unknown = JSON.parse(key);
+    const route = Array.isArray(value) && value.length === 0 ? ['/'] : value;
+    const name = Array.isArray(route)
+      ? '/' + route.filter((part) => part !== '/').join('/')
+      : '';
+    if (
+      Array.isArray(route) &&
+      route.length <= 8 &&
+      route.every(validLabel) &&
+      validLabel(name)
+    ) {
+      publish({ name, route, source: 'expo_router' }, token);
+    } else {
+      publish(null, token);
+    }
+    return () => release(token);
+  }, [key]);
+}

package/src/types.ts

@@ -1,5 +1,18 @@
 export type CrumbInvocation = 'shake' | 'programmatic';
 
+export type CrumbTheme = 'system' | 'light' | 'dark';
+
+export type CrumbReporterField = 'category' | 'description';
+
+export type CrumbEvidenceCategory =
+  | 'screenshot'
+  | 'performance'
+  | 'network'
+  | 'logs'
+  | 'thread_stacks'
+  | 'health_check'
+  | 'custom_context';
+
 export type CrumbLogLevel =
   | 'debug'
   | 'info'
@@ -32,10 +45,22 @@ export interface CrumbLogOptions {
   captureConsole?: boolean;
 }
 
+export interface CrumbJavaScriptCrashCaptureOptions {
+  /** Captures fatal JavaScript exceptions and unhandled promise rejections. */
+  enabled?: boolean;
+  /** Maximum number of recent Crumb breadcrumbs attached to a crash. */
+  maximumBreadcrumbs?: number;
+  /** Maximum UTF-8 bytes used by the attached breadcrumbs. */
+  maximumBreadcrumbBytes?: number;
+}
+
 export interface CrumbDiagnosticsOptions {
   healthCheckUrl?: string;
   timeoutMs?: number;
   logs?: CrumbLogOptions;
+  javascriptCrashCapture?: CrumbJavaScriptCrashCaptureOptions;
+  /** Opt-in rolling five-second rendering statistics; no screen content is recorded. */
+  renderingEnabled?: boolean;
 }
 
 export interface CrumbPrivacyOptions {
@@ -43,6 +68,29 @@ export interface CrumbPrivacyOptions {
   maskScreenshotsBeforeUpload?: boolean;
 }
 
+export interface CrumbReporterOptions {
+  /** Controls only the built-in reporter appearance. */
+  theme?: CrumbTheme;
+  /** The description field is always required by the report contract. */
+  visibleFields?: readonly CrumbReporterField[];
+}
+
+export interface CrumbApplicationMetadata {
+  name?: string;
+}
+
+export interface CrumbCustomContextOptions {
+  /** String-only context values; only explicitly allowed keys are persisted. */
+  values?: Readonly<Record<string, string>>;
+  allowedKeys?: readonly string[];
+}
+
+export interface CrumbWorkspacePolicyOptions {
+  /** Public policy endpoint. Omit to keep configuration local-only. */
+  url?: string;
+  timeoutMs?: number;
+}
+
 export interface CrumbUploadOptions {
   /** Base URL of the Crumb ingestion API. Omit to keep reports local-only. */
   ingestionUrl?: string;
@@ -57,6 +105,11 @@ export interface CrumbConfiguration {
   diagnostics?: CrumbDiagnosticsOptions;
   privacy?: CrumbPrivacyOptions;
   upload?: CrumbUploadOptions;
+  reporter?: CrumbReporterOptions;
+  evidence?: readonly CrumbEvidenceCategory[];
+  application?: CrumbApplicationMetadata;
+  customContext?: CrumbCustomContextOptions;
+  workspacePolicy?: CrumbWorkspacePolicyOptions;
 }
 
 export type CrumbLogMetadata = Readonly<Record<string, unknown>>;

package/tools/cli.cjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseArgs } = require('node:util');
+const { createInterface } = require('node:readline/promises');
+const { setupPlan, applyPlan, doctor } = require('./setup.cjs');
+const { prepareRelease } = require('./release.cjs');
+const { uploadRelease, retryUpload } = require('./upload.cjs');
+
+async function main() {
+  if (Number(process.versions.node.split('.')[0]) < 22)
+    throw new Error('Crumb build tooling requires Node.js 22 or newer.');
+  const { positionals, values } = parseArgs({
+    allowPositionals: true,
+    options: {
+      help: { type: 'boolean' },
+      apply: { type: 'boolean' },
+      'source-maps': { type: 'boolean' },
+      'upload-url': { type: 'string' },
+      root: { type: 'string' },
+      directory: { type: 'string' },
+      input: { type: 'string' },
+      receipt: { type: 'string' },
+      output: { type: 'string' },
+      targets: { type: 'string' },
+      'dry-run': { type: 'boolean' },
+    },
+  });
+  const root = path.resolve(values.root || process.cwd());
+  const [command] = positionals;
+  if (values.help || !command) {
+    console.log(
+      'crumb setup [--source-maps --upload-url HTTPS_ORIGIN] [--apply]\ncrumb doctor\ncrumb retry --receipt FILE\ncrumb export --output DIRECTORY --targets FILE [--dry-run]\n\nSetup previews changes; --apply accepts them without prompting. Upload credentials belong only in CRUMB_SOURCE_MAP_TOKEN.'
+    );
+    return;
+  }
+  if (command === 'setup') {
+    let sourceMaps = values['source-maps'];
+    let uploadUrl = values['upload-url'];
+    const prompt =
+      process.stdin.isTTY && !values.apply
+        ? createInterface({ input: process.stdin, output: process.stdout })
+        : undefined;
+    try {
+      if (prompt && sourceMaps === undefined)
+        sourceMaps = /^y(es)?$/i.test(
+          await prompt.question(
+            'Configure source maps for opt-in JavaScript crashes? [y/N] '
+          )
+        );
+      if (prompt && sourceMaps && !uploadUrl)
+        uploadUrl = await prompt.question(
+          'Upload origin from your Crumb integration page: '
+        );
+      const plan = setupPlan(root, { sourceMaps, uploadUrl });
+      console.log(`Crumb setup: ${plan.framework}`);
+      for (const change of plan.changes)
+        console.log(
+          `- ${change.before === undefined ? 'Create' : 'Update'} ${change.name}`
+        );
+      console.log(
+        'Setup adds Crumb configuration, preserves existing settings, and wraps supported build hooks. Review the resulting diff before committing.'
+      );
+      if (
+        values.apply ||
+        (prompt &&
+          /^y(es)?$/i.test(
+            await prompt.question(
+              `Apply ${plan.changes.length} reviewed file changes? [y/N] `
+            )
+          ))
+      ) {
+        applyPlan(plan);
+        console.log('Setup changes applied.');
+      } else
+        console.log(
+          'Preview only. Run again with --apply to apply these changes.'
+        );
+      for (const instruction of plan.instructions)
+        console.log(`- ${instruction}`);
+    } finally {
+      prompt?.close();
+    }
+  } else if (command === 'doctor') {
+    const result = doctor(root);
+    console.log(JSON.stringify(result, null, 2));
+    if (result.checks.some((check) => check.status === 'missing'))
+      process.exitCode = 1;
+  } else if (command === 'prepare' && values.directory) {
+    prepareRelease(path.resolve(values.directory));
+  } else if (command === 'upload-build' && values.input) {
+    uploadRelease(JSON.parse(fs.readFileSync(values.input, 'utf8')), {
+      dryRun: values['dry-run'],
+    });
+  } else if (command === 'export' && values.output && values.targets) {
+    require('./expo-export.cjs').exportRelease(
+      root,
+      values.output,
+      values.targets,
+      { dryRun: values['dry-run'] }
+    );
+  } else if (command === 'retry' && values.receipt) {
+    retryUpload(values.receipt);
+  } else
+    throw new Error('Unknown or incomplete Crumb command. Run crumb --help.');
+}
+
+main().catch((error) => {
+  const message =
+    error instanceof SyntaxError ||
+    String(error.code).startsWith('ERR_PARSE_ARGS')
+      ? 'Invalid command or JSON input. Run crumb --help; keep credentials only in the build environment.'
+      : error.message;
+  console.error(`Crumb: ${message}`);
+  process.exitCode = 1;
+});

package/tools/config.cjs

@@ -0,0 +1,72 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function readConfig(root) {
+  const file = path.join(root, 'crumb.config.json');
+  if (!fs.existsSync(file))
+    return { version: 1, sourceMaps: { enabled: false } };
+  let config;
+  try {
+    config = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    throw new Error(
+      'Could not read crumb.config.json. Check that it contains valid JSON without credentials.'
+    );
+  }
+  if (
+    !config ||
+    typeof config !== 'object' ||
+    Array.isArray(config) ||
+    config.version !== 1 ||
+    !config.sourceMaps ||
+    typeof config.sourceMaps !== 'object' ||
+    Array.isArray(config.sourceMaps) ||
+    Object.keys(config).some(
+      (key) => !['version', 'sourceMaps'].includes(key)
+    ) ||
+    Object.keys(config.sourceMaps).some(
+      (key) => !['enabled', 'uploadUrl', 'strict'].includes(key)
+    ) ||
+    typeof config.sourceMaps.enabled !== 'boolean' ||
+    (config.sourceMaps.strict !== undefined &&
+      typeof config.sourceMaps.strict !== 'boolean')
+  ) {
+    throw new Error(
+      'Invalid crumb.config.json. Use crumb setup; keep credentials only in the build environment.'
+    );
+  }
+  if (config.sourceMaps.enabled) validateOrigin(config.sourceMaps.uploadUrl);
+  return config;
+}
+
+function validateOrigin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(
+      'Supply the HTTPS upload origin shown in your Crumb integration instructions.'
+    );
+  }
+  if (
+    url.protocol !== 'https:' ||
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash ||
+    url.pathname !== '/'
+  ) {
+    throw new Error(
+      'The upload origin must use HTTPS without a path, credentials, query, or fragment.'
+    );
+  }
+  return url.origin;
+}
+
+function isStrict(config, env = process.env) {
+  return (
+    env.CRUMB_SOURCE_MAP_STRICT === '1' || config.sourceMaps.strict === true
+  );
+}
+
+module.exports = { readConfig, validateOrigin, isStrict };

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 };