fix: re-declare GestureHandlerRootView, and guard the handlers a byte diff drops

`GestureHandlerRootView` sat in the exclusion register's `notAComponent` bucket,
which the generated invariants subtract, so nothing rendered it. It renders two
ways. The default is `<View style={style ?? styles.container} {...rest} />`, and
the rewrite substitutes a styled twin for that `View`, so the class resolves.
The Android one renders `specs/RNGestureHandlerRootViewNativeComponent` with no
`react-native` specifier in the file, so the rewrite matches nothing:

    ANDROID/REWRITE {"type":"RNGestureHandlerRootView",
                     "props":{"style":{"flex":1},"className":"w-80"}}

That is the `PureNativeButton` shape on the export every app mounts at its root,
on the platform where mounting it is mandatory. It type-checks today through
`ViewProps`, so nothing stops a user writing it.

A bare `className: "style"` mapping fixes Android and regresses the default:
Gesture Handler reaches its `{ flex: 1 }` through `style ?? styles.container`
over a module-private StyleSheet, and resolving a class is exactly a thing that
makes `style` present. Measured, the class-only render went `[{width:95},{flex:1}]`
to `[{width:95}]`. The wrapper carries the default itself and applies it on the
same condition the `??` does — an inline style displaces it, a class does not.

Jest's `defaultPlatform` is `ios`, so a suite cannot reach the Android variant by
resolution. Substituting its module for the one the index requires puts the
shipped wrapper over the shipped Android component; the new suite renders both
variants and pins the byte-identical no-className path on each. Rendering the
root view calls `maybeInitializeFabric`, which reaches an `install()` the JS
module carries only inside a native binary, so the suites clear the global
`isFabric()` reads.

The no-className guard compares `JSON.stringify` of two trees, and that drops
exactly the props whose value is a function — these nodes carry up to four. A
wrapper written `const { onPress, ...rest } = props` reddened nothing: 3 failed,
1170 passed, byte-for-byte the control. `Object.keys().sort()` does not close it
either, because Pressable renders `testOnly_onPress={props.onPress}` whether or
not one was given, so only the value goes `undefined`. Neither does firing a
press: `findEventHandler` walks `element.parent` until something carries a prop
matching the event, and the JSX element the test itself wrote is on that path,
so a component that drops `onPress` on the floor still answers with the caller's
own callback. Comparing the function-valued prop names against the unwrapped twin
is what sees it, and it is the exact complement of what the byte comparison sees.
A test pins that a press is not a forwarding probe, so the closer that looks
obvious is not written again.

`DrawerLayoutAndroid` renders no handler at all under react-native's jest mock,
which makes its generated case an equality between two empty sets. It is named
rather than left to read as a measurement, and pinned beside the block.

The Reanimated exclusion keeps its outcome and loses its reason. "Out of reach
entirely" reads as an external constraint, and the constraint is this PR's own
`moduleName ===` branch — a `startsWith` away, in a function that already carries
a non-exact branch for react-native's Libraries. What actually blocks them is an
API question: neither exposes a plain `style`, only `contentContainerStyle` /
`drawerContainerStyle` and `containerStyle` / `childrenContainerStyle`, so
covering them means minting four `*ClassName` props. Those are the same four
`DrawerLayout` and `Swipeable` expose, which is what makes it worth revisiting:
the deprecated bucket is excluded because Gesture Handler sends users to
Pressable and to the Reanimated twins, and the twins are the uncovered set.

The derivation's domain is `Object.keys` over the index module, so those two are
outside it permanently — that is the limit on a census that otherwise enrols a
new member on its own commit.

Author: YevheniiKotyrlo

src/__tests__/_gesture-handler.ts

@@ -11,6 +11,18 @@ interface RenderedNode {
   children: RenderedNode[] | null;
 }
 
