@symbiote-native/engine 1.2.0 → 1.3.1

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/accessibility-props.d.ts

@@ -1,13 +1,2 @@
 export declare const ARIA_ALIAS_KEYS: readonly ["role", "aria-label", "aria-labelledby", "aria-live", "aria-hidden", "aria-busy", "aria-checked", "aria-disabled", "aria-expanded", "aria-selected", "aria-modal", "aria-valuemax", "aria-valuemin", "aria-valuenow", "aria-valuetext"];
-/**
- * Fold the web-alias `aria-*` / `role` props into RN's canonical `accessibility*` props.
- *
- * Returns the input BY IDENTITY when no alias is present — the fast path that keeps this off the
- * hot path for the ~99% of nodes carrying none, and the property idempotence rests on: pass 1
- * blanks every alias, so a second pass finds nothing and returns by identity again.
- *
- * The alias keys are blanked to `undefined` rather than deleted. That is not laziness: `setProp`
- * treats an `undefined` write as a delete and `fabricProps` skips undefined, so a blanked alias
- * cannot reach Fabric, while a `delete` would deoptimise the object's shape on every folded node.
- */
 export declare function foldAriaProps(props: Record<string, unknown>): Record<string, unknown>;

package/build/accessibility-props.js

@@ -1,27 +1,14 @@
-// RN's `aria-*` / `role` -> `accessibility*` fold, at the layer every path goes through.
-//
-// WHY IT IS HERE AND NOT IN A WRAPPER. It used to run inside each primitive's COMPONENT, and a tag
-// has none. It also cannot run per attribute — `aria-checked` has to be folded against a sibling
-// `accessibilityState` — so it belongs at the one point where the whole bag is known, which is the
-// payload build.
-//
-// IT IS A MOVE, NOT A REWRITE, AND THAT IS DELIBERATE. The function carries TWO CONTRADICTORY
-// PRECEDENCE RULES: for the scalars an explicit `accessibility*` WINS and the alias only fills a
-// hole (`if (next.X === undefined)`), while INSIDE the `accessibilityState` / `accessibilityValue`
-// composites the ALIAS wins per field (`ariaBusy ?? existing?.busy`). Both mirror RN's View.js.
-// Anyone "cleaning this up" collapses them into one rule, and every component test stays green
-// while real accessibility silently changes. `core/components/src/accessibility-props.test.ts`
-// pins both directions; read it before touching the branches below.
-//
-// Record-level rather than typed, because the engine's caller has a raw `node.props` bag and an
-// interface is not assignable to `Record<string, unknown>` (no index signature). The typed
-// `resolveAccessibilityProps<T>` in `core/components` stays where adapters already import it and
-// delegates here, keeping its own typed gate so the fast path allocates nothing.
+// RN's aria-* / role -> accessibility* fold, at the layer every path goes through: it can't run
+// per attribute (aria-checked folds against a sibling accessibilityState), so it belongs at the
+// one point where the whole bag is known, the payload build.
+// A move, not a rewrite: the function carries two contradictory precedence rules — scalars let an
+// explicit accessibility* win, alias only fills a hole; the composites let the alias win per field
+// instead. Both mirror RN's View.js. accessibility-props.test.ts pins both directions.
+// Record-level rather than typed: the engine's caller has a raw node.props bag with no index
+// signature. The typed resolveAccessibilityProps<T> in core/components delegates here.
 import { dlog } from './debug.js';
