Babel preset: Add Hermes V1 native runtime workarounds for hermes#1761

## Summary:

Three Babel plugins added to `@react-native/babel-preset` that work
around runtime codegen bugs in the bundled Hermes V1 (250829098.0.13,
branch cut 2025-08-29) by rewriting source patterns before they reach
the engine. Each plugin papers over a different bug that has been fixed
on Hermes `static_h` but has not been backported to the V1 stable
branch.

- `fix-hermes-v1-async-arrow-non-simple-params`:
  facebook/hermes#1761 (fixed in static_h by 68bfb3a48b31, 2025-09-11).
  Async arrow functions with destructured, defaulted, or rest parameters
  silently resolve `await` with `undefined` while the function body
  continues executing in the background. The plugin rewrites the params
  to a simple identifier with inline destructuring so Hermes never sees
  the buggy shape. Gated on `isHermesProfile && preserveAsync` since
  `plugin-transform-async-to-generator` rewrites the pattern away when
  `preserveAsync` is false.

- `fix-hermes-v1-class-in-finally`:
  Fixed in static_h by 1e94fbe0ebb4 (2026-02-12). Class declarations
  inside a `finally` block trip Hermes V1's variable caching path. The
  plugin wraps them in an IIFE so the class lives in its own scope.

- `fix-hermes-v1-super-in-object-accessor`:
  Fixed in static_h by 18a963465944 (2025-11-04). Object-literal getters
  and setters using `super.x` trip the `genFunctionExpression` home
  object path. The plugin marks the accessor as computed with a string
  key.

