react-native 0.88.0-rc.0 → 0.88.0-rc.1

package/scripts/spm/spm-types.js

@@ -9,6 +9,7 @@
  */
 
 /*::
+import type {SwiftpmNameOutcome} from './swiftpm-config';
 export type SetupArgs = {
   action: 'add' | 'update' | 'deinit' | 'sync' | 'codegen' | 'download' | 'scaffold' | null,
   version: string | null,
@@ -66,6 +67,8 @@ export type AutolinkingArgs = {
   autolinkingJson: string | null,
   output: string | null,
   xcframeworksPath: string | null,
+  // Platform floor of every manifest this run writes; sanitized by parseArgs.
+  iosDeploymentTarget: string,
 };
 
 export type SpmTarget = {
@@ -143,13 +146,19 @@ export type AutolinkedDep = {
   name: string,
   root: string,
   platforms: {ios: AutolinkingIosPlatform, ...},
-  // Resolved Swift target / module / headers-subdir name. Defaults to
-  // toSwiftName(name) and is overridden by the dep's react-native.config.js
-  // `spm.name`. Populated by expandSpmDependencies — always present after
-  // expansion; optional in the type so caller-side construction stays simple.
+  // Resolved Swift target / module / headers-subdir name — the name the library
+  // declares in `swiftpmConfig`, else its podspec's (see resolveSwiftName).
+  // Populated by expandSpmDependencies — always present after expansion;
+  // optional in the type so caller-side construction stays simple.
   swiftName?: string,
-  // Populated by expandSpmDependencies from each dep's
-  // react-native.config.js `spm.dependencies` array.
+  // Where swiftName came from. Only a podspec-derived name is safe for the
+  // scaffolder to record in the library's package.json.
+  swiftNameSource?: 'config' | 'podspec' | 'npm',
+  // Which podspec field named it ('podspec' source only), so `spm scaffold` can
+  // report the choice it made between `header_dir` and `module_name`.
+  swiftNamePodspecKey?: 'header_dir' | 'module_name' | 'name',
+  // Populated by expandSpmDependencies from each dep's declared
+  // `dependencies` array.
   spmDependencies?: Array<string>,
   ...
 };
@@ -199,6 +208,7 @@ export type AggregatorInput = {
   // the aggregator's package deps + the AutolinkedAggregate target deps.
   pluginPackageDeps?: ReadonlyArray<PluginPackageDep>,
   pluginProductDeps?: ReadonlyArray<PluginProductDep>,
+  iosDeploymentTarget?: ?string,
 };
 
 // --- Autolinking plugins (PREVIEW / unstable contract) ---
@@ -370,6 +380,7 @@ export type SynthPackageSpec = {
   // `<react/renderer/components/safeareacontext/X.h>` resolve through the
   // dep's own `common/cpp/` subtree.
   headerSearchPaths?: ?Array<string>,
+  iosDeploymentTarget?: ?string,
 };
 
 
@@ -422,6 +433,10 @@ export type PodspecModel = {
   // physical source tree (SPM has no header_mappings_dir copy step).
   headerMappingsDirs: Array<string>,
   headerDir: ?string,
+  // What CocoaPods compiles the module as, and so what Swift and `@import`
+  // consumers spell (`s.module_name`). Defaults to the pod name in CocoaPods;
+  // null here when the podspec does not declare it.
+  moduleName: ?string,
   frameworks: Array<string>,
   weakFrameworks: Array<string>,
   libraries: Array<string>,
@@ -462,8 +477,7 @@ export type PodspecModel = {
 // Decouples podspec reading from SPM-specific shaping so each side can be
 // tested in isolation.
 export type SpmScaffoldSpec = {
-  // Swift target / module name. Default: toSwiftName(podspec.name); overridden
-  // by `header_dir` when present.
+  // Swift target / module name, as resolved by expandSpmDependencies.
   swiftName: string,
   // Source file paths relative to the dep root, ready for `sources: [...]`
   // emission after the `root/` wrapper-dir prefix is applied at emit time.
@@ -522,6 +536,9 @@ export type ScaffoldResult =
       // changed, --force, etc.); false on first-time scaffolds. The CLI
       // orchestrator prompts only for first-time scaffolds.
       previouslyExisted: boolean,
+      // What became of `swiftpmConfig.name` in the library's package.json.
+      // Absent when the name was not podspec-derived, so nothing was attempted.
+      swiftpmName?: SwiftpmNameOutcome,
     }
   | {
       depName: string,

package/scripts/spm/spm-utils.js

@@ -171,6 +171,29 @@ function toSwiftName(name /*: string */) /*: string */ {
     .join('');
 }
 
