fix(hermes-base): surface the real hermesc error when a base compile fails

The failure reason was the last three lines of hermesc stderr. hermesc echoes
each diagnostic as message/source/caret, and a minified bundle puts a whole
module on one line, so a single warning could be 100k+ characters and pushed
the actual error out of the window — the report showed only warning noise.

Add summarizeHermescStderr(): drop caret lines and the source echo before
them, prefer error/fatal/assertion lines over warnings, and cap each kept
line. Also write the full stderr to <outputFolder>/hermes-base-error.log and
point at it, so the untruncated compiler output stays available.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: sunnylqm

src/bundle-runner.ts

@@ -552,6 +552,37 @@ async function checkGradleConfig(): Promise<GradleConfig> {
  * simply stays in the intermediate directory (never packed into the ppk) so
  * `address at` stack frames can still be symbolicated later.
  */
+/**
+ * hermesc echoes every diagnostic as three lines (header, the offending source
+ * line, a caret line). Minified bundles put a whole module on one line, so a
+ * single warning can be 100k+ characters and blindly keeping the tail of stderr
+ * buries the actual error under warning noise. Keep the diagnostic headers,
+ * prefer errors over warnings, and cap the length of whatever survives.
+ */
+export function summarizeHermescStderr(stderr: string): string {
+  const raw = String(stderr ?? '').split(/\r?\n/);
+  const kept: string[] = [];
+  for (let i = 0; i < raw.length; i++) {
+    const line = raw[i].trim();
+    if (!line) continue;
+    if (/^\^~*$/.test(line)) continue; // caret line
+    // the line before a caret is the echoed source, never the message
+    const next = raw[i + 1]?.trim();
+    if (next && /^\^~*$/.test(next)) continue;
+    kept.push(line.length > 300 ? `${line.slice(0, 300)}…` : line);
+  }
+  if (kept.length === 0) return '';
+  const isError = (line: string) =>
+    /(?::\s*|^)(?:fatal error|error)\b/i.test(line) ||
+    /^(?:Assertion|Stack dump|PLEASE submit a bug report)/i.test(line);
+  const errors = kept.filter(isError);
+  if (errors.length > 0) return errors.slice(-3).join(' ');
+  const notWarnings = kept.filter(
+    (line) => !/:\s*(?:warning|note):/i.test(line),
+  );
+  return (notWarnings.length > 0 ? notWarnings : kept).slice(-3).join(' ');
+}
+
 export function buildHermescArgs(bundlePath: string): string[] {
   return [
     '-emit-binary',
@@ -604,14 +635,21 @@ async function compileHermesByteCode(
     if (attempt.status === 0) {
       usedBase = true;
     } else {
-      const stderr = attempt.stderr
-        ? String(attempt.stderr).trim().split('\n').slice(-3).join(' ')
-        : '';
+      const fullStderr = attempt.stderr ? String(attempt.stderr) : '';
+      const reason = summarizeHermescStderr(fullStderr);
       console.warn(
         t('hermesBaseCompileFailed', {
-          reason: stderr || `exit ${attempt.status}`,
+          reason: reason || `exit ${attempt.status}`,
         }),
       );
+      if (fullStderr.trim()) {
+        // the summary drops warning noise; keep everything for bug reports
+        const logPath = path.join(outputFolder, 'hermes-base-error.log');
+        try {
+          fs.writeFileSync(logPath, fullStderr);
+          console.warn(t('hermesBaseCompileFailedLog', { file: logPath }));
+        } catch {}
+      }
       fs.copyFileSync(jsBackup, bundlePath);
     }
   }

src/locales/en.ts

@@ -220,6 +220,8 @@ This can reduce the risk of inconsistent dependencies and supply chain attacks.
   hermesBaseDownloading: 'Hermes base: downloading {{- url}}',
   hermesBaseCompileFailed:
     'Hermes base compile failed ({{- reason}}); retrying without -base-bytecode',
+  hermesBaseCompileFailedLog:
+    'Hermes base: full compiler output written to {{- file}}',
   hermesBaseVerified:
     'Hermes base: bytecode verified equivalent to a plain compile',
   hermesBaseVerifyFailed:

src/locales/zh.ts

@@ -203,6 +203,7 @@ export default {
   hermesBaseDownloading: 'Hermes base：下载 {{- url}}',
   hermesBaseCompileFailed:
     'Hermes base 编译失败（{{- reason}}），改为不带 -base-bytecode 重编',
+  hermesBaseCompileFailedLog: 'Hermes base：完整编译错误已写入 {{- file}}',
   hermesBaseVerified: 'Hermes base：字节码与普通编译等价，校验通过',
   hermesBaseVerifyFailed:
     'Hermes base：字节码与普通编译不等价，放弃 base 重新编译',

tests/bundle-runner.test.ts

@@ -11,6 +11,7 @@ import {
   resolveExpoCli,
   resolveHermesCommand,
   resolveSentryUploadMode,
+  summarizeHermescStderr,
 } from '../src/bundle-runner';
 
 function mkTempDir(prefix: string): string {
@@ -457,3 +458,42 @@ describe('buildHermescArgs', () => {
     ]);
   });
 });
+
+describe('summarizeHermescStderr', () => {
+  const warning = [
+    'index.bundlejs:204:115354: warning: the variable "clearTimeout" was not declared in anonymous function',
+    `__d(function(e,n,t){${'x'.repeat(2000)}})`,
+    `${' '.repeat(500)}^~~~~~~~~~~~~`,
+  ].join('\n');
+
+  test('surfaces the error instead of the warning noise around it', () => {
+    const stderr = [
+      warning,
+      'index.bundlejs:1:1: error: base bytecode is not compatible',
+      'var a = 1;',
+      '^~~',
+      warning,
+    ].join('\n');
+    expect(summarizeHermescStderr(stderr)).toBe(
+      'index.bundlejs:1:1: error: base bytecode is not compatible',
+    );
+  });
+
+  test('drops source and caret lines and caps the remaining length', () => {
+    const summary = summarizeHermescStderr(warning);
+    expect(summary).toContain('was not declared in anonymous function');
+    expect(summary).not.toContain('__d(function');
+    expect(summary.length).toBeLessThan(400);
+  });
+
+  test('keeps crash output that carries no error: prefix', () => {
+    const stderr = `${warning}\nAssertion \`baseBCProvider\` failed.`;
+    expect(summarizeHermescStderr(stderr)).toBe(
+      'Assertion `baseBCProvider` failed.',
+    );
+  });
+
+  test('returns an empty string for empty stderr', () => {
+    expect(summarizeHermescStderr('')).toBe('');
+  });
+});