All three gate on `isHermesProfile` and bail out fast on the common
case. The plugins are a direct port of work by @kitten (Phil Pluckthun,
Expo team) in `babel-preset-expo` (expo/expo#45601, MIT licensed). All
plugin design and implementation credit belongs to him. This PR carries
his work over to `@react-native/babel-preset` so bare React Native
consumers benefit from the same fix.

## Changelog:

[GENERAL] [FIXED] - Work around three Hermes V1 source-level codegen bugs in `@react-native/babel-preset` (async-arrow non-simple params, class-in-finally, super-in-object-accessor)

## Test Plan:

- 18 new inline-snapshot test cases across three new test files verify both the transformed output and the fast-bail behavior on irrelevant patterns.
- `yarn jest packages/react-native-babel-preset` clean (65 tests, 24 snapshots).
- Full repo `yarn test` clean (279 suites, 5656 tests passed, 1816 snapshots).
- `yarn lint`, `yarn format-check`, `yarn flow-check`, `yarn test-typescript`, `yarn featureflags --verify-unchanged`, `yarn build-types --validate` all clean.
- Existing `transform-snapshot-test` passes byte-identical: the kitchen-sink fixture has none of the buggy patterns so the new plugins do not change its output for any profile.
- Verified end-to-end downstream: `babel-preset-expo@56.0.7` (which carries the same plugins) applied to vanilla `@convex-dev/better-auth@0.12.2` fixes the `useConvexAuth.isAuthenticated` race that the destructured-param async-arrow shape produces on Hermes V1.
- Public repro: https://github.com/ramonclaudio/convex-better-auth-368-repro

## Caveats:

`fix-hermes-v1-class-in-finally` rewrites block-scoped `class`
declarations inside `finally` blocks to function-scoped `var`
initializers. Observable only when code references the class by name
from outside the `finally` (rare pattern). The same plugin shape has
run in `babel-preset-expo@56.0.6+` and Expo SDK 56 preview for a week
without reported regressions, but flagging in case Meta's internal test
fleet surfaces an edge case the OSS test suite does not catch.

## References:

- facebook/hermes#1761 (root-cause issue, fixed in static_h)
- expo/expo#45601 (source of the ported plugins, by @kitten)
- expo/expo#45592 (user-facing bug report on SDK 56 preview)

Co-authored-by: Phil Pluckthun <phil@kitten.sh>

Author: ramonclaudio

packages/react-native-babel-preset/src/__tests__/fix-hermes-v1-async-arrow-non-simple-params-test.js

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @noflow
+ */
+
+'use strict';
+
+const {transform} = require('../__mocks__/test-helpers');
+const fixHermesV1AsyncArrowNonSimpleParams = require('../fix-hermes-v1-async-arrow-non-simple-params');
+
+test('rewrites destructured object param with default to simple identifier', () => {
+  const code = `
+    const fn = async ({a = 1, b} = {}) => {
+      return await fetch(a + b);
+    };
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async _p => {
+      var {
+        a = 1,
+        b
+      } = _p === undefined ? {} : _p;
+      return await fetch(a + b);
+    };"
+  `);
+});
+
+test('rewrites destructured array param to simple identifier', () => {
+  const code = `
+    const fn = async ([a, b]) => await Promise.resolve(a + b);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async _p => {
+      var [a, b] = _p;
+      return await Promise.resolve(a + b);
+    };"
+  `);
+});
+
+test('rewrites assignment-pattern param without enclosing destructure', () => {
+  const code = `
+    const fn = async (x = 5) => await use(x);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async _p => {
+      var x = _p === undefined ? 5 : _p;
+      return await use(x);
+    };"
+  `);
+});
+
+test('wraps body in inner async arrow when rest param is present', () => {
+  const code = `
+    const fn = async (...args) => await handle(args);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = (...args) => (async () => {
+      return await handle(args);
+    })();"
+  `);
+});
+
+test('leaves async arrow with only simple identifier params alone', () => {
+  const code = `
+    const fn = async (a, b) => await fetch(a + b);
+  `;
+
+  expect(
+    transform(code, [fixHermesV1AsyncArrowNonSimpleParams]),
+  ).toMatchInlineSnapshot(`"const fn = async (a, b) => await fetch(a + b);"`);
+});
+
+test('leaves non-async arrow alone', () => {
+  const code = `
+    const fn = ({a = 1, b} = {}) => a + b;
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = ({
+      a = 1,
+      b
+    } = {}) => a + b;"
+  `);
+});
+
+test('handles multiple params mixing simple and complex', () => {
+  const code = `
+    const fn = async (a, {b}, c = 1) => await all(a, b, c);
+  `;
+
+  expect(transform(code, [fixHermesV1AsyncArrowNonSimpleParams]))
+    .toMatchInlineSnapshot(`
+    "const fn = async (a, _p, _p2) => {
+      var {
+        b
+      } = _p;
+      var c = _p2 === undefined ? 1 : _p2;
+      return await all(a, b, c);
+    };"
+  `);
+});

packages/react-native-babel-preset/src/__tests__/fix-hermes-v1-class-in-finally-test.js