+// The charset a declared SwiftPM name must satisfy — permissive on purpose,
+// since it has to admit header-dir style (lowercase with hyphens) as well as
+// Swift identifiers.
+function isValidSwiftName(name /*: unknown */) /*: boolean */ {
+  return typeof name === 'string' && /^[A-Za-z_][A-Za-z0-9_-]*$/.test(name);
+}
+
+/**
+ * SwiftPM's `c99name` — the identifier a target's module is compiled under,
+ * with every character C99 rejects replaced by `_`. `react-native-svg` and
+ * `react_native_svg` share one, so they cannot both be targets.
+ */
+function toC99Name(name /*: string */) /*: string */ {
+  const mangled = name.replace(/[^A-Za-z0-9_]/g, '_');
+  return /^[0-9]/.test(mangled) ? `_${mangled}` : mangled;
+}
+
+// Collision key for a Swift target name: two names that share one collide, as a
+// module (punctuation) or as a headers directory (case).
+function swiftNameKey(name /*: string */) /*: string */ {
+  return toC99Name(name).toLowerCase();
+}
+
 /**
  * Derive a default app name from the raw package name and source path.
  * Prefers the source directory name when it's meaningful (e.g. "RNTester"),
@@ -743,6 +766,9 @@ module.exports = {
   sharedCacheDir,
   defaultCacheDir,
   toSwiftName,
+  toC99Name,
+  swiftNameKey,
+  isValidSwiftName,
   deriveAppName,
   readPackageJson,
   findProjectRoot,

package/scripts/spm/swiftpm-config.js

@@ -0,0 +1,245 @@
+/**
+ * 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.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const {isValidSwiftName, makeLogger} = require('./spm-utils');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {log, warn} = makeLogger('swiftpm-config');
+
+/**
+ * swiftpm-config.js — one reader for a package's SwiftPM settings.
+ *
+ * They live in `swiftpmConfig` in the package's package.json:
+ *
+ *   { "swiftpmConfig": { "name": "RNSVG" } }
+ *
+ * A library owns `name`, `dependencies`, `autolinkingPlugin` and `scaffold`;
+ * an app owns `modules` and `denyPlugins`. The `spm` block in
+ * react-native.config.js is the deprecated spelling of the same fields — still
+ * read so nothing breaks mid-migration, but package.json wins field by field.
+ */
+
+/*::
+export type SwiftpmNameOutcome =
+  | 'created'
+  | 'inserted'
+  | 'already-set'
+  | 'skipped'
+  | 'failed';
+// User-authored, so values stay unknown and are validated where consumed.
+export type SwiftpmConfig = {
+  readonly name?: unknown,
+  readonly dependencies?: unknown,
+  readonly autolinkingPlugin?: unknown,
+  readonly scaffold?: unknown,
+  readonly modules?: unknown,
+  readonly denyPlugins?: unknown,
+  ...
+};
+type RnConfig = {...};
+*/
+
+const SWIFTPM_FIELDS /*: ReadonlyArray<string> */ = [
+  'name',
+  'dependencies',
+  'autolinkingPlugin',
+  'scaffold',
+  'modules',
+  'denyPlugins',
+];
+
+// Config file paths already warned about, by kind of warning.
+const deprecationsReported /*: Set<string> */ = new Set();
+const unknownKeysReported /*: Set<string> */ = new Set();
+
+function readPackageJson(
+  root /*: string */,
+) /*: ?{readonly [string]: unknown} */ {
+  const pkgPath = path.join(root, 'package.json');
+  if (!fs.existsSync(pkgPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return parsed != null && typeof parsed === 'object' ? parsed : null;
+  } catch (e) {
+    warn(
+      `Failed to read ${pkgPath}: ${e.message}. 'swiftpmConfig' is ignored.`,
+    );
+    return null;
+  }
+}
+
+// A settings object, or null for anything else the author may have written
+// there — an array included, since its indices are not fields.
+function objectField(
+  source /*: ?{readonly [string]: unknown} */,
+  key /*: string */,
+) /*: ?SwiftpmConfig */ {
+  const value = source?.[key];
+  return value != null && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : null;
+}
+
+function declaredFields(
+  config /*: ?{readonly [string]: unknown} */,
+) /*: Array<string> */ {
+  return config == null
+    ? []
+    : SWIFTPM_FIELDS.filter(field => config[field] !== undefined);
+}
+
+function stringList(value /*: unknown */) /*: Array<string> */ {
+  return Array.isArray(value) ? value.filter(v => typeof v === 'string') : [];
+}
+
+function reportDeprecation(
+  root /*: string */,
+  fields /*: Array<string> */,
+) /*: void */ {
+  const configPath = path.join(root, 'react-native.config.js');
+  if (deprecationsReported.has(configPath)) {
+    return;
+  }
+  deprecationsReported.add(configPath);
+  warn(
+    `${configPath} declares SwiftPM settings in the deprecated 'spm' block (${fields.join(', ')}). ` +
+      `Move them to 'swiftpmConfig' in the package's package.json — the 'spm' block still works, but will stop being read.`,
+  );
+}
+
+// A misspelled field would otherwise do nothing at all. Unknown keys are only
+// reported, never rejected: a library may declare a field a newer React Native
+// knows and this one does not.
+function reportUnknownKeys(
+  root /*: string */,
+  config /*: SwiftpmConfig */,
+) /*: void */ {
+  const pkgPath = path.join(root, 'package.json');
+  const unknown = Object.keys(config).filter(
+    key => !SWIFTPM_FIELDS.includes(key),
+  );
+  if (unknown.length === 0 || unknownKeysReported.has(pkgPath)) {
+    return;
+  }
+  unknownKeysReported.add(pkgPath);
+  warn(
+    `${pkgPath} declares 'swiftpmConfig' fields React Native does not know (${unknown.join(', ')}). ` +
+      `They are ignored — check the spelling against ${SWIFTPM_FIELDS.join(', ')}.`,
+  );
+}
+
+/**
+ * The SwiftPM settings that apply to the package at `root`: `swiftpmConfig`
+ * from its package.json over the deprecated `spm` block of its already-loaded
+ * react-native.config.js. Null when the package declares neither.
+ */
+function readSwiftpmConfig(
+  root /*: string */,
+  rnConfig /*: ?RnConfig */,
+) /*: ?SwiftpmConfig */ {
+  const fromPackageJson = objectField(readPackageJson(root), 'swiftpmConfig');
+  if (fromPackageJson != null) {
+    reportUnknownKeys(root, fromPackageJson);
+  }
+  const deprecated = objectField(rnConfig, 'spm');
+  const deprecatedFields = declaredFields(deprecated);
+  if (deprecatedFields.length > 0) {
+    reportDeprecation(root, deprecatedFields);
+  }
+  if (fromPackageJson == null) {
+    return deprecatedFields.length > 0 ? deprecated : null;
+  }
+  return {...deprecated, ...fromPackageJson};
+}
+
+// The file's own indentation, so writing a field back does not reformat it.
+function detectIndent(source /*: string */) /*: string */ {
+  return /\n([ \t]+)"/.exec(source)?.[1] ?? '  ';
+}
+
+/**
+ * Records `swiftName` as `swiftpmConfig.name` in the package's package.json —
+ * the scaffolder's migration step, which is what lets a library stop deriving
+ * its SwiftPM name from a podspec. A name the author already chose is never
+ * overwritten.
+ */
+function writeSwiftpmName(
+  root /*: string */,
+  swiftName /*: string */,
+  options /*:: ?: {dryRun?: boolean} */,
+) /*: SwiftpmNameOutcome */ {
+  if (!isValidSwiftName(swiftName)) {
+    return 'skipped';
+  }
+  const pkgPath = path.join(root, 'package.json');
+  let source;
+  let pkg;
+  try {
+    source = fs.readFileSync(pkgPath, 'utf8');
+    pkg = JSON.parse(source);
+  } catch {
+    return 'skipped';
+  }
+  if (pkg == null || typeof pkg !== 'object') {
+    return 'skipped';
+  }
+  const existing = objectField(pkg, 'swiftpmConfig');
+  if (existing == null && pkg.swiftpmConfig !== undefined) {
+    warn(
+      `${pkgPath} has a 'swiftpmConfig' that is not an object; leaving it alone. ` +
+        `React Native resolved the name '${swiftName}' from the podspec.`,
+    );
+    return 'skipped';
+  }
+  const declaredName = existing?.name;
+  if (declaredName === swiftName) {
+    return 'already-set';
+  }
+  if (declaredName != null) {
+    warn(
+      `${pkgPath} already sets 'swiftpmConfig.name' to '${String(declaredName)}'; leaving it. ` +
+        `React Native resolved '${swiftName}' from the podspec — set them to the same value to silence this.`,
+    );
+    return 'skipped';
+  }
+  const outcome = existing == null ? 'created' : 'inserted';
+  pkg.swiftpmConfig = {...existing, name: swiftName};
+  if (options?.dryRun === true) {
+    log(`Would set 'swiftpmConfig.name' to '${swiftName}' in ${pkgPath}`);
+    return outcome;
+  }
+  const serialized = JSON.stringify(pkg, null, detectIndent(source));
+  const content = source.endsWith('\n') ? `${serialized}\n` : serialized;
+  // Staged and renamed, so an interrupted or out-of-space write cannot leave a
+  // third-party package.json truncated.
+  const tmpPath = `${pkgPath}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmpPath, content, 'utf8');
+    fs.renameSync(tmpPath, pkgPath);
+  } catch (e) {
+    fs.rmSync(tmpPath, {force: true});
+    warn(
+      `Could not record 'swiftpmConfig.name' in ${pkgPath}: ${e.message}. The manifest is written; the name is not.`,
+    );
+    return 'failed';
+  }
+  return outcome;
+}
+
+module.exports = {
+  readSwiftpmConfig,
+  stringList,
+  writeSwiftpmName,
+};

package/scripts/spm/sync-spm-autolinking.js

@@ -82,6 +82,10 @@ async function main(
       demandOption: true,
       describe: 'Path to react-native package root',
     })
+    .option('ios-deployment-target', {
+      type: 'string',
+      describe: 'Platform floor forwarded to the autolinker',
+    })
     .help()
     .parseSync();
 
@@ -115,12 +119,17 @@ async function main(
   deps.installSpmCodegenTemplate(appRoot, reactNativeRoot, {log});
 
   log('Re-generating build/generated/autolinking/Package.swift...');
-  deps.generateAutolinking([
+  const autolinkingArgv = [
     '--app-root',
     appRoot,
     '--react-native-root',
     reactNativeRoot,
-  ]);
+  ];
+  const iosDeploymentTarget = parsed['ios-deployment-target'];
+  if (iosDeploymentTarget != null) {
+    autolinkingArgv.push('--ios-deployment-target', iosDeploymentTarget);
+  }
+  deps.generateAutolinking(autolinkingArgv);
 
   // Rebuild the per-app generated-headers farm (vended as the ReactAppHeaders
   // SPM target inside the codegen package). React core headers need no trees

package/sdks/hermes-engine/version.properties

@@ -1 +1 @@
-HERMES_VERSION_NAME=260318099.0.2
+HERMES_VERSION_NAME=260318099.0.3

package/src/private/featureflags/ReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<d9d665005b8706625e48e615f44af4b8>>
+ * @generated SignedSource<<52d39a196023796eed43d419c5a0b855>>
  * @flow strict
  * @noformat
  */
@@ -34,7 +34,7 @@ export type ReactNativeFeatureFlagsJsOnly = Readonly<{
   animatedKeepListenersOnDetach: Getter<boolean>,
   animatedShouldSyncValueBeforeStartCallback: Getter<boolean>,
   deferFlatListFocusChangeRenderUpdate: Getter<boolean>,
-  enableImperativeEvents: Getter<boolean>,
+  enableImperativeEvents_DEPRECATED: Getter<boolean>,
   enableNativeEventTargetEventDispatching: Getter<boolean>,
   externalElementInspectionEnabled: Getter<boolean>,
   fixVirtualizeListCollapseWindowSize: Getter<boolean>,
@@ -80,6 +80,7 @@ export type ReactNativeFeatureFlags = Readonly<{
   enableImagePrefetchingAndroid: Getter<boolean>,
   enableImageTransparentTintColor: Getter<boolean>,
   enableImmediateUpdateModeForContentOffsetChanges: Getter<boolean>,
+  enableImperativeEvents: Getter<boolean>,
   enableImperativeFocus: Getter<boolean>,
   enableInteropViewManagerClassLookUpOptimizationIOS: Getter<boolean>,
   enableIntersectionObserverByDefault: Getter<boolean>,
@@ -168,14 +169,14 @@ export const animatedShouldSyncValueBeforeStartCallback: Getter<boolean> = creat
 export const deferFlatListFocusChangeRenderUpdate: Getter<boolean> = createJavaScriptFlagGetter('deferFlatListFocusChangeRenderUpdate', false);
 
 /**
- * When enabled, ReactNativeElement and ReadOnlyText expose the public EventTarget API (addEventListener, removeEventListener, dispatchEvent). When disabled, those methods are removed from those final classes.
+ * Deprecated in favor of the common flag with the same name, which is the one that can be configured by OSS release stage. This is only kept so JS bundles delivered to older native builds, where the common flag is unavailable, can still enable the feature.
  */
-export const enableImperativeEvents: Getter<boolean> = createJavaScriptFlagGetter('enableImperativeEvents', false);
+export const enableImperativeEvents_DEPRECATED: Getter<boolean> = createJavaScriptFlagGetter('enableImperativeEvents_DEPRECATED', false);
 
 /**
  * When enabled, the React Native renderer dispatches events through the W3C EventTarget API (addEventListener/dispatchEvent) instead of the legacy plugin-based system.
  */
-export const enableNativeEventTargetEventDispatching: Getter<boolean> = createJavaScriptFlagGetter('enableNativeEventTargetEventDispatching', false);
+export const enableNativeEventTargetEventDispatching: Getter<boolean> = createJavaScriptFlagGetter('enableNativeEventTargetEventDispatching', true);
 
 /**
  * Enable the external inspection API for DevTools to communicate with the Inspector overlay.
@@ -335,6 +336,10 @@ export const enableImageTransparentTintColor: Getter<boolean> = createNativeFlag
  * Dispatches state updates for content offset changes synchronously on the main thread.
  */
 export const enableImmediateUpdateModeForContentOffsetChanges: Getter<boolean> = createNativeFlagGetter('enableImmediateUpdateModeForContentOffsetChanges', false);
+/**
+ * When enabled, ReactNativeElement and ReadOnlyText expose the public EventTarget API (addEventListener, removeEventListener, dispatchEvent). When disabled, those methods are removed from those final classes.
+ */
+export const enableImperativeEvents: Getter<boolean> = createNativeFlagGetter('enableImperativeEvents', false);
 /**
  * Enable ref.focus() and ref.blur() for all views, not just TextInput.
  */

package/src/private/featureflags/specs/NativeReactNativeFeatureFlags.js

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<efe20af949bcd1f716b8f620279899ae>>
+ * @generated SignedSource<<d6c54d6154c0f0771c211424e608f182>>
  * @flow strict
  * @noformat
  */
@@ -56,6 +56,7 @@ export interface Spec extends TurboModule {
   readonly enableImagePrefetchingAndroid?: () => boolean;
   readonly enableImageTransparentTintColor?: () => boolean;
   readonly enableImmediateUpdateModeForContentOffsetChanges?: () => boolean;
+  readonly enableImperativeEvents?: () => boolean;
   readonly enableImperativeFocus?: () => boolean;
   readonly enableInteropViewManagerClassLookUpOptimizationIOS?: () => boolean;
   readonly enableIntersectionObserverByDefault?: () => boolean;

package/src/private/webapis/dom/nodes/ReactNativeElement.js

@@ -360,12 +360,14 @@ ReactNativeElement_public.prototype = ReactNativeElement.prototype;
 // `removeEventListener`, `dispatchEvent`) is only inherited by this final class
 // when `enableNativeEventTargetEventDispatching` is enabled (which makes
 // `ReadOnlyNode` extend `EventTarget`). Until that public API is finalized, it
-// is gated behind `enableImperativeEvents`: when that flag is off we remove
-// those methods from this final class. Native/internal event dispatch does not
-// rely on these public methods, so removing them is safe.
+// is gated behind `enableImperativeEvents` (or its deprecated JS-only
+// counterpart, `enableImperativeEvents_DEPRECATED`): when both flags are off we
+// remove those methods from this final class. Native/internal event dispatch
+// does not rely on these public methods, so removing them is safe.
 if (
   ReactNativeFeatureFlags.enableNativeEventTargetEventDispatching() &&
-  !ReactNativeFeatureFlags.enableImperativeEvents()
+  !ReactNativeFeatureFlags.enableImperativeEvents() &&
+  !ReactNativeFeatureFlags.enableImperativeEvents_DEPRECATED()
 ) {
   const prototype: interface {
     addEventListener?: unknown,

package/src/private/webapis/dom/nodes/ReadOnlyText.js

@@ -45,12 +45,14 @@ ReadOnlyText_public.prototype = ReadOnlyText.prototype;
 // `removeEventListener`, `dispatchEvent`) is only inherited by this final class
 // when `enableNativeEventTargetEventDispatching` is enabled (which makes
 // `ReadOnlyNode` extend `EventTarget`). Until that public API is finalized, it
-// is gated behind `enableImperativeEvents`: when that flag is off we remove
-// those methods from this final class. Native/internal event dispatch does not
-// rely on these public methods, so removing them is safe.
+// is gated behind `enableImperativeEvents` (or its deprecated JS-only
+// counterpart, `enableImperativeEvents_DEPRECATED`): when both flags are off we
+// remove those methods from this final class. Native/internal event dispatch
+// does not rely on these public methods, so removing them is safe.
 if (
   ReactNativeFeatureFlags.enableNativeEventTargetEventDispatching() &&
-  !ReactNativeFeatureFlags.enableImperativeEvents()
+  !ReactNativeFeatureFlags.enableImperativeEvents() &&
+  !ReactNativeFeatureFlags.enableImperativeEvents_DEPRECATED()
 ) {
   const prototype: interface {
     addEventListener?: unknown,

package/src/react-private-interface.js

@@ -29,6 +29,7 @@ import typeof ExceptionsManager from '../Libraries/Core/ExceptionsManager';
 import typeof RawEventEmitter from '../Libraries/Core/RawEventEmitter';
 import typeof ReactFiberErrorDialog from '../Libraries/Core/ReactFiberErrorDialog';
 import typeof RCTEventEmitter from '../Libraries/EventEmitter/RCTEventEmitter';
+import type {Spec as FabricUIManager} from '../Libraries/ReactNative/FabricUIManager';
 import typeof {
   createPublicInstance,
   createPublicRootInstance,
@@ -78,6 +79,9 @@ module.exports = {
   get UIManager(): UIManager {
     return require('../Libraries/ReactNative/UIManager').default;
   },
+  get fabricUIManager(): ?FabricUIManager {
+    return require('../Libraries/ReactNative/FabricUIManager').getFabricUIManager();
+  },
   // TODO: Remove when React has migrated to `createAttributePayload` and `diffAttributePayloads`
   get deepDiffer(): deepDiffer {
     return require('../Libraries/Utilities/differ/deepDiffer').default;

package/src/react-private-interface.js.flow

@@ -14,6 +14,7 @@
 // IMPORTANT: Keep this file in sync with react-private-interface.js.
 // ----------------------------------------------------------------------------
 
+import type {Spec as FabricUIManager} from '../Libraries/ReactNative/FabricUIManager';
 import typeof {createPublicTextInstance as createPublicTextInstanceT} from '../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance';
 
 export type {PublicRootInstance} from '../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance';
@@ -26,6 +27,7 @@ export {default as RCTEventEmitter} from '../Libraries/EventEmitter/RCTEventEmit
 export * as ReactNativeViewConfigRegistry from '../Libraries/Renderer/shims/ReactNativeViewConfigRegistry';
 export {default as TextInputState} from '../Libraries/Components/TextInput/TextInputState';
 export {default as UIManager} from '../Libraries/ReactNative/UIManager';
+declare export const fabricUIManager: ?FabricUIManager;
 export {default as deepDiffer} from '../Libraries/Utilities/differ/deepDiffer';
 export {default as deepFreezeAndThrowOnMutationInDev} from '../Libraries/Utilities/deepFreezeAndThrowOnMutationInDev';
 export {default as flattenStyle} from '../Libraries/StyleSheet/flattenStyle';

package/types_generated/Libraries/ReactNative/FabricUIManager.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ *
+ * @generated SignedSource<<7798de311e4858731ccfd93f6ba077fd>>
+ *
+ * This file was translated from Flow by scripts/js-api/build-types/index.js.
+ * Original file: packages/react-native/Libraries/ReactNative/FabricUIManager.js
+ */
+
+import type { MeasureInWindowOnSuccessCallback, MeasureLayoutOnSuccessCallback, MeasureOnSuccessCallback } from "../../src/private/types/HostInstance";
+import type { NativeElementReference } from "../../src/private/webapis/dom/nodes/specs/NativeDOM";
+import type { InternalInstanceHandle, LayoutAnimationConfig, Node } from "../Renderer/shims/ReactNativeTypes";
+import type { RootTag } from "../Types/RootTagTypes";
+export type NodeSet = Array<Node>;
+export type NodeProps = {};
+export interface Spec {
+  readonly createNode: (reactTag: number, viewName: string, rootTag: RootTag, props: NodeProps, instanceHandle: InternalInstanceHandle) => Node;
+  readonly cloneNode: (node: Node) => Node;
+  readonly cloneNodeWithNewChildren: (node: Node) => Node;
+  readonly cloneNodeWithNewProps: (node: Node, newProps: NodeProps) => Node;
+  readonly cloneNodeWithNewChildrenAndProps: (node: Node, newProps: NodeProps) => Node;
+  readonly createChildSet: (rootTag: RootTag) => NodeSet;
+  readonly appendChild: (parentNode: Node, child: Node) => Node;
+  readonly appendChildToSet: (childSet: NodeSet, child: Node) => void;
+  readonly completeRoot: (rootTag: RootTag, childSet: NodeSet) => void;
+  readonly measure: (node: Node | NativeElementReference, callback: MeasureOnSuccessCallback) => void;
+  readonly measureInWindow: (node: Node | NativeElementReference, callback: MeasureInWindowOnSuccessCallback) => void;
+  readonly measureLayout: (node: Node | NativeElementReference, relativeNode: Node | NativeElementReference, onFail: () => void, onSuccess: MeasureLayoutOnSuccessCallback) => void;
+  readonly configureNextLayoutAnimation: (config: LayoutAnimationConfig, callback: () => void, errorCallback: () => void) => void;
+  readonly sendAccessibilityEvent: (node: Node, eventType: string) => void;
+  readonly findShadowNodeByTag_DEPRECATED: (reactTag: number) => Node | undefined;
+  readonly setNativeProps: (node: Node | NativeElementReference, newProps: NodeProps) => void;
+  readonly dispatchCommand: (node: Node, commandName: string, args: Array<unknown>) => void;
+  readonly findNodeAtPoint: (node: Node, locationX: number, locationY: number, callback: (instanceHandle: InternalInstanceHandle | undefined) => void) => void;
+  readonly compareDocumentPosition: (node: Node | NativeElementReference, otherNode: Node | NativeElementReference) => number;
+  readonly getBoundingClientRect: (node: Node | NativeElementReference, includeTransform: boolean) => [number, number, number, number] | undefined;
+  readonly setIsJSResponder: (node: Node | NativeElementReference, isJSResponder: boolean, blockNativeResponder: boolean) => void;
+  readonly unstable_DefaultEventPriority: number;
+  readonly unstable_DiscreteEventPriority: number;
+  readonly unstable_ContinuousEventPriority: number;
+  readonly unstable_IdleEventPriority: number;
+  readonly unstable_getCurrentEventPriority: () => number;
+}
+export declare function getFabricUIManager(): null | undefined | Spec;

package/types_generated/src/react-private-interface.d.ts

@@ -4,12 +4,13 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<43644da4b4f4c04a0f152e538ac03b9e>>
+ * @generated SignedSource<<15c92ca112f9f20e0cf4bade86cf466f>>
  *
  * This file was translated from Flow by scripts/js-api/build-types/index.js.
  * Original file: packages/react-native/src/react-private-interface.js.flow
  */
 
+import type { Spec as FabricUIManager } from "../Libraries/ReactNative/FabricUIManager";
 import type { createPublicTextInstance as $$IMPORT_TYPEOF_1$$ } from "../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance";
 type createPublicTextInstanceT = typeof $$IMPORT_TYPEOF_1$$;
 export type { PublicRootInstance } from "../Libraries/ReactNative/ReactFabricPublicInstance/ReactFabricPublicInstance";
@@ -21,6 +22,8 @@ export { default as RCTEventEmitter } from "../Libraries/EventEmitter/RCTEventEm
 export * as ReactNativeViewConfigRegistry from "../Libraries/Renderer/shims/ReactNativeViewConfigRegistry";
 export { default as TextInputState } from "../Libraries/Components/TextInput/TextInputState";
 export { default as UIManager } from "../Libraries/ReactNative/UIManager";
+export declare const fabricUIManager: null | undefined | FabricUIManager;
+export declare type fabricUIManager = typeof fabricUIManager;
 export { default as deepDiffer } from "../Libraries/Utilities/differ/deepDiffer";
 export { default as deepFreezeAndThrowOnMutationInDev } from "../Libraries/Utilities/deepFreezeAndThrowOnMutationInDev";
 export { default as flattenStyle } from "../Libraries/StyleSheet/flattenStyle";