pulse-updates 1.2.0 → 1.2.2

package/README.md

@@ -392,7 +392,10 @@ npx pulse-updates register-capabilities --platform <ios|android> [--api-key <key
 
 Run it at build time so the server can warn when a future JS-only update references native modules
 the installed binary doesn't have. When the release pipeline already has the exact embedded bundle,
-pass it with `--bundle <path>`; otherwise the command builds the production Metro graph automatically.
+pass it with `--bundle <path>`. On Android the command automatically reuses the newest Gradle packager
+source map (the exact pre-Hermes graph retained under `android/app/build/intermediates/sourcemaps`), so
+a normal Gradle release build needs no extra path. If no embedded or generated source exists, it builds
+an unminified, scan-only Metro graph; that fallback is never uploaded or used as the app's launch bundle.
 
 ### Configuration File
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pulse-updates",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "OTA updates for React Native - lightweight alternative to expo-updates",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",

package/scripts/publish.mjs

@@ -36,7 +36,21 @@ export function extractNativeModulesFromSource(source) {
 }
 
 export function extractNativeModules(bundlePath) {
-  return extractNativeModulesFromSource(fs.readFileSync(bundlePath, 'utf8'));
+  if (isHermesBytecode(bundlePath)) {
+    throw new Error(
+      `Capability source is Hermes bytecode: ${bundlePath}. ` +
+      'Pass the pre-Hermes bundle or its index.android.bundle.packager.map source map.'
+    );
+  }
+  const raw = fs.readFileSync(bundlePath, 'utf8');
+  if (bundlePath.endsWith('.map')) {
+    const sourceMap = JSON.parse(raw);
+    if (!Array.isArray(sourceMap.sourcesContent)) {
+      throw new Error(`Capability source map has no sourcesContent: ${bundlePath}`);
+    }
+    return extractNativeModulesFromSource(sourceMap.sourcesContent.filter(Boolean).join('\n'));
+  }
+  return extractNativeModulesFromSource(raw);
 }
 
 /**
@@ -235,9 +249,10 @@ function ensureHermesc(platform) {
 /**
  * Create JS bundle using Metro
  */
-function createBundle(platform, bundleDir, entryFile = 'index.ts') {
+function createBundle(platform, bundleDir, entryFile = 'index.ts', options = {}) {
   const bundleOutput = path.join(bundleDir, platform, 'index.bundle');
   const assetsDir = path.join(bundleDir, platform, 'assets');
+  const minify = options.minify ?? true;
 
   // Clean and create directories
   fs.rmSync(path.join(bundleDir, platform), { recursive: true, force: true });
@@ -250,11 +265,13 @@ function createBundle(platform, bundleDir, entryFile = 'index.ts') {
     'npx react-native bundle',
     `--platform ${platform}`,
     '--dev false',
+    options.resetCache ? '--reset-cache' : null,
     `--entry-file ${entryFile}`,
     `--bundle-output ${bundleOutput}`,
     `--assets-dest ${assetsDir}`,
-    '--minify true',
-  ].join(' ');
+    options.sourceMap ? `--sourcemap-output ${bundleOutput}.map` : null,
+    `--minify ${minify}`,
+  ].filter(Boolean).join(' ');
 
   execSync(cmd, { stdio: 'inherit' });
 
@@ -1129,14 +1146,66 @@ export function resolveCapabilitiesBundle(options, config, bundleFactory = creat
     return resolved;
   }
 
+  if (config.platform === 'android') {
+    const generated = findLatestGeneratedAndroidCapabilitySource(config.projectRoot || process.cwd());
+    if (generated) {
+      log(`  Using the latest Gradle-generated Android capability source: ${generated}`, colors.dim);
+      return generated;
+    }
+  }
+
   logStep('1/2', `Building the ${config.platform} production bundle for capability discovery...`);
   return bundleFactory(
     config.platform,
     path.resolve(config.bundleDir || './dist'),
-    config.entryFile || 'index.ts'
+    config.entryFile || 'index.ts',
+    // Capability discovery scans source text and does not ship this bundle. Keep
+    // it unminified: worklet transformers may create short-lived virtual modules
+    // that Metro's minifier tries to hash after they have already been removed.
+    // The release pipeline should still pass --bundle whenever it has the exact
+    // embedded artifact, which remains the authoritative path.
+    { minify: false, resetCache: true, sourceMap: true }
   );
 }
 
+/** Find the pre-Hermes graph most recently produced by a React Native Android Gradle task. */
+export function findLatestGeneratedAndroidCapabilitySource(projectRoot = process.cwd()) {
+  const buildRoot = path.join(projectRoot, 'android', 'app', 'build');
+  if (!fs.existsSync(buildRoot)) return null;
+
+  const candidates = [];
+  const variantOf = (candidatePath) => {
+    const normal = candidatePath.replaceAll('\\', '/');
+    return normal.match(/\/react\/([^/]+)\/index\.android\.bundle/)?.[1]
+      || normal.match(/\/intermediates\/assets\/([^/]+)\//)?.[1]
+      || null;
+  };
+  const visit = (directory) => {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(fullPath);
+      else if (entry.isFile() && entry.name === 'index.android.bundle.packager.map') {
+        candidates.push({ path: fullPath, modifiedAt: fs.statSync(fullPath).mtimeMs, map: true, variant: variantOf(fullPath) });
+      } else if (entry.isFile() && entry.name === 'index.android.bundle' && !isHermesBytecode(fullPath)) {
+        candidates.push({ path: fullPath, modifiedAt: fs.statSync(fullPath).mtimeMs, map: false, variant: variantOf(fullPath) });
+      }
+    }
+  };
+  visit(buildRoot);
+  candidates.sort((a, b) => b.modifiedAt - a.modifiedAt);
+  const latest = candidates[0];
+  if (!latest) return null;
+
+  // Gradle writes the minified bundle after its packager map. Choosing only by mtime therefore
+  // selects the bundle, where R8/Metro have erased the canonical native binding call sites, and
+  // reports a dangerous empty capability set. For the newest build variant, the packager map is
+  // authoritative because it retains every original module in sourcesContent.
+  const matchingMap = latest.variant
+    ? candidates.find((candidate) => candidate.map && candidate.variant === latest.variant)
+    : null;
+  return matchingMap?.path || latest.path;
+}
+
 
 /**
  * The experiments an app is running, and how their split is holding.