@symbiote-native/engine 1.2.0 → 1.3.0

package/android/CMakeLists.txt

@@ -26,6 +26,19 @@ add_library(symbiote_engine
 # So the JNI shim can say `#include "SymbioteEngineBindings.h"` rather than walk four levels up.
 target_include_directories(symbiote_engine PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../cpp)
 
+# `measure` / `measureInWindow` / `measureLayout` need `react/renderer/dom/DOM.h`. libreactnative.so
+# EXPORTS `facebook::react::dom::measure*`, but the prefab ships no `dom/` headers, so without this
+# SymbioteTree.cpp's `__has_include` compiles the throwing stubs. Only that one header is copied into
+# a private root: putting all of ReactCommon on the path would shadow the prefab's own headers.
+set(SYMBIOTE_RN_DOM_HEADER ${REACT_NATIVE_DIR}/ReactCommon/react/renderer/dom/DOM.h)
+if(DEFINED REACT_NATIVE_DIR AND EXISTS ${SYMBIOTE_RN_DOM_HEADER})
+  set(SYMBIOTE_RN_DOM_ROOT ${CMAKE_CURRENT_BINARY_DIR}/rn-dom-include)
+  file(COPY ${SYMBIOTE_RN_DOM_HEADER} DESTINATION ${SYMBIOTE_RN_DOM_ROOT}/react/renderer/dom)
+  target_include_directories(symbiote_engine PRIVATE ${SYMBIOTE_RN_DOM_ROOT})
+else()
+  message(WARNING "symbiote_engine: ${SYMBIOTE_RN_DOM_HEADER} not found, measure* will throw")
+endif()
+
 set_target_properties(symbiote_engine PROPERTIES
         CXX_STANDARD 20
         CXX_STANDARD_REQUIRED ON
@@ -33,13 +46,30 @@ set_target_properties(symbiote_engine PROPERTIES
         POSITION_INDEPENDENT_CODE ON
 )
 
-target_compile_definitions(symbiote_engine PRIVATE -DFOLLY_NO_CONFIG=1)
+# Must match the flags libreactnative.so's folly was built with
+# (ReactAndroid/cmake-utils/folly-flags.cmake). FOLLY_MOBILE is ABI, not tuning: without it arm64
+# picks the SIMD F14 layout while RN's folly is the fallback one, and the link fails on
+# `folly::f14::detail::F14LinkCheck<1>::check()` / `tlsPendingSafeInserts` from any folly::dynamic.
+target_compile_definitions(symbiote_engine PRIVATE
+        -DFOLLY_NO_CONFIG=1
+        -DFOLLY_HAVE_CLOCK_GETTIME=1
+        -DFOLLY_USE_LIBCPP=1
+        -DFOLLY_CFG_NO_COROUTINES=1
+        -DFOLLY_MOBILE=1
+        -DFOLLY_HAVE_RECVMMSG=1
+        -DFOLLY_HAVE_PTHREAD=1
+        -DFOLLY_HAVE_XSI_STRERROR_R=1
+)
 
 # `jsi` and `reactnative` are the only two prefab modules ReactAndroid publishes
 # (ReactAndroid/build.gradle.kts, the `prefab { }` block — the third is `hermestooling`).
 # `reactnative` is the merged library that carries react/renderer/uimanager, react/renderer/mounting
 # and the turbomodule JNI headers our C++ includes; there is no separate
 # `react_renderer_uimanager` prefab target to link.
+# 16 KB page-size devices (Android 15+) refuse a 4 KB-aligned LOAD segment and drop the whole app
+# into compat mode. NDK r27 still links 4 KB by default; RN's own libraries already ship 16 KB.
+target_link_options(symbiote_engine PRIVATE -Wl,-z,max-page-size=16384)
+
 find_package(ReactAndroid REQUIRED CONFIG)
 find_package(fbjni REQUIRED CONFIG)
 

package/android/build.gradle

@@ -37,7 +37,10 @@ android {
 
     externalNativeBuild {
       cmake {
-        arguments "-DANDROID_STL=c++_shared"
+        // REACT_NATIVE_DIR: the app's own react-native (the plugin's `reactNativeDir`), so CMake can
+        // reach the one ReactCommon header the prefab does not ship (see CMakeLists.txt).
+        arguments "-DANDROID_STL=c++_shared",
+            "-DREACT_NATIVE_DIR=${project.extensions.getByName('react').reactNativeDir.get().asFile.absolutePath}"
       }
     }
   }

package/build/accessibility-info/index.android.js

@@ -9,6 +9,7 @@
 import { createDeviceEventModule } from '../native-modules/index.js';
 import {} from '../native-events.js';
 import { dlog } from '../debug.js';
+import { sendAccessibilityEventByTag } from '../fabric.js';
 import { isBoolean, routeSendAccessibilityEvent, } from './shared.js';
 // The Android native module name. This is the module the Android JS wrapper
 // (INativeAccessibilityInfoAndroid) resolves: the stock RN `AccessibilityInfo` Turbo/legacy
@@ -19,6 +20,8 @@ const ACCESSIBILITY_MODULE = 'AccessibilityInfo';
 // most of them; events with no Android source (iOS-only) are absent and yield an inert
 // subscription. (RN maps both `change` and `screenReaderChanged` to touchExplorationDidChange.)
 const ANDROID_DEVICE_EVENT = {
+    // RN's deprecated alias (AccessibilityInfo.js EventNames).
+    change: 'touchExplorationDidChange',
     screenReaderChanged: 'touchExplorationDidChange',
     reduceMotionChanged: 'reduceMotionDidChange',
     highTextContrastChanged: 'highTextContrastDidChange',
@@ -39,19 +42,18 @@ function getModule() {
 function getEmitter() {
     return deviceEventModule.getEmitter();
 }
-// Run a single-callback Android getter as a Promise. Resolves false when the module is
-// unlinked OR the optional method is absent on this host; mirrors RN's "missing query ->
-// false" contract for the cross-platform getters. The dlog records the miss.
-function queryState(pick, label) {
+const MODULE_UNAVAILABLE = 'NativeAccessibilityInfoAndroid is not available';
+// Run a single-callback Android getter as a Promise, REJECTING when it cannot run, as RN does
+// (AccessibilityInfo.js): a required getter names the module, an optional one names itself.
+function queryState(pick, label, isOptional = false) {
     const module = getModule();
-    if (module === null) {
-        dlog(`AccessibilityInfo(android).${label} -> no module (false)`);
-        return Promise.resolve(false);
-    }
-    const getter = pick(module);
-    if (getter === undefined) {
-        dlog(`AccessibilityInfo(android).${label} -> method absent (false)`);
-        return Promise.resolve(false);
+    const getter = module === null ? undefined : pick(module);
+    if (module === null || getter === undefined) {
+        const message = isOptional
+            ? `NativeAccessibilityInfoAndroid.${label} is not available`
+            : MODULE_UNAVAILABLE;
+        dlog(`AccessibilityInfo(android).${label} -> rejected: ${message}`);
+        return Promise.reject(new Error(message));
     }
     return new Promise(resolve => {
         getter.call(module, enabled => resolve(enabled));
@@ -70,17 +72,17 @@ class AccessibilityInfoAndroid {
         return Promise.resolve(false);
     }
     isGrayscaleEnabled() {
-        return queryState(m => m.isGrayscaleEnabled, 'isGrayscaleEnabled');
+        return queryState(m => m.isGrayscaleEnabled, 'isGrayscaleEnabled', true);
     }
     isInvertColorsEnabled() {
-        return queryState(m => m.isInvertColorsEnabled, 'isInvertColorsEnabled');
+        return queryState(m => m.isInvertColorsEnabled, 'isInvertColorsEnabled', true);
     }
     // iOS-only query; resolve false (RN parity).
     isReduceTransparencyEnabled() {
         return Promise.resolve(false);
     }
     isHighTextContrastEnabled() {
-        return queryState(m => m.isHighTextContrastEnabled, 'isHighTextContrastEnabled');
+        return queryState(m => m.isHighTextContrastEnabled, 'isHighTextContrastEnabled', true);
     }
     // iOS-only "Increase Contrast"; Android has no equivalent, so resolve false (RN parity).
     isDarkerSystemColorsEnabled() {
@@ -91,7 +93,7 @@ class AccessibilityInfoAndroid {
         return Promise.resolve(false);
     }
     isAccessibilityServiceEnabled() {
-        return queryState(m => m.isAccessibilityServiceEnabled, 'isAccessibilityServiceEnabled');
+        return queryState(m => m.isAccessibilityServiceEnabled, 'isAccessibilityServiceEnabled', true);
     }
     // Post a string to be announced by the screen reader. No-op without a module.
     announceForAccessibility(announcement) {
@@ -111,8 +113,10 @@ class AccessibilityInfoAndroid {
     // bare reactTag can't be resolved back to its SymbioteNode (the mirror is node-keyed), so
     // this best-effort path is a logged no-op. Callers should use sendAccessibilityEvent(node,
     // 'focus') with a host ref, which routes a real node through the slot.
+    // RN: legacySendAccessibilityEvent(tag, 'focus') -> bridgeless UIManager resolves the tag.
     setAccessibilityFocus(reactTag) {
-        dlog(`AccessibilityInfo(android).setAccessibilityFocus(${reactTag}) -> tag-only, no node to route (no-op)`);
+        dlog(`AccessibilityInfo(android).setAccessibilityFocus(${reactTag})`);
+        sendAccessibilityEventByTag(reactTag, 'focus');
     }
     // Recommended UI-change timeout for this user. Resolves the original when the module or
     // the query is absent (RN parity).

package/build/accessibility-info/index.ios.js

@@ -19,6 +19,8 @@ const ACCESSIBILITY_MODULE = 'AccessibilityManager';
 // Public event name -> the iOS device event the native side emits. iOS keeps the names
 // 1:1; the indirection exists only so the mapping stays explicit (Android renames them).
 const IOS_DEVICE_EVENT = {
+    // RN's deprecated alias (AccessibilityInfo.js EventNames).
+    change: 'screenReaderChanged',
     screenReaderChanged: 'screenReaderChanged',
     reduceMotionChanged: 'reduceMotionChanged',
     boldTextChanged: 'boldTextChanged',

package/build/accessibility-info/shared.d.ts

@@ -1,7 +1,7 @@
 import { type ISymbioteNode } from '../node';
 import type { IEventSubscription } from '../native-events';
 export { isBoolean } from '../type-guards';
-export type IAccessibilityChangeEventName = 'screenReaderChanged' | 'reduceMotionChanged' | 'boldTextChanged' | 'grayscaleChanged' | 'invertColorsChanged' | 'reduceTransparencyChanged' | 'darkerSystemColorsChanged' | 'announcementFinished' | 'accessibilityServiceChanged' | 'highTextContrastChanged';
+export type IAccessibilityChangeEventName = 'change' | 'screenReaderChanged' | 'reduceMotionChanged' | 'boldTextChanged' | 'grayscaleChanged' | 'invertColorsChanged' | 'reduceTransparencyChanged' | 'darkerSystemColorsChanged' | 'announcementFinished' | 'accessibilityServiceChanged' | 'highTextContrastChanged';
 export type IAccessibilityChangeEvent = IAccessibilityChangeEventName;
 export type IAccessibilityHandle = ISymbioteNode | number | null | undefined;
 export interface IAccessibilityAnnouncementFinishedEvent {

package/build/alert/shared.d.ts

@@ -16,4 +16,4 @@ export interface IAlertStatic {
     alert(title?: string, message?: string, buttons?: IAlertButtons, options?: IAlertOptions): void;
 }
 export declare const DEFAULT_POSITIVE_TEXT = "OK";
-export declare function normalizeButtons(buttons?: IAlertButtons): IAlertButtons;
+export declare function normalizeButtons(buttons?: IAlertButtons | null): IAlertButtons;

package/build/alert/shared.js

@@ -6,12 +6,8 @@
 // a factory. No native, no `Platform.OS` read here.
 // The default positive label RN uses when a button carries no text.
 export const DEFAULT_POSITIVE_TEXT = 'OK';
-// Normalize the `buttons` arg into a consistent list: undefined/empty becomes a single
-// default "OK" button, exactly as RN does before handing the list to native. Both
-// platform files start from this so the no-buttons case behaves identically.
+// Android's `buttons ? buttons : [{text: 'OK'}]` (Alert.js): only an ABSENT list gets the default
+// OK. An explicit empty array is a dialog with no buttons.
 export function normalizeButtons(buttons) {
-    if (buttons === undefined || buttons.length === 0) {
-        return [{ text: DEFAULT_POSITIVE_TEXT }];
-    }
-    return buttons;
+    return buttons ?? [{ text: DEFAULT_POSITIVE_TEXT }];
 }

package/build/app-state/index.d.ts

@@ -9,7 +9,7 @@ export type IAppStateStatus = 'inactive' | 'background' | 'active' | 'extension'
 export type IAppStateEvent = (typeof APP_STATE_EVENT)[keyof typeof APP_STATE_EVENT];
 declare class AppStateImpl {
     get isAvailable(): boolean;
-    get currentState(): string | null;
+    get currentState(): string | null | undefined;
     addEventListener(type: IAppStateEvent, handler: (...args: unknown[]) => void): IEventSubscription;
 }
 export declare const AppState: AppStateImpl;

package/build/app-state/index.js

@@ -24,30 +24,39 @@ const APP_STATE_EVENT = {
     focus: 'focus',
     blur: 'blur',
 };
-function isStateChangePayload(value) {
-    return typeof value === 'object' && value !== null && 'app_state' in value;
+// `appStateData.app_state`, read the way RN reads it: no shape check, `undefined` when absent,
+// and a TypeError on a null payload as the property read would throw.
+function appStateOf(payload) {
+    if (payload === null || payload === undefined) {
+        throw new TypeError(`Cannot read property 'app_state' of ${String(payload)}`);
+    }
+    const state = Reflect.get(Object(payload), 'app_state');
+    return typeof state === 'string' ? state : undefined;
 }
-// Lazily resolved so importing this module has no native side effect: a headless
-// run without a fake __turboModuleProxy still loads it; resolution happens on first
-// use. `null` when the module isn't linked.
+// `null` until the module resolves (or when it is not linked), as RN's field starts.
 let currentState = null;
-// The self-subscription policy that diverges from a plain lazy-resolve+emitter:
-// AppState hydrates `currentState` from the module's initial constants, then keeps it
-// fresh forever via a permanent 'appStateDidChange' listener, so a read after a native
-// change returns the new value even with nobody else listening (RN parity).
+// AppState.js's constructor, run once when the emitter is built: seed from the constant, keep it
+// fresh from 'appStateDidChange', and ask native for the live state — which wins, and is
+// re-emitted to listeners, unless an event arrived first.
 const deviceEventModule = createDeviceEventModule({
     moduleName: APP_STATE_MODULE,
     moduleLogPrefix: 'AppState: module',
     onEmitterCreated: (emitter, module) => {
-        if (module !== null) {
-            currentState = module.getConstants().initialAppState;
-        }
+        if (module === null)
+            return;
+        currentState = module.getConstants().initialAppState;
+        let eventUpdated = false;
         emitter.addListener(NATIVE_EVENT.stateDidChange, payload => {
-            if (!isStateChangePayload(payload))
-                return;
-            dlog(`AppState: ${NATIVE_EVENT.stateDidChange} -> ${payload.app_state}`);
-            currentState = payload.app_state;
+            eventUpdated = true;
+            currentState = appStateOf(payload);
+            dlog(`AppState: ${NATIVE_EVENT.stateDidChange} -> ${String(currentState)}`);
         });
+        module.getCurrentAppState(data => {
+            if (!eventUpdated && currentState !== data.app_state) {
+                currentState = data.app_state;
+                emitter.emit(NATIVE_EVENT.stateDidChange, data);
+            }
+        }, error => dlog(`AppState.getCurrentAppState failed: ${String(error)}`));
     },
 });
 function getModule() {
@@ -68,33 +77,32 @@ class AppStateImpl {
         getEmitter();
         return currentState;
     }
-    // Subscribe to an AppState event. Native delivers `appStateDidChange`,
-    // `memoryWarning`, and `appStateFocusChange`; this maps each onto the requested
-    // public event. Never throws; a missing module yields a live-but-silent
-    // subscription (the counters are no-ops without a module).
+    // Subscribe to an AppState event, mapped onto the native `appStateDidChange` /
+    // `memoryWarning` / `appStateFocusChange`. Throws, as RN does, without a module or for an
+    // event it does not know.
     addEventListener(type, handler) {
+        if (getModule() === null) {
+            throw new Error('Cannot use AppState when `isAvailable` is false.');
+        }
         const eventEmitter = getEmitter();
         dlog(`AppState.addEventListener -> ${type}`);
         switch (type) {
             case APP_STATE_EVENT.change:
-                return eventEmitter.addListener(NATIVE_EVENT.stateDidChange, payload => {
-                    if (!isStateChangePayload(payload))
-                        return;
-                    handler(payload.app_state);
-                });
+                return eventEmitter.addListener(NATIVE_EVENT.stateDidChange, payload => handler(appStateOf(payload)));
             case APP_STATE_EVENT.memoryWarning:
                 return eventEmitter.addListener(NATIVE_EVENT.memoryWarning, () => handler());
             case APP_STATE_EVENT.focus:
                 return eventEmitter.addListener(NATIVE_EVENT.focusChange, hasFocus => {
-                    if (hasFocus === true)
+                    if (hasFocus)
                         handler();
                 });
             case APP_STATE_EVENT.blur:
                 return eventEmitter.addListener(NATIVE_EVENT.focusChange, hasFocus => {
-                    if (hasFocus === false)
+                    if (!hasFocus)
                         handler();
                 });
         }
+        throw new Error(`Trying to subscribe to unknown event: ${String(type)}`);
     }
 }
 export const AppState = new AppStateImpl();

package/build/back-handler/index.d.ts

@@ -1,14 +1,19 @@
 import { type IEventSubscription } from '../native-events';
+declare const DEVICE_BACK_EVENT = "hardwareBackPress";
 declare const BACK_PRESS_EVENT: {
     readonly backPress: "backPress";
     readonly hardwareBackPress: "hardwareBackPress";
 };
 export type IBackPressEventName = (typeof BACK_PRESS_EVENT)[keyof typeof BACK_PRESS_EVENT];
-export type IBackPressHandler = () => boolean | null | undefined | void;
+export type IHardwareBackPressEvent = {
+    readonly type: typeof DEVICE_BACK_EVENT;
+    readonly timeStamp: number;
+};
+export type IBackPressHandler = (event: IHardwareBackPressEvent) => boolean | null | undefined | void;
 declare class BackHandlerImpl {
     exitApp(): void;
     addEventListener(_eventName: IBackPressEventName, handler: IBackPressHandler): IEventSubscription;
-    removeEventListener(_eventName: IBackPressEventName, handler: IBackPressHandler): void;
 }
 export declare const BackHandler: BackHandlerImpl;
+export declare function installBackHandler(): void;
 export {};

package/build/back-handler/index.js

@@ -23,6 +23,12 @@ const BACK_PRESS_EVENT = {
     backPress: 'backPress',
     hardwareBackPress: 'hardwareBackPress',
 };
+function nativeTimeStamp(nativeEvent) {
+    if (typeof nativeEvent !== 'object' || nativeEvent === null)
+        return undefined;
+    const timeStamp = Reflect.get(nativeEvent, 'timeStamp');
+    return typeof timeStamp === 'number' ? timeStamp : undefined;
+}
 // The registry, in registration order. Invoked in reverse on a back press.
 const backPressSubscriptions = [];
 function isHandled(result) {
@@ -50,10 +56,14 @@ function getEmitter() {
 }
 // Run handlers last-registered-first; the first to return true consumes the press
 // and the rest are skipped. If none consume it, fall through to the native default.
-function dispatchBackPress() {
+function dispatchBackPress(nativeEvent) {
+    const event = {
+        type: DEVICE_BACK_EVENT,
+        timeStamp: nativeTimeStamp(nativeEvent) ?? performance.now(),
+    };
     for (let i = backPressSubscriptions.length - 1; i >= 0; i--) {
         const handler = backPressSubscriptions[i];
-        if (handler !== undefined && isHandled(handler())) {
+        if (handler !== undefined && isHandled(handler(event))) {
             dlog(`BackHandler: back press consumed by handler ${i}`);
             return;
         }
@@ -90,13 +100,12 @@ class BackHandlerImpl {
             },
         };
     }
-    // Legacy unsubscribe kept for RN parity. The modern path is the subscription's
-    // remove() returned by addEventListener.
-    removeEventListener(_eventName, handler) {
-        const index = backPressSubscriptions.indexOf(handler);
-        if (index !== -1) {
-            backPressSubscriptions.splice(index, 1);
-        }
-    }
 }
 export const BackHandler = new BackHandlerImpl();
+// Subscribes to `hardwareBackPress` up front, as RN does when BackHandler.android.js loads: Android
+// exits only when JS answers the event with invokeDefaultBackPressHandler, so an app with no handler
+// of its own would otherwise have a dead back button. Called by the host bootstrap, not at module
+// load — a barrel-reached module's load-time side effect does not run in a release bundle.
+export function installBackHandler() {
+    getEmitter();
+}

package/build/events/index.js

@@ -380,8 +380,13 @@ export function installEventHandler() {
         if (topLevelType === TOUCH_START) {
             // The ternary is gone with the gate: `isSymbioteNode(instanceHandle)` was re-asked here
             // three lines after the early return above already proved it.
-            if (isDebug())
+            if (isDebug()) {
                 dlog(`event ${TOUCH_START} on ${instanceHandle.component}`);
+                // A responder surviving into a one-touch start lost its end/cancel. If it is an ancestor
+                // of the target, this whole tap goes to it and the release finally clears it.
+                if (currentResponder !== undefined)
+                    dlog(`touchStart while ${currentResponder.component} still holds the responder`);
+            }
             // Update the touch bank, then attach it so responder handlers (PanResponder)
             // read each touch's own previous->current delta; RN records before dispatch.
             recordTouchTrack('start', nativeEvent);
@@ -519,6 +524,10 @@ export function installEventHandler() {
             return;
         }
         if (topLevelType === TOUCH_CANCEL) {
+            // Android: a ScrollView whose scroller has not finished (fling tail, spring-back) intercepts
+            // the next down natively, and the tap reaches JS as start + cancel with no press.
+            if (isDebug())
+                dlog(`event ${TOUCH_CANCEL} on ${instanceHandle.component}`);
             recordTouchTrack('end', nativeEvent);
             attachTouchHistory(nativeEvent);
             // A cancel is scoped to the finger(s) removed from `touches`, just like an end. An unrelated

package/build/fabric-props.js

@@ -29,7 +29,7 @@
 // What is left is the framework-agnostic half: colour processing, the style hoist, and a node's own
 // `payloadFold`.
 import { RAW_TEXT_COMPONENT } from './node.js';
-import { isProcessableColor, processColor } from './platform-color/index.js';
+import { isProcessableColor, processColor } from './platform-color';
 import { configProcessedKeys } from './registry.js';
 import { isRecord } from './type-guards.js';
 // Color props must reach Fabric as platform ints, not CSS strings. Fabric's C++

package/build/fabric.d.ts

@@ -32,7 +32,14 @@ interface IFabricHost extends Omit<IFabricSlot, 'cloneNodeWithNewChildren' | 'cl
     cloneNodeWithNewChildren(node: IFabricNode, children?: readonly IFabricNode[]): IFabricNode;
     cloneNodeWithNewChildrenAndProps(node: IFabricNode, newProps: IFabricProps): IFabricNode;
     cloneNodeWithNewChildrenAndProps(node: IFabricNode, children: readonly IFabricNode[], newProps: IFabricProps): IFabricNode;
+    findShadowNodeByTag_DEPRECATED?(tag: number): IFabricNode | null;
 }
+/**
+ * An accessibility event addressed by a bare native TAG, the way RN's bridgeless
+ * `UIManager.sendAccessibilityEvent` does it: resolve the tag to its committed shadow node, then send.
+ * An unknown tag is dropped, as RN drops it (with a log rather than a throw).
+ */
+export declare function sendAccessibilityEventByTag(tag: number, eventType: string): void;
 declare global {
     var nativeFabricUIManager: IFabricHost | undefined;
 }

package/build/fabric.js

@@ -6,6 +6,20 @@
 // host function, so we read each method once and cache a plain facade.
 import { dlog } from './debug.js';
 import { installNativeTreeHost } from './native-tree-host.js';
+/**
+ * An accessibility event addressed by a bare native TAG, the way RN's bridgeless
+ * `UIManager.sendAccessibilityEvent` does it: resolve the tag to its committed shadow node, then send.
+ * An unknown tag is dropped, as RN drops it (with a log rather than a throw).
+ */
+export function sendAccessibilityEventByTag(tag, eventType) {
+    const host = globalThis.nativeFabricUIManager;
+    const node = host?.findShadowNodeByTag_DEPRECATED?.(tag);
+    if (host === undefined || node === undefined || node === null) {
+        dlog(`sendAccessibilityEvent("${eventType}") dropped: no view with tag #${tag}`);
+        return;
+    }
+    host.sendAccessibilityEvent(node, eventType);
+}
 let cached;
 // BATCHING IS GONE, and it is worth one paragraph because the idea recurs. `batching-slot.ts`
 // recorded this slot's calls and replayed them once per commit — three ways, the last handing the

package/build/host-behavior.d.ts

@@ -22,6 +22,7 @@ export interface IHostBehavior {
     readonly ownedListeners?: readonly string[];
     readonly slotProps?: Readonly<Record<string, string>>;
     readonly slotPropsExcept?: readonly string[];
+    readonly slotValueFor?: (slotKey: string, value: unknown) => unknown;
     readonly slotTakesNoChildren?: boolean;
     readonly slotDerived?: readonly string[];
     readonly claimedChildren?: Readonly<Record<string, IClaimMode>>;

package/build/image-loader.d.ts

@@ -6,8 +6,10 @@ export type IImageSize = {
 export type IImageCacheStatus = 'memory' | 'disk' | 'disk/memory';
 type ISizeSuccess = (width: number, height: number) => void;
 type ISizeFailure = (error: unknown) => void;
-declare function getSize(uri: string, success?: ISizeSuccess, failure?: ISizeFailure): Promise<IImageSize>;
-declare function getSizeWithHeaders(uri: string, headers: Record<string, string>, success?: ISizeSuccess, failure?: ISizeFailure): Promise<IImageSize>;
+declare function getSize(uri: string): Promise<IImageSize>;
+declare function getSize(uri: string, success: ISizeSuccess, failure?: ISizeFailure): undefined;
+declare function getSizeWithHeaders(uri: string, headers: Record<string, string>): Promise<IImageSize>;
+declare function getSizeWithHeaders(uri: string, headers: Record<string, string>, success: ISizeSuccess, failure?: ISizeFailure): undefined;
 declare function prefetch(uri: string, callback?: (requestId: number) => void): Promise<boolean>;
 declare function abortPrefetch(requestId: number): void;
 declare function queryCache(uris: string[]): Promise<Record<string, IImageCacheStatus>>;

package/build/image-loader.js

@@ -54,40 +54,29 @@ function requireLoader(method) {
     }
     return loader;
 }
-// Resolve image dimensions, optionally via success/failure callbacks. Always returns the Promise
-// too (RN returns void when a callback is passed, but a promise-and-callback shape is friendlier
-// and a strict superset).
+// Image.ios.js / Image.android.js: the promise when no success callback is given; otherwise the
+// result goes to the callbacks and nothing is returned, a missing `failure` becoming a warning.
+function deliverSize(promise, uri, success, failure) {
+    if (typeof success !== 'function')
+        return promise;
+    promise
+        .then(size => success(size.width, size.height))
+        .catch(typeof failure === 'function'
+        ? failure
+        : () => console.warn('Failed to get size for image: ' + uri));
+    return undefined;
+}
 function getSize(uri, success, failure) {
     const promise = Promise.resolve()
         .then(() => requireLoader('getSize').getSize(uri))
         .then(toImageSize);
-    if (typeof success === 'function') {
-        promise
-            .then(size => success(size.width, size.height))
-            .catch((error) => {
-            if (typeof failure === 'function')
-                failure(error);
-            else
-                dlog(`Image.getSize failed for ${uri}: ${String(error)}`);
-        });
-    }
-    return promise;
+    return deliverSize(promise, uri, success, failure);
 }
 function getSizeWithHeaders(uri, headers, success, failure) {
     const promise = Promise.resolve()
         .then(() => requireLoader('getSizeWithHeaders').getSizeWithHeaders(uri, headers))
         .then(toImageSize);
-    if (typeof success === 'function') {
-        promise
-            .then(size => success(size.width, size.height))
-            .catch((error) => {
-            if (typeof failure === 'function')
-                failure(error);
-            else
-                dlog(`Image.getSizeWithHeaders failed for ${uri}: ${String(error)}`);
-        });
-    }
-    return promise;
+    return deliverSize(promise, uri, success, failure);
 }
 // Android keys an in-flight prefetch by a monotonic requestId (so abortRequest can cancel it);
 // RN's Image.android.js generates the same way. iOS ignores the arg.

package/build/image-source-write.d.ts

@@ -10,7 +10,7 @@ export declare const IMAGE_SOURCE_PROPS: ReadonlySet<string>;
  * whatever it is handed, and a tag with no image behavior must keep its props verbatim — the
  * control case in `image-payload.itest.ts` is what holds that line.
  */
-export declare function resolveImageSourceProp(value: unknown): unknown;
+export declare function resolveImageSourceProp(value: unknown, dropsSingleSourceHeaders?: boolean): unknown;
 export declare const IMAGE_LOAD_EVENT_NAMES: ReadonlySet<string>;
 /** Whether at least one of the four still has a listener installed on the node. */
 export declare function anyImageLoadEventListenerWired(listeners: ReadonlyMap<string, unknown> | undefined): boolean;

package/build/image-source-write.js

@@ -30,13 +30,25 @@ export const IMAGE_SOURCE_PROPS = new Set([
  * whatever it is handed, and a tag with no image behavior must keep its props verbatim — the
  * control case in `image-payload.itest.ts` is what holds that line.
  */
-export function resolveImageSourceProp(value) {
+export function resolveImageSourceProp(value, dropsSingleSourceHeaders = false) {
     if (value === undefined || value === null)
         return value;
     if (typeof value !== 'number' && typeof value !== 'object')
         return value;
     const resolved = resolveImageSource(value);
-    return Array.isArray(resolved) ? resolved : [resolved];
+    if (Array.isArray(resolved))
+        return resolved;
+    // Android `source` only: `Image.android.js` lifts headers to the native `headers` prop just for an
+    // ARRAY source, and ReactImageView ignores per-source headers, so RN sends none for a single
+    // object. Wrapping here erases that shape, so its headers go here too.
+    if (dropsSingleSourceHeaders &&
+        typeof resolved === 'object' &&
+        resolved !== null &&
+        'headers' in resolved) {
+        const { headers: _dropped, ...rest } = resolved;
+        return [rest];
+    }
+    return [resolved];
 }
 // `ReactImageView.setShouldNotifyLoadEvents` (Android) — `downloadListener` stays `null`, and
 // none of these four ever fires, until this prop is `true`. `Image.android.js` sets it whenever

package/build/index.d.ts

@@ -90,8 +90,8 @@ export type { IKeyboardEventName, IKeyboardEvent, IKeyboardMetrics, } from './ke
 export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, focusTextInput, } from './text-input-state';
 export { LayoutAnimation } from './layout-animation';
 export type { ILayoutAnimationType, ILayoutAnimationProperty, ILayoutAnimationConfig, ILayoutAnimationAnim, ILayoutAnimationTypes, ILayoutAnimationProperties, } from './layout-animation';
-export { BackHandler } from './back-handler';
-export type { IBackPressEventName, IBackPressHandler } from './back-handler';
+export { BackHandler, installBackHandler } from './back-handler';
+export type { IBackPressEventName, IBackPressHandler, IHardwareBackPressEvent, } from './back-handler';
 export { PermissionsAndroid, PERMISSIONS, RESULTS, } from './permissions-android';
 export type { IPermission, IPermissionStatus, IRationale, } from './permissions-android';
 export { AccessibilityInfo } from './accessibility-info';