-// Copied line for line from the wrapper this replaces. The first copy silently dropped five
-// entries (`button`, `grid`, `link`, `list`, `listitem`) — a role that falls through simply passes
-// unmapped, so `role="listitem"` would have reached Fabric as `listitem` instead of `list` with
-// nothing red anywhere. Diff this against RN's View.js rather than reading it for plausibility.
+// A role that falls through here passes unmapped, reaching Fabric under the wrong name with
+// nothing red anywhere. Diff against RN's View.js, don't just read for plausibility.
 const ROLE_TO_ACCESSIBILITY_ROLE = {
     alert: 'alert',
     button: 'button',
@@ -52,14 +39,11 @@ const ROLE_TO_ACCESSIBILITY_ROLE = {
     timer: 'timer',
     toolbar: 'toolbar',
 };
-// Exported so a behavior that folds a DIFFERENT node's bag can name them without restating the
-// list. `slotDerived` (host-behavior.ts) takes prop NAMES, so a primitive whose payload derives
-// from an owner's aria props has to enumerate them — and a second hand-written copy is exactly what
-// `.claude/rules/adapter-parity-audit.md` records going stale one member at a time.
-// `as const` rather than `readonly string[]`, so the members are LITERALS. That is what lets a
-// consumer index a prop type with them — `pickAccessibilityProps` in the Svelte adapter forwards the
-// aria half by looping this list — and it makes the two sides check each other: a name here that is
-// not a key of `IAriaProps` stops compiling at the use site rather than going quietly unforwarded.
+// Exported so a behavior folding a different node's bag can name these without restating the
+// list — slotDerived (host-behavior.ts) takes prop names, so a derived primitive enumerates them.
+// as const rather than readonly string[], so the members are literals: pickAccessibilityProps
+// (Svelte adapter) indexes IAriaProps with them, and a name here not a key of IAriaProps then
+// fails to compile at the use site instead of going quietly unforwarded.
 export const ARIA_ALIAS_KEYS = [
     'role',
     'aria-label',
@@ -86,28 +70,17 @@ function hasAnyAriaKey(props) {
     }
     return false;
 }
-// `isAriaAliasKey` WAS HERE AND IS GONE (2026-09-18). Its whole reason was to maintain
-// `node.hasAriaAlias` from `setProp` — the hottest write path in the engine, 32 001 writes on one
-// benchmark create — and that flag existed only to gate the aria fold inside the headless payload
-// builder. The fold left for `SymbioteFabricProps.cpp`, which recomputes presence from the bag it
-// holds, so the flag became write-only and this function became its only maintainer. Both went.
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
 function fieldOf(source, field) {
     return isRecord(source) ? source[field] : undefined;
 }
-/**
- * Fold the web-alias `aria-*` / `role` props into RN's canonical `accessibility*` props.
- *
- * Returns the input BY IDENTITY when no alias is present — the fast path that keeps this off the
- * hot path for the ~99% of nodes carrying none, and the property idempotence rests on: pass 1
- * blanks every alias, so a second pass finds nothing and returns by identity again.
- *
- * The alias keys are blanked to `undefined` rather than deleted. That is not laziness: `setProp`
- * treats an `undefined` write as a delete and `fabricProps` skips undefined, so a blanked alias
- * cannot reach Fabric, while a `delete` would deoptimise the object's shape on every folded node.
- */
+// Fold the web-alias aria-*/role props into RN's canonical accessibility* props. Returns the input
+// by identity when no alias is present, keeping this off the hot path for nodes carrying none —
+// and idempotent, since pass 1 blanks every alias so a second pass finds nothing.
+// Alias keys are blanked to undefined rather than deleted: setProp treats undefined as a delete
+// and fabricProps skips it, while a real delete would deoptimise the object's shape.
 export function foldAriaProps(props) {
     if (!hasAnyAriaKey(props))
         return props;
@@ -157,27 +130,16 @@ export function foldAriaProps(props) {
     if (typeof role === 'string' && bag.accessibilityRole === undefined) {
         bag.accessibilityRole = ROLE_TO_ACCESSIBILITY_ROLE[role] ?? role;
     }
-    // RULE TWO, INSIDE the composites: the polarity INVERTS and the ALIAS wins per field. Read from
-    // the ORIGINAL props, not from `bag` — the loop above has already blanked the aliases there.
-    //
-    // UPSTREAM-BUG(react-native): View.js:96 is `checked: ariaChecked ?? accessibilityState?.checked`
-    // — NO type coercion. A template writes `aria-checked="true"` as a STRING in every framework we
-    // support, so `accessibilityState.checked` reaches native as `'true'` where the native side
-    // declares `boolean | 'mixed'`. Ported verbatim for parity; do NOT add a cast without recording
-    // a deliberate divergence. Found by the Svelte session 2026-08-31 and pinned as an ASSERTION in
-    // `adapters/svelte/src/aria-fold-parity.test.ts`, so a future decision to coerce shows up as a
-    // failing test at the point the decision was made rather than as a silent behaviour change.
-    //
-    // A SECOND, SMALLER DIVERGENCE, and this one is ours rather than upstream's — it predates the
-    // move down and is kept only because changing it here would be an undeclared behaviour change:
-    // upstream gates the composite on `!= null` (View.js:87-92) and this gates on `!== undefined`.
-    // So an explicit `aria-busy={null}` builds an all-undefined `accessibilityState` here and builds
-    // nothing upstream. The VALUES agree either way — `??` treats null and undefined alike — so only
-    // the composite's existence differs.
-    //
-    // The composite is REPLACED by a fresh literal listing exactly the known fields, so an unknown
-    // field riding on the incoming object is dropped. Faithful to RN and pinned by a test; it is the
-    // shape of bug that only shows for whoever passes a field RN adds later.
+    // Rule two, inside the composites: the polarity inverts and the alias wins per field. Read from
+    // the original props, not bag — the loop above has already blanked the aliases there.
+    // Upstream bug, ported verbatim: RN's View.js does `checked: ariaChecked ?? accessibilityState
+    // ?.checked` with no coercion, so a string "true" reaches native where it declares boolean |
+    // 'mixed'. No cast without recording a divergence (aria-fold-parity.test.ts pins it).
+    // A second, smaller divergence, ours rather than upstream's: upstream gates the composite on
+    // `!= null`, this on `!== undefined`, so `aria-busy={null}` builds an all-undefined
+    // accessibilityState here but nothing upstream — the values agree either way.
+    // The composite is replaced by a fresh literal listing exactly the known fields, so an unknown
+    // field riding on the incoming object is dropped, faithful to RN.
     const existingState = fieldOf(props, 'accessibilityState');
     if (existingState !== undefined ||
         ariaBusy !== undefined ||

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/animated/graph.js

@@ -278,7 +278,7 @@ export function flushValue(rootNode) {
 // in RELEASE builds only (dev was fine, every headless test was fine, and the code was even
 // present in the bundle — it just never ran). Adding a bare `import './interpolation-node'` to
 // the barrel does NOT fix it either: Babel merges that import with the adjacent re-export of the
-// same specifier, and the merged dependency stays lazy. Both were tried on device 2026-08-14.
+// same specifier, and the merged dependency stays lazy. Both were tried on device.
 //
 // Keeping the class next to its base class removes the cycle, the factory, and the entire class
 // of load-order bug with it: `interpolate()` constructs it directly and there is nothing left to

package/build/animated/leaf-lifecycle.js

@@ -7,7 +7,7 @@
 // create-animated-component.tsx, Vue's create-animated-component.ts, Svelte's
 // animated-props-runtime.ts, Angular's animated-leaf-binder.ts). Each re-derived the same policy,
 // and they drifted: only Svelte ever grew the rebuild guard below, after a day of device
-// debugging in 2026-08. React's `useMemo(..., [rest])` LOOKS like the same guard but is not - its
+// debugging. React's `useMemo(..., [rest])` LOOKS like the same guard but is not - its
 // dependency is a fresh rest-destructured object every render - and Vue's `pendingLeaf === null`
 // answers "has render run yet", not "did anything change". A fix landing in one copy is exactly
 // what <adapters_reach_full_feature_parity> forbids: parity has to be structural.
@@ -86,7 +86,7 @@ export function createAnimatedLeafLifecycle(label) {
             lastWantsNative = wantsNative;
             // A SNAPSHOT, never the reference. A caller can legitimately hand back the SAME object on
             // every update, mutating what its keys resolve to rather than allocating (Svelte's rest
-            // proxy does exactly that, device-confirmed 2026-08-13); storing it would make the next
+            // proxy does exactly that, device-confirmed); storing it would make the next
             // call run shallowEqualProps on that object against ITSELF - reading the same current values
             // through both sides - which is unconditionally true. `propsChanged` could then never be
             // true again and reconcile would be skipped forever, so every rebuilt AnimatedInterpolation

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/asset-source-resolver.d.ts

@@ -0,0 +1,2 @@
+export declare function setAssetSourceResolver(resolve: (source: unknown) => unknown): void;
+export declare function resolveAssetSource(source: unknown): unknown;

package/build/asset-source-resolver.js

@@ -0,0 +1,13 @@
+// Generic asset-id resolution seam, the non-Image sibling of image-source-resolver.ts. Kept as a
+// separate file so a non-image consumer (audio's `number` source, sqlite's `assetSource`) never
+// has to import something named "image" to resolve its own assets.
+let sourceResolver = source => source;
+export function setAssetSourceResolver(resolve) {
+    sourceResolver = resolve;
+}
+// Public mirror of image-source-resolver.ts's resolveImageSource, for non-Image consumers of RN's
+// require()'d-asset resolution (audio's `number` source form, sqlite's `assetSource` option).
+// Headless (no resolver wired) it is the identity, so smokes see the input unchanged.
+export function resolveAssetSource(source) {
+    return sourceResolver(source);
+}

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

@@ -1,14 +1,15 @@
 import { type IEventSubscription } from '../native-events';
-declare const BACK_PRESS_EVENT: {
-    readonly backPress: "backPress";
-    readonly hardwareBackPress: "hardwareBackPress";
+declare const DEVICE_BACK_EVENT = "hardwareBackPress";
+export type IBackPressEventName = 'backPress' | 'hardwareBackPress';
+export type IHardwareBackPressEvent = {
+    readonly type: typeof DEVICE_BACK_EVENT;
+    readonly timeStamp: number;
 };
-export type IBackPressEventName = (typeof BACK_PRESS_EVENT)[keyof typeof BACK_PRESS_EVENT];
-export type IBackPressHandler = () => boolean | null | undefined | void;
+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

@@ -17,12 +17,12 @@ import { dlog } from '../debug.js';
 const DEVICE_EVENT_MANAGER_MODULE = 'DeviceEventManager';
 // The device event native emits when the hardware back button is pressed.
 const DEVICE_BACK_EVENT = 'hardwareBackPress';
-// The public event names callers subscribe to. `backPress` is RN's legacy alias
-// for `hardwareBackPress`; both map to the same chain.
-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 +50,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 +94,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();
+}