@symbiote-native/engine 0.1.4 → 0.1.5

package/build/layout-animation/index.js

@@ -9,20 +9,17 @@
 // these in the adapter, not in shared, like Keyboard / StatusBar).
 import { getNativeModule } from '../native-modules.js';
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 // ---- native module routing ----------------------------------------------
-// DEVICE-VERIFY-PENDING: on bridgeless Fabric the layout-animation configure call
-// is exposed by RN through the UIManager surface (RN's non-Fabric path calls
-// `UIManager.configureNextLayoutAnimation`; the Fabric path routes the same args
-// onto `global.nativeFabricUIManager.configureNextLayoutAnimation`). The native
-// MODULE NAME is platform-specific and a headless fake answers to ANY name, so
-// the name below is the most plausible bridgeless candidate, NOT proven. Only the
-// simulator/device resolution log can confirm it; the fallback list is tried in
-// order so a wrong primary still resolves on a real host. Verify on-device before
-// trusting either name. See the `dlog` at the resolution seam below.
-const NATIVE_UI_MANAGER_NAME = {
-    primary: 'UIManager',
-    fallback: 'FabricUIManager',
-};
+// RN's actual dual-path (LayoutAnimation.js): the Fabric global slot
+// (`global.nativeFabricUIManager`, a JSI slot read directly, not a TurboModule
+// lookup) is tried FIRST; only when it lacks `configureNextLayoutAnimation` does
+// RN fall back to the TurboModule `UIManager.configureNextLayoutAnimation`
+// (`TurboModuleRegistry.getEnforcing('UIManager')` in NativeUIManager.js; iOS's
+// RCTUIManager.mm registers under the same bare "UIManager" name via
+// RCT_EXPORT_MODULE()). There is only ONE correct TurboModule name; RN never
+// registers a module under "FabricUIManager".
+const NATIVE_UI_MANAGER_MODULE_NAME = 'UIManager';
 // ---- public type surface (ported from RN's ReactNativeTypes) -------------
 const ANIMATION_TYPE = {
     spring: 'spring',
@@ -38,28 +35,39 @@ const ANIMATION_PROPERTY = {
     scaleY: 'scaleY',
     scaleXY: 'scaleXY',
 };
-// Resolved FRESH on every configureNext, deliberately NOT memoized. The native module can
-// be absent at one moment and linked later, and a cached answer would pin the first result;
-// getNativeModule is a cheap proxy lookup, so per-call resolution costs nothing and stays
-// correct. (Memoizing here also broke the headless smoke, which flips a fake module on/off
-// in one process: a cached module survived the flip-off, so configureNext kept calling native
-// when the module was meant to be absent.)
+// Narrows the Fabric global slot down to whether it ALSO carries the
+// layout-animation hook. `fabric.ts`'s `IFabricSlot` deliberately omits this
+// method (out of scope for the engine's own mutation API), so the slot's static
+// type never has it either; this is the runtime feature-detect RN itself does
+// (`FabricUIManager?.configureNextLayoutAnimation` in LayoutAnimation.js) before
+// calling it, no `as` cast needed.
+function hasConfigureNextLayoutAnimation(value) {
+    return isRecord(value) && typeof value.configureNextLayoutAnimation === 'function';
+}
+// Resolved FRESH on every configureNext, deliberately NOT memoized. Either mechanism can
+// come and go at runtime (the Fabric global installs during bootstrap; a TurboModule can be
+// absent at one moment and linked later), and a cached answer would pin the first result;
+// both lookups are cheap, so per-call resolution costs nothing and stays correct.
+// (Memoizing here also broke the headless smoke, which flips a fake module on/off in one
+// process: a cached module survived the flip-off, so configureNext kept calling native when
+// the module was meant to be absent.)
 function resolveUIManager() {
-    // Try the most plausible bridgeless name first, then fall back. A wrong primary
-    // resolves null on a real host (the bridgeless proxy returns null for an
-    // unlinked name), so the fallback covers a misnamed primary.
-    const candidates = [NATIVE_UI_MANAGER_NAME.primary, NATIVE_UI_MANAGER_NAME.fallback];
-    for (const name of candidates) {
-        const module = getNativeModule(name);
-        if (module !== null) {
-            // DEVICE-VERIFY-PENDING seam: this line on the simulator/device is the only
-            // proof the chosen name is the real one. Keep it permanently (P0 logging gate).
-            dlog(`LayoutAnimation: resolved native UIManager via "${name}"`);
-            return module;
-        }
+    // Mechanism 1: the Fabric global slot, read directly: a JSI global, not a
+    // TurboModule lookup.
+    const fabricUIManager = globalThis.nativeFabricUIManager;
+    if (hasConfigureNextLayoutAnimation(fabricUIManager)) {
+        dlog('LayoutAnimation: resolved native UIManager via the Fabric global slot');
+        return fabricUIManager;
     }
-    dlog(`LayoutAnimation: no native UIManager resolved (tried ${candidates.join(', ')}); ` +
-        `configureNext is a no-op (headless or module not linked)`);
+    // Mechanism 2: the TurboModule fallback (RN's non-Fabric path).
+    const module = getNativeModule(NATIVE_UI_MANAGER_MODULE_NAME);
+    if (module !== null) {
+        dlog(`LayoutAnimation: resolved native UIManager via "${NATIVE_UI_MANAGER_MODULE_NAME}"`);
+        return module;
+    }
+    dlog('LayoutAnimation: no native UIManager resolved (no Fabric global slot, ' +
+        `"${NATIVE_UI_MANAGER_MODULE_NAME}" module not linked); configureNext is a no-op ` +
+        '(headless or module not linked)');
     return null;
 }
 // ---- config builder ------------------------------------------------------
@@ -106,7 +114,7 @@ function setLayoutAnimationEnabled(value) {
 // ---- configureNext -------------------------------------------------------
 // Configures the next commit to be animated. NATIVE drives completion:
 // `onAnimationDidEnd` is passed straight through as the native success callback,
-// so it fires exactly when the native animation actually finishes, including
+// so it fires exactly when the native animation finishes, including
 // when native extends it past `duration` (spring overshoot, OS slowdown,
 // reduce-motion). `onAnimationDidFail` fires only if native config parsing fails.
 // When no native module is linked (headless), this is a logged no-op; an app
@@ -140,7 +148,7 @@ function configureNext(config, onAnimationDidEnd, onAnimationDidFail) {
         onAnimationDidEnd?.();
     };
     dlog(`LayoutAnimation.configureNext: dispatching config (duration=${config.duration})`);
-    // onError only fires if native config parsing fails; default to a no-op.
+    // Default to a no-op when the caller doesn't supply one.
     manager.configureNextLayoutAnimation(config, onComplete, onAnimationDidFail ?? (() => { }));
 }
 // ---- the LayoutAnimation facade ------------------------------------------
@@ -178,5 +186,15 @@ class LayoutAnimationImpl {
     checkConfig(..._args) {
         dlog('LayoutAnimation.checkConfig(...) has been disabled.');
     }
+    // Coerce an arbitrary string (e.g. a keyboard event's `easing` field) onto a known
+    // ILayoutAnimationType, falling back to 'keyboard' when it isn't a key of `Types`.
+    // Owned here, not by a caller: `Types` is this class's own frozen table, so by
+    // Information Expert the coercion belongs on the type it reads (Keyboard's
+    // scheduleLayoutAnimation is the first caller; RN's own
+    // `LayoutAnimation.Types[easing] || 'keyboard'` is the same rule).
+    coerceType(easing) {
+        const types = this.Types;
+        return types[easing] ?? ANIMATION_TYPE.keyboard;
+    }
 }
 export const LayoutAnimation = new LayoutAnimationImpl();

package/build/native-modules.d.ts

@@ -1,6 +1,18 @@
+import { NativeEventEmitter } from './native-events';
 declare global {
     var __turboModuleProxy: (<T>(name: string) => T | null) | undefined;
     var nativeModuleProxy: Record<string, unknown> | undefined;
 }
 export declare function getNativeModule<T>(name: string): T | null;
 export declare function getEnforcingNativeModule<T>(name: string): T;
+export interface IDeviceEventModuleConfig<TModule> {
+    moduleName: string;
+    moduleLogPrefix: string;
+    bindModuleToEmitter?: boolean;
+    onEmitterCreated?: (emitter: NativeEventEmitter, module: TModule | null) => void;
+}
+export interface IDeviceEventModule<TModule> {
+    getModule(): TModule | null;
+    getEmitter(): NativeEventEmitter;
+}
+export declare function createDeviceEventModule<TModule>(config: IDeviceEventModuleConfig<TModule>): IDeviceEventModule<TModule>;

package/build/native-modules.js

@@ -5,10 +5,12 @@
 // one more client of the same global, exactly as `getSlot` is for the view tree.
 //
 // This is first-party access, for symbiote's own modules (StatusBarManager,
-// KeyboardObserver, …). Third-party RN packages import `TurboModuleRegistry` from
+// KeyboardObserver, ...). Third-party RN packages import `TurboModuleRegistry` from
 // `'react-native'` and read the same global themselves; they do not go through
 // here.
 import { dlog } from './debug.js';
+import { installDeviceEventHub, NativeEventEmitter, } from './native-events.js';
+import { isRecord } from './type-guards.js';
 // The native module value crosses from an untyped HostObject into our types here;
 // the caller vouches for its shape via T (the single trust-boundary narrowing, no
 // per-call `as`). Native modules are always non-null objects.
@@ -55,3 +57,64 @@ export function getEnforcingNativeModule(name) {
     }
     return module;
 }
+// ---- device-event module factory ------------------------------------------
+//
+// AccessibilityInfo (iOS + Android), AppState, Appearance, BackHandler, Keyboard,
+// and Dimensions each hand-rolled the identical plumbing: lazily resolve a native
+// module, lazily build a NativeEventEmitter bound to it, install the device-event
+// hub on first subscribe. `createLinking` (linking/shared.ts) proved this factors
+// out safely for Linking's iOS/Android split; this is the general form for every
+// other lazy-module + emitter pair in the runtime-module layer.
+//
+// Each caller's DEGRADE POLICY stays its own, via config - the factory owns only
+// the plumbing:
+//   - `bindModuleToEmitter` (default true): whether the resolved module is wired
+//     into the emitter so its addListener/removeListeners observe-counters get
+//     pinged. Dimensions' DeviceInfo module has no observe-counters, so it opts out
+//     (matching its original `new NativeEventEmitter(undefined)`).
+//   - `onEmitterCreated`: runs exactly once, right after the emitter is built -
+//     the hook for a caller's own permanent self-subscription (AppState/Appearance/
+//     BackHandler/Keyboard each keep a cache fresh or dispatch a chain this way) or
+//     one-time hydration from the module's constants (AppState's initial state,
+//     Dimensions' initial metrics - the latter also relies on this hook running
+//     `addListener` BEFORE the constants read, preserving the original
+//     subscribe-before-resolve ordering that guards against missing an update).
+// A structural check, not a cast: narrows an arbitrary resolved module down to
+// IEventEmitterModule only when it actually carries both observe-counter methods.
+// Needed because `TModule` is unconstrained (Dimensions' INativeDeviceInfo doesn't
+// extend IEventEmitterModule at all) - NativeEventEmitter itself re-checks the same
+// shape internally, so this exists to satisfy the type system, not to change
+// behavior.
+function hasEventEmitterShape(value) {
+    return (isRecord(value) &&
+        typeof value.addListener === 'function' &&
+        typeof value.removeListeners === 'function');
+}
+// Build one module's lazy-resolve + lazy-emitter pair. Each call owns its own
+// cache, so two callers (or two platform builds loaded together in one smoke) stay
+// independent - the same guarantee `createLinking` documents.
+export function createDeviceEventModule(config) {
+    let module;
+    let emitter;
+    function getModule() {
+        if (module === undefined) {
+            module = getNativeModule(config.moduleName);
+            dlog(`${config.moduleLogPrefix} ${module ? 'resolved' : 'NOT resolved (null)'}`);
+        }
+        return module;
+    }
+    function getEmitter() {
+        if (emitter === undefined) {
+            // WHY lazy: install on first subscribe so the hub exists before native
+            // emits, without a hard bootstrap-order dependency. Idempotent.
+            installDeviceEventHub();
+            const resolved = getModule();
+            const bindModule = config.bindModuleToEmitter ?? true;
+            const boundModule = bindModule && resolved !== null && hasEventEmitterShape(resolved) ? resolved : undefined;
+            emitter = new NativeEventEmitter(boundModule);
+            config.onEmitterCreated?.(emitter, resolved);
+        }
+        return emitter;
+    }
+    return { getModule, getEmitter };
+}

package/build/node.d.ts

@@ -10,6 +10,7 @@ export interface ISymbioteEvent {
     stopPropagation: () => void;
 }
 export type IListener = (event: ISymbioteEvent) => unknown;
+export declare function isSymbioteEvent(value: unknown): value is ISymbioteEvent;
 export interface ISymbioteNode {
     readonly [BRAND]: true;
     readonly component: string;

package/build/node.js

@@ -15,6 +15,15 @@ const BRAND = Symbol('symbiote.node');
 export const RAW_TEXT_COMPONENT = 'RCTRawText';
 export const TEXT_COMPONENT = 'RCTText';
 export const VIRTUAL_TEXT_COMPONENT = 'RCTVirtualText';
+// Runtime guard narrowing `unknown` to ISymbioteEvent (no `as` cast). Lives with the interface
+// it tests, so every adapter checking for a Symbiote event shares one guard instead of writing
+// its own copy.
+export function isSymbioteEvent(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const nativeEvent = Reflect.get(value, 'nativeEvent');
+    return typeof nativeEvent === 'object' && nativeEvent !== null;
+}
 export function createElement(component, isText = false) {
     return {
         [BRAND]: true,

package/build/pan-responder/index.js

@@ -12,12 +12,10 @@
 // changed ones on `changedTouches`), so the centroid/velocity math here reads
 // those directly while keeping RN's accumulate-deltas-over-time behavior.
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 const SINGLE_TOUCH_COUNT = 1;
 // onShouldBlockNativeResponder defaults to true (RN: block native by default).
 const DEFAULT_BLOCK_NATIVE_RESPONDER = true;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function toFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }

package/build/permissions-android/index.js

@@ -19,6 +19,7 @@
 //   requestMultiplePermissions(permissions): Promise<{[permission]: string}>
 import { getNativeModule } from '../native-modules.js';
 import { dlog } from '../debug.js';
+import { isBoolean } from '../type-guards.js';
 // The native module name RN registers this TurboModule under
 // (`TurboModuleRegistry.get<Spec>('PermissionsAndroid')`). NOTE: a module name is
 // only provable on a real host (a headless fake answers to any name); this name
@@ -79,9 +80,6 @@ export const PERMISSIONS = Object.freeze({
     POST_NOTIFICATIONS: 'android.permission.POST_NOTIFICATIONS',
     NEARBY_WIFI_DEVICES: 'android.permission.NEARBY_WIFI_DEVICES',
 });
-function isBoolean(value) {
-    return typeof value === 'boolean';
-}
 // Narrow the native string result into a known RESULTS value. Any unrecognized
 // string is passed through as a IPermissionStatus only when it matches; otherwise
 // we fall back to DENIED: a runtime guard at the trust boundary, not an `as`.

package/build/platform-color.d.ts

@@ -17,3 +17,6 @@ export type IColorValue = string | IOpaqueColorValue;
 export declare function PlatformColor(...names: string[]): IOpaqueColorValue;
 export declare function DynamicColorIOS(tuple: IDynamicColorIOSTuple): IOpaqueColorValue;
 export declare function isOpaqueColorValue(value: unknown): value is IOpaqueColorValue;
+export declare function setColorProcessor(process: (value: IColorValue) => unknown): void;
+export declare function processColor(color: IColorValue): unknown;
+export declare function isProcessableColor(value: unknown): value is IColorValue;

package/build/platform-color.js

@@ -23,3 +23,27 @@ export function DynamicColorIOS(tuple) {
 export function isOpaqueColorValue(value) {
     return typeof value === 'object' && value !== null && ('semantic' in value || 'dynamic' in value);
 }
+// Color props must reach Fabric as platform ints, not CSS strings. Fabric's C++ color
+// parser silently drops strings. The actual conversion (processColor) is RN-platform-specific,
+// so it is injected here rather than imported, keeping shared free of a react-native dependency
+// (and the headless harness working). This module is the sole owner of "run a value through the
+// platform color processor" - every color-touching consumer (commit's fabricProps,
+// process-box-shadow, process-filter, process-background-image, StatusBar android) imports
+// processColor/isProcessableColor from here, never from commit.ts.
+let colorProcessor = value => value;
+export function setColorProcessor(process) {
+    colorProcessor = process;
+}
+// Public mirror of RN's processColor: run a color through the injected platform processor (the
+// canary wires RN's own). Off a real host it resolves CSS strings and opaque PlatformColor
+// objects to the platform ints Fabric expects; headless (no processor wired) it is the identity,
+// so smokes see the input unchanged.
+export function processColor(color) {
+    return colorProcessor(color);
+}
+// A color-keyed value the platform processor must convert before Fabric: a CSS string, or an
+// opaque PlatformColor / DynamicColorIOS object. Numbers (already platform ints) and undefined
+// are left untouched.
+export function isProcessableColor(value) {
+    return typeof value === 'string' || isOpaqueColorValue(value);
+}

package/build/process-background-image/index.js

@@ -1,15 +1,11 @@
 // JS-side port of RN's processBackgroundImage (Libraries/StyleSheet/processBackgroundImage.js).
 // Same root cause as boxShadow/filter/transform: `experimental_backgroundImage` registers with
 // enableNativeCSSParsing(), which DEFAULTS TO FALSE, so RN's stock path parses the CSS gradient
-// string / structured array in JS and sends only the processed array to native — Fabric's C++
+// string / structured array in JS and sends only the processed array to native - Fabric's C++
 // never sees the raw string. This restores that missing JS parse.
-//
-// processColor is referenced from ../commit at RUNTIME only (inside function bodies), never at
-// module-init, so the cyclic import (commit -> here -> commit) has no TDZ hazard — same pattern
-// as process-box-shadow/process-filter.
-import { processColor } from '../commit.js';
-import { isOpaqueColorValue } from '../platform-color.js';
+import { isOpaqueColorValue, processColor } from '../platform-color.js';
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 // RN processBackgroundImage.js: pre-compiled patterns.
 const NEWLINE_REGEX = /\n/g;
 const GRADIENT_REGEX = /^(linear|radial)-gradient\(((?:\([^)]*\)|[^()])*)\)/;
@@ -23,9 +19,6 @@ const LINEAR_GRADIENT_DEFAULT_DIRECTION = { type: 'angle', value: 180 };
 const DEFAULT_RADIAL_SHAPE = 'ellipse';
 const DEFAULT_RADIAL_SIZE = 'farthest-corner';
 const DEFAULT_RADIAL_POSITION = { top: '50%', left: '50%' };
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 function isStringOrNumber(value) {
     return typeof value === 'string' || typeof value === 'number';
 }
@@ -221,7 +214,7 @@ function processBackgroundImageArray(rawList) {
 //#region CSS string form
 // Split a `background-image` value on its TOP-LEVEL commas only (multiple gradients, or a
 // color function's internal commas like `rgba(0, 0, 0, .3)`, must not be confused for one
-// another) — depth-tracking instead of a lookahead regex because a gradient's own arg list can
+// another) - depth-tracking instead of a lookahead regex because a gradient's own arg list can
 // itself contain nested parens (`linear-gradient(to right, rgba(0,0,0,.5), blue)`).
 function splitGradients(input) {
     const result = [];
@@ -320,7 +313,7 @@ function parseLinearGradientCSSString(gradientContent) {
 }
 // The `at <position>` clause of `radial-gradient(... at <position>, <color-stops>)`. Drains
 // `tokens` (the SAME queue the caller is walking) via `shift()`, mirroring RN's in-place mutation
-// of `firstPartTokens` — not a copy, so the caller sees it emptied after this returns.
+// of `firstPartTokens` - not a copy, so the caller sees it emptied after this returns.
 function parseRadialGradientPositionTokens(tokens) {
     if (tokens.length === 0)
         return null;
@@ -511,7 +504,7 @@ function parseRadialGradientCSSString(gradientContent) {
             position = parsedPosition;
             break;
         }
-        // No shape/size/position token found in this iteration — the rest of the first part is a
+        // No shape/size/position token found in this iteration - the rest of the first part is a
         // color stop, not gradient config.
         if (!hasShapeSizeOrPositionString)
             break;
@@ -545,7 +538,7 @@ function parseBackgroundImageCSSString(cssString) {
     return gradients;
 }
 //#endregion CSS string form
-// RN processBackgroundImage.js's default export. Returns [] on any invalid gradient — web
+// RN processBackgroundImage.js's default export. Returns [] on any invalid gradient - web
 // semantics: an invalid `background-image` paints none of it rather than a partial gradient.
 export function processBackgroundImage(backgroundImage) {
     if (backgroundImage == null)

package/build/process-box-shadow/index.js

@@ -4,11 +4,7 @@
 // processed array to native; Fabric's C++ never sees the raw string. symbiote was
 // forwarding the raw value, which native (CSS parsing off) silently ignores: shadow
 // rendered nothing. This restores the missing JS parse + per-color processColor.
-//
-// processColor is referenced from ./commit at RUNTIME only (inside the function bodies),
-// never at module-init, so the cyclic import (commit -> here -> commit) has no TDZ hazard.
-import { processColor } from '../commit.js';
-import { isOpaqueColorValue } from '../platform-color.js';
+import { isOpaqueColorValue, processColor } from '../platform-color.js';
 import { dlog } from '../debug.js';
 // RN processBoxShadow.js:16-19: split args only on the delimiters that are NOT inside
 // a parenthesized color like rgba(0,0,0,1).

package/build/process-filter.js

@@ -4,12 +4,9 @@
 // structured result. symbiote forwarded the raw value; the array form already worked
 // (Fabric accepts it raw, `filter:[{brightness:0.5}]` was device-verified), but the
 // CSS-string form and drop-shadow color processing were missing. This restores them.
-//
-// processColor is referenced from ./commit at RUNTIME only (inside function bodies),
-// never at module-init, so the cyclic import (commit -> here -> commit) has no TDZ hazard.
-import { processColor } from './commit.js';
-import { isOpaqueColorValue } from './platform-color.js';
+import { isOpaqueColorValue, processColor } from './platform-color.js';
 import { dlog } from './debug.js';
+import { isRecord } from './type-guards.js';
 // RN processFilter.js:19-24: pre-compiled patterns.
 const NEWLINE_REGEX = /\n/g;
 const FILTER_FUNCTION_REGEX = /([\w-]+)\(([^()]*|\([^()]*\)|[^()]*\([^()]*\)[^()]*)\)/g;
@@ -17,9 +14,6 @@ const ARGS_WITH_UNITS_REGEX = /([+-]?\d*(\.\d+)?)([a-zA-Z%]+)?/g;
 const WHITESPACE_SPLIT_REGEX = /\s+(?![^(]*\))/;
 const LENGTH_PARSE_REGEX = /([+-]?\d*(\.\d+)?)([\w\W]+)?/g;
 const RADIANS_TO_DEGREES = 180 / Math.PI;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // A length field may be a CSS string or a number; resolve to a number or null.
 function resolveLength(value) {
     if (typeof value === 'string')

package/build/registry.js

@@ -11,13 +11,14 @@
 // shared must stay react-native-free (the headless harness runs in plain Node), so
 // the ViewConfig lookup is INJECTED, exactly like the color processor: the adapter
 // wires `setNativeViewConfigSource(ReactNativeViewConfigRegistry.get)` on a real
-// host (on a real host that one source covers BOTH RN core and every library).
+// host, where that one source covers BOTH RN core and every library.
 //
 // The ONLY explicit list is OUR OWN built-in primitives (BUILTIN_COMPONENTS): a
 // finite set we own, which keep their hand-tuned tables (view-config events, commit
 // COLOR_PROPS) and are never read from the source, so they can't drift. Everything
 // NOT in that set derives. The list never grows with the community; it grows only
 // when we add a core primitive of our own.
+import { isRecord } from './type-guards.js';
 const EMPTY = { listeners: new Set(), byRaw: new Map(), processors: new Map() };
 // OUR own primitives: the finite set shared hand-tunes (view-config events,
 // commit COLOR_PROPS). The source is never consulted for these, so they can't
@@ -59,9 +60,6 @@ export function registerComponent(name, registration = {}) {
         list.push(registration);
     resolvedCache.delete(name);
 }
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // onChange -> change (mirrors node.ts listenerName; the split of the handler prop).
 function splitListener(handlerProp) {
     return handlerProp.charAt(2).toLowerCase() + handlerProp.slice(3);
@@ -92,7 +90,7 @@ function deriveFromConfig(config, into) {
             const attribute = validAttributes[key];
             if (isRecord(attribute)) {
                 const process = attribute.process;
-                // The codegen config already carries the right processor (processColor, …);
+                // The codegen config already carries the right processor (processColor, ...);
                 // wrap it so the typed Function becomes a PropProcessor without a cast.
                 if (typeof process === 'function')
                     into.processors.set(key, value => process(value));

package/build/settings/index.js

@@ -8,6 +8,7 @@
 import { installDeviceEventHub, NativeEventEmitter, } from '../native-events.js';
 import { getNativeModule } from '../native-modules.js';
 import { dlog } from '../debug.js';
+import { isRecord } from '../type-guards.js';
 // The iOS native module name RN registers this under. NOTE: this is the name the
 // iOS JS wrapper resolves via `TurboModuleRegistry.getEnforcing('SettingsManager')`.
 // The spec filename is `INativeSettingsManager`. A module name is only provable on a
@@ -19,9 +20,6 @@ const SETTINGS_UPDATED_EVENT = 'settingsUpdated';
 // watchIds are handed out as the registry index, so the first watcher is 0. A
 // cleared slot keeps its index (the array never shrinks) so later ids stay stable.
 const FIRST_WATCH_ID = 0;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // Lazily resolved so importing this module has no native side effect. `null` when
 // the module isn't linked (headless): the snapshot then starts empty and `set`
 // updates only JS state + fires watchers.

package/build/share/index.ios.js

@@ -6,8 +6,8 @@
 // web/headless.
 import { dlog } from '../debug.js';
 import { getNativeModule } from '../native-modules.js';
+import { ACTION_SHEET_MANAGER, } from '../action-sheet-ios/index.js';
 import { validateContent, shareActions, SHARED_ACTION, DISMISSED_ACTION } from './shared.js';
-const ACTION_SHEET_MANAGER = 'ActionSheetManager';
 export const Share = {
     ...shareActions,
     // Open the iOS share sheet for `content`. Resolves with the user's action

package/build/status-bar/index.android.js

@@ -11,8 +11,8 @@
 // relayout survives and the bar updates without blanking (verified on device: show/hide +
 // light/dark text). See render.ts's installStopSurfaceGlobal.
 import { getNativeModule } from '../native-modules.js';
-import { processColor } from '../commit.js';
 import { dlog } from '../debug.js';
+import { processColor } from '../platform-color.js';
 import { STATUS_BAR_MANAGER } from './shared.js';
 // processColor returns `unknown` (its result is platform-dependent); narrow to the
 // number Fabric/native expects, like RN's invariant before setColor. A non-number

package/build/style/index.js

@@ -7,9 +7,7 @@
 // POSITION only, never on a property VALUE. `transform: [{translateX: 5}]` is an
 // array-valued prop and `shadowOffset: {width, height}` an object-valued prop; both
 // are copied through untouched. Only the top-level style slot is flattened.
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
+import { isRecord } from '../type-guards.js';
 export function flattenStyle(style) {
     if (Array.isArray(style)) {
         const result = {};
@@ -22,7 +20,7 @@ export function flattenStyle(style) {
         }
         return result;
     }
-    if (isPlainObject(style)) {
+    if (isRecord(style)) {
         // Shallow copy of own enumerable keys: values (arrays, nested objects) pass through.
         return { ...style };
     }

package/build/style-registry/index.d.ts

@@ -5,7 +5,5 @@ export declare function registerStyles(styles: Record<string, IResolvedStyle>):
 export declare function clearGlobalStyles(): void;
 export declare function isClassNameValue(value: unknown): value is IClassNameValue;
 export declare function resolveClassName(className: IClassNameValue): IResolvedStyle;
-export type IClassToggleMap = Record<string, boolean | undefined>;
-export type IScopableClassValue = string | IClassToggleMap | Array<string | IClassToggleMap> | undefined | null;
-export declare function scopeClassName(value: IScopableClassValue, localNames: ReadonlySet<string>, scopeId: string): IScopableClassValue;
+export declare function kebabToCamel(value: string): string;
 export {};