+/**
+ * `GestureHandlerRootView` calls `maybeInitializeFabric()` while rendering, which
+ * reaches `RNGestureHandlerModule.install()` — a method the JS module carries only
+ * inside a native binary. React Native's own jest setup defines `nativeFabricUIManager`
+ * as `{}`, and `isFabric()` reads that global and nothing else, so clearing it takes
+ * the branch that never touches the module. Every suite that renders the re-declared
+ * census needs this, which is why it is here rather than in one of them.
+ */
+export function disableFabric(): void {
+  Reflect.set(globalThis, "nativeFabricUIManager", undefined);
+}
+
 /** Every rendered element's props, at any depth. */
 export function collectProps(node: unknown): Record<string, unknown>[] {
   if (node === null || typeof node !== "object") {
@@ -26,6 +38,26 @@ export function collectProps(node: unknown): Record<string, unknown>[] {
   return [props, ...collectProps(children)];
 }
 
+/**
+ * Every rendered element's function-valued prop names, at any depth. `JSON.stringify`
+ * drops exactly the props whose value is a function, so a byte comparison of two trees
+ * is blind to a wrapper that swallows a handler — and these nodes carry up to four.
+ * This is the complement of what the byte comparison sees, which is what makes the two
+ * together a whole guard.
+ *
+ * The value TYPE is the discriminator, not the name. Gesture Handler's Pressable renders
+ * `testOnly_onPress={props.onPress}` unconditionally, so the KEY is present either way
+ * and `Object.keys()` reports no difference at all; only the value goes `undefined`.
+ */
+export function functionPropNames(node: unknown): string[][] {
+  return collectProps(node).map((props) =>
+    Object.entries(props)
+      .filter(([, value]) => typeof value === "function")
+      .map(([name]) => name)
+      .sort(),
+  );
+}
+
 /**
  * Every style object in the tree, at any array depth. The merge nests — a Pressable
  * carrying both `className` and `style` renders `[{}, [{…}, {…}]]` — so flattening a
@@ -48,7 +80,7 @@ export function flattenStyles(node: unknown): Record<string, unknown>[] {
 /**
  * Derived from the module, not restated: a member the wrapper re-declares is one whose
  * export is no longer the one `export *` provided. Every generated case reads this, so
- * an eighth re-declaration is covered the moment it lands.
+ * a further re-declaration is covered the moment it lands.
  */
 export function deriveReDeclared(
   styledExports: Record<string, unknown>,
@@ -69,7 +101,6 @@ export const notAComponent = [
   "Directions",
   "Gesture",
   "GestureDetector",
-  "GestureHandlerRootView",
   "HoverEffect",
   "MouseButton",
   "PointerType",
@@ -128,6 +159,11 @@ export const reasonedExclusions = [
  * when a member has been missed, and the drop invariant is generated from THIS — so
  * an unhandled component is rendered and held to the invariant rather than waiting
  * for the accounting test to notice a name is absent from a list.
+ *
+ * The domain is `Object.keys` over the index module, and that is the limit of what
+ * deriving buys: ReanimatedDrawerLayout and ReanimatedSwipeable ship from their own
+ * entry points, so they are outside it permanently and no upstream change can enrol
+ * them here. Covering those two is an edit to this file, not a thing it notices.
  */
 export function deriveExcludedComponents(
   gestureHandlerExports: Record<string, unknown>,
@@ -140,6 +176,17 @@ export function deriveExcludedComponents(
     .sort();
 }
 
+/**
+ * Re-declared members that render no function-valued prop for the guard to compare, so
+ * its verdict on them is an equality between two empty sets. React Native's jest mock for
+ * the Android-only DrawerLayoutAndroid renders a debug placeholder `View` and forwards
+ * none of its props — not `testID`, not a callback — which is the same tier limit the
+ * RefreshControl exclusion stands on. Naming it is what stops the generated case reading
+ * as a measurement it is not, and the pinned test beside the block is what keeps the
+ * name honest.
+ */
+export const handlerUnobservable = ["DrawerLayoutAndroid"];
+
 /** Props a component will not render at all without. */
 export const requiredProps: Record<string, Record<string, unknown>> = {
   DrawerLayout: { renderNavigationView: () => null },

src/__tests__/compiler/react-native-gesture-handler.test.tsx

@@ -9,10 +9,13 @@ import * as RNGH from "react-native-gesture-handler";
 
 import {
   deriveReDeclared,
+  disableFabric,
   flattenStyles,
   requiredProps,
 } from "../_gesture-handler";
 
+beforeAll(disableFabric);
+
 /**
  * The compiler plane's statement about the gesture-handler defect is that it has none:
  * `compile` takes a CSS string and nothing else, so no artifact it emits can know which
@@ -70,8 +73,8 @@ test("the declaration carries a style object, not a prop target", () => {
 });
 
 test("the census the two runtime halves are generated from is non-empty", () => {
-  // Derived by diffing the wrapper's exports against the real package's, so an
-  // eighth re-declaration joins both halves on its own. An emptied census would
+  // Derived by diffing the wrapper's exports against the real package's, so a
+  // further re-declaration joins both halves on its own. An emptied census would
   // make every case below vacuous.
   expect(reDeclared.length).toBeGreaterThan(0);
 });

src/__tests__/native/react-native-gesture-handler-rewrite.test.tsx

@@ -6,11 +6,14 @@ import { registerCSS, testID } from "react-native-css/jest";
 import {
   collectProps,
   deprecatedByGestureHandler,
+  disableFabric,
   flattenStyles,
   reachedByTheRewrite,
   requiredProps,
 } from "../_gesture-handler";
 
+beforeAll(disableFabric);
+
 /**
  * `nativeResolver` rewrites every `react-native` import outside this package to
  * `react-native-css/components` — react-native's own exports with the styled

src/__tests__/native/react-native-gesture-handler-root-view.test.tsx

@@ -0,0 +1,107 @@
+import type { ComponentType } from "react";
+
+import { render } from "@testing-library/react-native";
+import { registerCSS, testID } from "react-native-css/jest";
+
+import {
+  collectProps,
+  disableFabric,
+  flattenStyles,
+} from "../_gesture-handler";
+
+/**
+ * `GestureHandlerRootView` has two implementations, and only one of them is reachable
+ * from the sibling suites. The default renders a react-native `View`, so the rewrite
+ * substitutes a styled twin underneath it and the class resolves whether or not this
+ * package re-declares anything. The Android one renders
+ * `specs/RNGestureHandlerRootViewNativeComponent` — a codegen'd native view, with no
+ * `react-native` specifier anywhere in the file — so the rewrite has nothing to match
+ * and the raw class string lands on the element. That is the `PureNativeButton` shape,
+ * on the export every app mounts at its root, on the platform where mounting it is
+ * mandatory.
+ *
+ * Jest's `defaultPlatform` is `ios`, so the sibling suites resolve the default variant
+ * and cannot see this. Substituting the Android module for the one the index requires
+ * is what puts the shipped wrapper over the shipped Android component.
+ */
+jest.mock(
+  "react-native-gesture-handler/lib/commonjs/components/GestureHandlerRootView",
+  (): Record<string, unknown> =>
+    jest.requireActual<Record<string, unknown>>(
+      "react-native-gesture-handler/lib/commonjs/components/GestureHandlerRootView.android",
+    ),
+);
+
+beforeAll(disableFabric);
+
+function styledRootView(): ComponentType<Record<string, unknown>> {
+  return jest.requireActual<Record<string, unknown>>(
+    "react-native-css/components/react-native-gesture-handler",
+  ).GestureHandlerRootView as ComponentType<Record<string, unknown>>;
+}
+
+function unwrappedRootView(): ComponentType<Record<string, unknown>> {
+  return jest.requireActual<Record<string, unknown>>(
+    "react-native-gesture-handler",
+  ).GestureHandlerRootView as ComponentType<Record<string, unknown>>;
+}
+
+function renderWith(
+  component: ComponentType<Record<string, unknown>>,
+  props: Record<string, unknown> = {},
+): unknown {
+  const Component = component;
+
+  return render(<Component testID={testID} {...props} />).toJSON();
+}
+
+test("the Android variant is what these cases render", () => {
+  // Without the substitution every assertion below measures the default variant, which
+  // the sibling suites already cover — and the two disagree precisely here.
+  expect(JSON.stringify(renderWith(unwrappedRootView()))).toContain(
+    "RNGestureHandlerRootView",
+  );
+});
+
+test("the unwrapped Android variant leaks the class — the bug this closes", () => {
+  registerCSS(`.w-97 { width: 97px; }`);
+
+  const tree = renderWith(unwrappedRootView(), { className: "w-97" });
+
+  expect(
+    collectProps(tree).filter((props) => Object.hasOwn(props, "className")),
+  ).not.toEqual([]);
+  expect(flattenStyles(tree)).not.toContainEqual(
+    expect.objectContaining({ width: 97 }),
+  );
+});
+
+test("the wrapper resolves the class on Android, where the rewrite cannot", () => {
+  registerCSS(`.w-98 { width: 98px; }`);
+
+  const tree = renderWith(styledRootView(), { className: "w-98" });
+
+  expect(flattenStyles(tree)).toContainEqual(
+    expect.objectContaining({ width: 98 }),
+  );
+
+  for (const props of collectProps(tree)) {
+    expect(props).not.toHaveProperty("className");
+  }
+});
+
+test("the flex:1 default survives the class on Android too", () => {
+  registerCSS(`.w-99 { width: 99px; }`);
+
+  expect(
+    flattenStyles(renderWith(styledRootView(), { className: "w-99" })),
+  ).toContainEqual(expect.objectContaining({ flex: 1 }));
+});
+
+test("renders identically to the unwrapped Android variant with no className", () => {
+  // The resolver routes every gesture-handler import in the graph through this module,
+  // so the no-className path has to stay byte-identical on both variants.
+  expect(JSON.stringify(renderWith(styledRootView()))).toBe(
+    JSON.stringify(renderWith(unwrappedRootView())),
+  );
+});