@@ -0,0 +1,135 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @noflow
+ */
+
+'use strict';
+
+const {transform} = require('../__mocks__/test-helpers');
+const fixHermesV1ClassInFinally = require('../fix-hermes-v1-class-in-finally');
+
+test('wraps class declaration in finally block in IIFE', () => {
+  const code = `
+    function run() {
+      try {
+        risky();
+      } finally {
+        class Logger {
+          log() { console.log('done'); }
+        }
+        new Logger().log();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "function run() {
+      try {
+        risky();
+      } finally {
+        var Logger = (() => {
+          class Logger {
+            log() {
+              console.log('done');
+            }
+          }
+          return Logger;
+        })();
+        new Logger().log();
+      }
+    }"
+  `);
+});
+
+test('wraps class expression in finally block in IIFE', () => {
+  const code = `
+    function run() {
+      try {
+        risky();
+      } finally {
+        const Logger = class {
+          log() {}
+        };
+        new Logger().log();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "function run() {
+      try {
+        risky();
+      } finally {
+        const Logger = (() => class {
+          log() {}
+        })();
+        new Logger().log();
+      }
+    }"
+  `);
+});
+
+test('leaves class outside finally block alone', () => {
+  const code = `
+    function run() {
+      try {
+        class Inside {}
+        return new Inside();
+      } catch (e) {
+        class Caught {}
+        return new Caught();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "function run() {
+      try {
+        class Inside {}
+        return new Inside();
+      } catch (e) {
+        class Caught {}
+        return new Caught();
+      }
+    }"
+  `);
+});
+
+test('leaves class declared at module scope alone', () => {
+  const code = `
+    class Module {}
+    new Module();
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "class Module {}
+    new Module();"
+  `);
+});
+
+test('does not enter nested function scope', () => {
+  const code = `
+    try {} finally {
+      function inner() {
+        class NestedFn {}
+        return new NestedFn();
+      }
+      inner();
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1ClassInFinally])).toMatchInlineSnapshot(`
+    "try {} finally {
+      function inner() {
+        class NestedFn {}
+        return new NestedFn();
+      }
+      inner();
+    }"
+  `);
+});

packages/react-native-babel-preset/src/__tests__/fix-hermes-v1-super-in-object-accessor-test.js

@@ -0,0 +1,128 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @noflow
+ */
+
+'use strict';
+
+const {transform} = require('../__mocks__/test-helpers');
+const fixHermesV1SuperInObjectAccessor = require('../fix-hermes-v1-super-in-object-accessor');
+
+test('rewrites identifier-keyed object getter using super.x to computed string key', () => {
+  const code = `
+    const obj = {
+      get name() {
+        return super.name;
+      },
+    };
+  `;
+
+  expect(transform(code, [fixHermesV1SuperInObjectAccessor]))
+    .toMatchInlineSnapshot(`
+    "const obj = {
+      get [\\"name\\"]() {
+        return super.name;
+      }
+    };"
+  `);
+});
+
+test('rewrites identifier-keyed object setter using super.x to computed string key', () => {
+  const code = `
+    const obj = {
+      set value(v) {
+        super.value = v;
+      },
+    };
+  `;
+
+  expect(transform(code, [fixHermesV1SuperInObjectAccessor]))
+    .toMatchInlineSnapshot(`
+    "const obj = {
+      set [\\"value\\"](v) {
+        super.value = v;
+      }
+    };"
+  `);
+});
+
+test('leaves super inside class method alone', () => {
+  const code = `
+    class Child extends Parent {
+      get name() {
+        return super.name;
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1SuperInObjectAccessor]))
+    .toMatchInlineSnapshot(`
+    "class Child extends Parent {
+      get name() {
+        return super.name;
+      }
+    }"
+  `);
+});
+
+test('leaves super inside regular object method alone', () => {
+  const code = `
+    const obj = {
+      run() {
+        return super.run();
+      },
+    };
+  `;
+
+  expect(transform(code, [fixHermesV1SuperInObjectAccessor]))
+    .toMatchInlineSnapshot(`
+    "const obj = {
+      run() {
+        return super.run();
+      }
+    };"
+  `);
+});
+
+test('leaves super() call alone', () => {
+  const code = `
+    class Child extends Parent {
+      constructor() {
+        super();
+      }
+    }
+  `;
+
+  expect(transform(code, [fixHermesV1SuperInObjectAccessor]))
+    .toMatchInlineSnapshot(`
+    "class Child extends Parent {
+      constructor() {
+        super();
+      }
+    }"
+  `);
+});
+
+test('skips already-computed accessor', () => {
+  const code = `
+    const obj = {
+      get [keyName]() {
+        return super.value;
+      },
+    };
+  `;
+
+  expect(transform(code, [fixHermesV1SuperInObjectAccessor]))
+    .toMatchInlineSnapshot(`
+    "const obj = {
+      get [keyName]() {
+        return super.value;
+      }
+    };"
+  `);
+});