@symbiote-native/react 0.1.0

package/build/index.d.ts

@@ -0,0 +1,98 @@
+export { View, Text } from './components';
+export type { IViewProps, ITextProps } from './components';
+export type { IAccessibilityProps, IAriaProps, IAccessibilityRole, IRole, IAccessibilityStateValue, IAccessibilityValue, IAccessibilityActionInfo, } from '@symbiote-native/components';
+export type { IResponderProps } from './utils/responder-props';
+export { Image, setImageSourceResolver } from './components/image';
+export type { IImageProps, IImageSource, IImageSourceProp, IResizeMode, IImageSize, IImageCacheStatus, } from './components/image';
+export { ImageBackground } from './components/image-background';
+export type { IImageBackgroundProps } from './components/image-background';
+export { ScrollView } from './components/scroll-view';
+export type { IScrollViewProps, IScrollViewHandle } from './components/scroll-view';
+export { TextInput } from './components/text-input';
+export type { ITextInputProps, ITextInputHandle } from './components/text-input';
+export { InputAccessoryView } from './components/input-accessory-view';
+export type { IInputAccessoryViewProps } from './components/input-accessory-view';
+export { Keyboard, KEYBOARD_EVENT } from './modules/keyboard';
+export type { IKeyboardEventName } from './modules/keyboard';
+export { KeyboardAvoidingView } from './components/keyboard-avoiding-view';
+export type { IKeyboardAvoidingViewProps, IKeyboardAvoidingBehavior, } from './components/keyboard-avoiding-view';
+export { StatusBar } from './modules/status-bar';
+export type { IStatusBarProps, IStatusBarStyle } from './modules/status-bar';
+export { Switch } from './components/switch';
+export type { ISwitchProps, ISwitchTrackColor } from './components/switch';
+export { ActivityIndicator } from './components/activity-indicator';
+export type { IActivityIndicatorProps } from './components/activity-indicator';
+export { SafeAreaView } from './components/safe-area-view';
+export type { ISafeAreaViewProps } from './components/safe-area-view';
+export { RefreshControl } from './components/refresh-control';
+export type { IRefreshControlProps } from './components/refresh-control';
+export { Modal } from './components/modal';
+export type { IModalProps, IModalAnimationType, IModalPresentationStyle, IModalOrientation, } from './components/modal';
+export { Pressable } from './components/pressable';
+export type { IPressableProps, IPressState } from './components/pressable';
+export { TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, } from './components/touchable';
+export type { ITouchableOpacityProps, ITouchableHighlightProps, ITouchableWithoutFeedbackProps, } from './components/touchable';
+export { Button } from './components/button';
+export type { IButtonProps } from './components/button';
+export { FlatList } from './components/flat-list';
+export type { IFlatListProps, IFlatListHandle } from './components/flat-list';
+export { SectionList } from './components/section-list';
+export type { ISectionListProps, ISectionListHandle, ISection } from './components/section-list';
+export { VirtualizedSectionList } from './components/virtualized-section-list';
+export type { IVirtualizedSectionListProps, IVirtualizedSectionListHandle, } from './components/virtualized-section-list';
+export { VirtualizedList } from './components/virtualized-list';
+export type { IVirtualizedListProps, IVirtualizedListHandle, IViewToken, IViewableItemsChangedInfo, IViewabilityConfig, IViewabilityConfigCallbackPair, } from './components/virtualized-list';
+export type { IViewStyle, ITextStyle, IFlexAlign, IFlexJustify } from './utils/styles';
+export { mount, unmount } from './render';
+export { createPortal, type IPortalContainer } from './create-portal';
+export { createTunnel, type ITunnel } from './create-tunnel';
+export { descriptorToReact } from './descriptor-to-react';
+export { findNodeHandle } from './host-instance';
+export type { IHostInstance } from './host-instance';
+export { AppRegistry, setHostRegistrar } from './modules/app-registry';
+export type { IComponentProvider, IAppParameters, IRunnable, IHostRegistrar, IWrapperComponentProvider, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from './modules/app-registry';
+export { Animated, createAnimatedComponent } from './modules/animated';
+export { Platform, StyleSheet } from '@symbiote-native/engine';
+export { PlatformColor, DynamicColorIOS, processColor } from '@symbiote-native/engine';
+export type { IColorValue, IOpaqueColorValue, IDynamicColorIOSTuple, } from '@symbiote-native/engine';
+export { setNativeViewConfigSource } from '@symbiote-native/engine';
+export type { INativeViewConfig, INativeViewConfigSource } from '@symbiote-native/engine';
+export type { IPlatformStatic, IPlatformOSType, IPlatformConstantsIOS, IPlatformConstantsAndroid, IPlatformSelectSpec, } from '@symbiote-native/engine';
+export { Dimensions } from './modules/dimensions';
+export type { IDisplayMetrics, IDisplayMetricsAndroid, IDimensionsPayload, IDimensionsSet, IDimensionsKey, IDimensionsChangeListener, IDimensionsStatic, } from './modules/dimensions';
+export { PixelRatio } from '@symbiote-native/engine';
+export type { IPixelRatioStatic } from '@symbiote-native/engine';
+export { useWindowDimensions } from './hooks/use-window-dimensions';
+export { Appearance } from './modules/appearance';
+export type { IColorSchemeName, IColorSchemePreference } from './modules/appearance';
+export { useColorScheme } from './hooks/use-color-scheme';
+export { AppState } from './modules/app-state';
+export type { IAppStateStatus, IAppStateEvent } from './modules/app-state';
+export { Alert } from './modules/alert';
+export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlertOptions, } from './modules/alert';
+export { ActionSheetIOS } from './modules/action-sheet-ios';
+export type { IActionSheetIOSOptions, IShareActionSheetIOSOptions, IShareActionSheetError, } from './modules/action-sheet-ios';
+export { Linking } from './modules/linking';
+export type { IUrlEvent } from './modules/linking';
+export { Vibration } from './modules/vibration';
+export { Share } from './modules/share';
+export type { IShareContent, IShareOptions, IShareAction } from './modules/share';
+export { AccessibilityInfo } from './modules/accessibility-info';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from './modules/accessibility-info';
+export { I18nManager } from './modules/i18n-manager';
+export type { II18nManagerConstants } from './modules/i18n-manager';
+export { Settings } from './modules/settings';
+export { PanResponder } from '@symbiote-native/engine';
+export type { IPanResponderGestureState, IPanResponderCallbacks, IGestureResponderHandlers, IPanResponderInstance, } from '@symbiote-native/engine';
+export { LayoutAnimation } from './modules/layout-animation';
+export type { ILayoutAnimationType, ILayoutAnimationProperty, ILayoutAnimationConfig, ILayoutAnimationAnim, } from './modules/layout-animation';
+export { InteractionManager } from '@symbiote-native/engine';
+export type { IInteractionEvent, ISimpleTask, IPromiseTask, ITask, IHandle, } from '@symbiote-native/engine';
+export { BackHandler } from './modules/back-handler';
+export type { IBackPressEventName, IBackPressHandler } from './modules/back-handler';
+export { ToastAndroid } from './modules/toast-android';
+export { PermissionsAndroid, PERMISSIONS, RESULTS } from './modules/permissions-android';
+export type { IPermission, IPermissionStatus, IRationale } from './modules/permissions-android';
+export { TouchableNativeFeedback } from './components/touchable-native-feedback';
+export type { ITouchableNativeFeedbackProps, INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, } from './components/touchable-native-feedback';
+export type { ISymbioteEvent } from '@symbiote-native/engine';

package/build/index.js

@@ -0,0 +1,85 @@
+// @symbiote-native/react: a react-reconciler host config (mutation mode) over
+// @symbiote-native/engine. React is a known-good driver: it proves the native pipe
+// (R1) and shared's clone-on-write engine (R2) before any non-React adapter.
+export { View, Text } from './components';
+export { Image, setImageSourceResolver } from './components/image';
+export { ImageBackground } from './components/image-background';
+export { ScrollView } from './components/scroll-view';
+export { TextInput } from './components/text-input';
+export { InputAccessoryView } from './components/input-accessory-view';
+export { Keyboard, KEYBOARD_EVENT } from './modules/keyboard';
+export { KeyboardAvoidingView } from './components/keyboard-avoiding-view';
+export { StatusBar } from './modules/status-bar';
+export { Switch } from './components/switch';
+export { ActivityIndicator } from './components/activity-indicator';
+export { SafeAreaView } from './components/safe-area-view';
+export { RefreshControl } from './components/refresh-control';
+export { Modal } from './components/modal';
+export { Pressable } from './components/pressable';
+export { TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, } from './components/touchable';
+export { Button } from './components/button';
+export { FlatList } from './components/flat-list';
+export { SectionList } from './components/section-list';
+export { VirtualizedSectionList } from './components/virtualized-section-list';
+export { VirtualizedList } from './components/virtualized-list';
+export { mount, unmount } from './render';
+// createPortal: react-reconciler's Fiber-level portal, working here because @symbiote-native/react is
+// mutation-mode (unlike stock RN's persistent-mode Fabric renderer, which doesn't support it —
+// see create-portal.ts). v1 scope: target must be an already-mounted node in the SAME surface.
+export { createPortal } from './create-portal';
+// createTunnel: cross-surface content sharing (createPortal/Teleport stay same-surface-only
+// by design — see create-tunnel.tsx and the react-adapter-portal skill for why).
+export { createTunnel } from './create-tunnel';
+// descriptorToReact: the @symbiote-native/components Descriptor → React.createElement bridge. Exported so
+// an external wrapper package (e.g. @symbiote-native/slider/react over a third-party native view) can map
+// a shared render fn's Descriptor onto React elements through the SAME bridge the adapter uses.
+export { descriptorToReact } from './descriptor-to-react';
+export { findNodeHandle } from './host-instance';
+// AppRegistry: RN's app entry point over `mount`. setHostRegistrar wires RN's own
+// registrar so the native Fabric host finds our runnable by app key.
+export { AppRegistry, setHostRegistrar } from './modules/app-registry';
+// Animated bridge: createAnimatedComponent + Animated.View/Text/Image, driving the
+// shared JS Animated engine (ADR 0016). Imperative timing/spring drivers merge into
+// this namespace once they land in shared.
+export { Animated, createAnimatedComponent } from './modules/animated';
+// Framework-agnostic runtime utilities live in shared; the adapter re-exports them
+// so app code names only @symbiote-native/react (RN's surface, one import root).
+export { Platform, StyleSheet } from '@symbiote-native/engine';
+// Color utilities: PlatformColor / DynamicColorIOS build opaque platform colors;
+// processColor runs a color through the injected platform processor. All pure /
+// seam-backed, so they live in shared and the adapter re-exports them.
+export { PlatformColor, DynamicColorIOS, processColor } from '@symbiote-native/engine';
+// Wired once by the app entry on a real host (like setColorProcessor): hands shared
+// RN's ViewConfig registry so third-party Fabric views auto-derive their metadata:
+//   setNativeViewConfigSource(name => ReactNativeViewConfigRegistry.get(name))
+export { setNativeViewConfigSource } from '@symbiote-native/engine';
+// Runtime modules: native-bridge consumers, same shape as Keyboard/StatusBar:
+// thin JS over getNativeModule + device events, no Fabric component of their own.
+export { Dimensions } from './modules/dimensions';
+export { PixelRatio } from '@symbiote-native/engine';
+export { useWindowDimensions } from './hooks/use-window-dimensions';
+export { Appearance } from './modules/appearance';
+export { useColorScheme } from './hooks/use-color-scheme';
+export { AppState } from './modules/app-state';
+export { Alert } from './modules/alert';
+export { ActionSheetIOS } from './modules/action-sheet-ios';
+export { Linking } from './modules/linking';
+export { Vibration } from './modules/vibration';
+export { Share } from './modules/share';
+export { AccessibilityInfo } from './modules/accessibility-info';
+export { I18nManager } from './modules/i18n-manager';
+export { Settings } from './modules/settings';
+// Interaction subsystems: gestures, deferred work, and layout transitions.
+export { PanResponder } from '@symbiote-native/engine';
+export { LayoutAnimation } from './modules/layout-animation';
+// InteractionManager is pure JS, so it lives in shared; re-exported here so app code
+// names only @symbiote-native/react (RN's single import root).
+export { InteractionManager } from '@symbiote-native/engine';
+// Android-only surface (the second-platform pass). Each is a thin JS shim over an
+// Android native module / Fabric view, inert on iOS (no module → graceful no-op,
+// no native view → degrade to a plain container). Native module names are
+// device-verify-pending; see .docs/native-module-platform-routing.md.
+export { BackHandler } from './modules/back-handler';
+export { ToastAndroid } from './modules/toast-android';
+export { PermissionsAndroid, PERMISSIONS, RESULTS } from './modules/permissions-android';
+export { TouchableNativeFeedback } from './components/touchable-native-feedback';

package/build/modules/accessibility-info/index.android.d.ts

@@ -0,0 +1,2 @@
+export { AccessibilityInfo } from '@symbiote-native/engine';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from '@symbiote-native/engine';

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

@@ -0,0 +1,4 @@
+// AccessibilityInfo (Android) moved to @symbiote-native/engine. This thin re-export keeps
+// @symbiote-native/react's surface identical; Metro selects the engine's accessibility-info.android.ts
+// on an Android host.
+export { AccessibilityInfo } from '@symbiote-native/engine';

package/build/modules/accessibility-info/index.d.ts

@@ -0,0 +1 @@
+export * from './index.ios';

package/build/modules/accessibility-info/index.ios.d.ts

@@ -0,0 +1,2 @@
+export { AccessibilityInfo } from '@symbiote-native/engine';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from '@symbiote-native/engine';

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

@@ -0,0 +1,3 @@
+// AccessibilityInfo (iOS) moved to @symbiote-native/engine. This thin re-export keeps @symbiote-native/react's
+// surface identical; Metro selects the engine's accessibility-info.ios.ts on an iOS host.
+export { AccessibilityInfo } from '@symbiote-native/engine';

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

@@ -0,0 +1,5 @@
+// Base / default AccessibilityInfo: re-exports the iOS build. Metro overrides this with
+// accessibility-info.ios.ts / .android.ts on a real host; under tsx / tsc / web the host
+// config resolves here. Filename is the selector, no Platform.OS read. See
+// accessibility-info-shared.ts.
+export * from './index.ios';

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

@@ -0,0 +1 @@
+export type { IAccessibilityChangeEventName, IAccessibilityChangeEvent, IAccessibilityHandle, IAccessibilityAnnouncementFinishedEvent, IAccessibilityChangeEventHandler, IAnnounceForAccessibilityOptions, IAccessibilityInfoStatic, IAccessibilityEventType, } from '@symbiote-native/engine';

package/build/modules/accessibility-info/shared.js

@@ -0,0 +1 @@
+export {};

package/build/modules/action-sheet-ios.d.ts

@@ -0,0 +1,2 @@
+export { ActionSheetIOS } from '@symbiote-native/engine';
+export type { IActionSheetIOSOptions, IShareActionSheetIOSOptions, IShareActionSheetError, } from '@symbiote-native/engine';

package/build/modules/action-sheet-ios.js

@@ -0,0 +1,4 @@
+// ActionSheetIOS now lives framework-agnostic in @symbiote-native/engine (imperative
+// native-bridge module, no visual, no lifecycle). The React adapter re-exports it
+// verbatim so the public surface is unchanged. See ADR 0019.
+export { ActionSheetIOS } from '@symbiote-native/engine';

package/build/modules/alert.d.ts

@@ -0,0 +1,2 @@
+export { Alert } from '@symbiote-native/engine';
+export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlertOptions, } from '@symbiote-native/engine';

package/build/modules/alert.js

@@ -0,0 +1,5 @@
+// Alert now lives framework-agnostic in @symbiote-native/engine (imperative native-bridge
+// module, no visual, no lifecycle). The React adapter re-exports it verbatim so the
+// public surface is unchanged; the platform split (alert.ios/alert.android) lives
+// inside engine. See ADR 0019 + the engine relocation.
+export { Alert } from '@symbiote-native/engine';

package/build/modules/animated/create-animated-component.d.ts

@@ -0,0 +1,12 @@
+import { type ComponentType, type Ref } from 'react';
+export interface IAnimatedComponentProps {
+    style?: unknown;
+    ref?: Ref<unknown>;
+    [key: string]: unknown;
+}
+type IAnimatableProps = {
+    style?: unknown;
+    children?: unknown;
+};
+export declare function createAnimatedComponent<P extends IAnimatableProps>(Component: ComponentType<P>): ComponentType<IAnimatedComponentProps>;
+export {};

package/build/modules/animated/create-animated-component.js

@@ -0,0 +1,125 @@
+// createAnimatedComponent wraps a base component (View / Text / Image / any) so
+// it can take AnimatedNodes in its props. Reimplemented thin against symbiote's
+// shared primitive: NO native driver, NO scheduleUpdate fallback. A frame is the
+// scoped commit setNativeProps drives from the AnimatedProps leaf (ADR 0016). RN's
+// createAnimatedComponent + useAnimatedProps + createAnimatedPropsHook are the
+// structural reference, but their native helpers are deliberately not imported.
+//
+// Per render: build the AnimatedProps leaf for the current props, compute
+// reducedProps (every animated node replaced by its current value) and hand those
+// to the base component. A callback ref captures the rendered base component's
+// public instance (the SymbioteNode the host config returns) and binds it to the
+// leaf. An effect attaches the leaf to the value graph so flushValue reaches it,
+// and detaches on unmount / when the leaf identity changes. The per-frame path is
+// then: value.setValue / animation -> flushValue -> AnimatedProps.update() ->
+// setNativeProps(node, partial).
+import { createElement, useEffect, useMemo, useRef, } from 'react';
+import { AnimatedProps, attachNativeEventHandler, isNativeAnimatedAvailable, reduceProps, readPassthroughStyle, resolveHostNode, } from '@symbiote-native/engine';
+// A ref can be a function or a `.current` object; assign through both forms without
+// casting so a forwarded ref from the caller still receives the instance. Framework-
+// ref-specific, so it stays per-adapter (the rest of the wrap helpers are shared).
+function assignRef(ref, value) {
+    if (ref === undefined || ref === null)
+        return;
+    if (typeof ref === 'function') {
+        ref(value);
+        return;
+    }
+    ref.current = value;
+}
+export function createAnimatedComponent(Component) {
+    function AnimatedComponent(props) {
+        const { ref: forwardedRef, passthroughAnimatedPropExplicitValues: passthrough, ...rest } = props;
+        // Native driving is opt-in per the passthrough prop AND requires a real native module;
+        // headless / unsupported hosts keep the JS flush path (and the existing JS smokes green).
+        const wantsNative = passthrough != null && isNativeAnimatedAvailable();
+        // One AnimatedProps leaf per distinct props object. Rebuilt when props change,
+        // so a newly-added animated value joins the graph; the effect below swaps the
+        // graph attachment to match.
+        const animatedProps = useMemo(() => new AnimatedProps(rest), [rest]);
+        // The leaf currently wired into the value graph. Tracked across renders so a swap
+        // can attach the new leaf BEFORE detaching the old one.
+        const attached = useRef(null);
+        // The committed host node, captured by the ref below. Needed in the event-attach
+        // effect (a native event binds to the node's tag, not the AnimatedProps leaf).
+        const nodeRef = useRef(null);
+        // Swap the graph attachment to the current leaf, attaching the new one FIRST and
+        // detaching the previous one SECOND. Order is load-bearing: a shared Value node
+        // self-detaches (and drops its native animation node) the instant its child count
+        // hits zero, so detaching the old leaf before the new one is attached would kill a
+        // running native-driven animation on any unrelated re-render. Detaching here (not
+        // in a cleanup, which React runs BEFORE the next setup) keeps the new-before-old
+        // order, mirroring RN's AnimatedComponent._attachProps.
+        useEffect(() => {
+            animatedProps.__attach();
+            const previous = attached.current;
+            attached.current = animatedProps;
+            if (previous !== null && previous !== animatedProps) {
+                previous.__detach();
+            }
+        }, [animatedProps]);
+        // Native-driver trigger (ADR 0017). Runs after attach: push the leaf -> style -> transform
+        // -> interpolation -> value chain native so the props animate on the UI thread (no JS lag).
+        // Cascades down to the source value; the scroll event attaches to that same value
+        // (idempotent). __makeNative is idempotent, so re-firing on a leaf swap is safe.
+        useEffect(() => {
+            if (wantsNative)
+                animatedProps.__makeNative();
+        }, [animatedProps, wantsNative]);
+        // Final teardown: detach the last-attached leaf when the component unmounts.
+        useEffect(() => {
+            return () => {
+                if (attached.current !== null) {
+                    attached.current.__detach();
+                    attached.current = null;
+                }
+            };
+        }, []);
+        // Native-attach any Animated.event prop, e.g. onScroll={Animated.event(…,
+        // {useNativeDriver:true})}, to the committed node, so the event drives its values on
+        // the UI thread. attachNativeEventHandler no-ops (returns undefined) unless the prop is
+        // a native event handler with a committed tag, so the JS path stays the fallback. The
+        // __makeNative cascade then carries the bound interpolations/props native too. Keyed on
+        // animatedProps (rebuilt with rest) so a new inline event re-attaches; cleanup detaches.
+        useEffect(() => {
+            const node = nodeRef.current;
+            if (node === null)
+                return;
+            const detachers = [];
+            for (const key of Object.keys(rest)) {
+                const attachment = attachNativeEventHandler(node, key, rest[key]);
+                if (attachment !== undefined)
+                    detachers.push(attachment.detach);
+            }
+            return () => {
+                for (const detach of detachers)
+                    detach();
+            };
+        }, [animatedProps]);
+        // Callback ref: when the base component mounts, capture its public instance, resolve
+        // it to the underlying host node (unwrapping a scroll-container handle), record THAT
+        // for the event-attach effect and bind it to the leaf, but forward the ORIGINAL
+        // instance to the caller, who expects the component's public handle (scrollTo, …).
+        const captureRef = (instance) => {
+            const node = resolveHostNode(instance);
+            nodeRef.current = node;
+            animatedProps.setNativeView(node);
+            assignRef(forwardedRef, instance);
+        };
+        // Reduced props are P-shaped (animated nodes already replaced by values); add the
+        // capture ref. Build via Object.assign so the merged object stays typed as P & ref
+        // without a cast. createElement then accepts it for the generic base component.
+        const reduced = reduceProps(rest);
+        // Override the committed style with the explicit passthrough values (last wins via the style
+        // array, which the commit layer flattens) so the ShadowTree carries the current transform.
+        const passthroughStyle = readPassthroughStyle(passthrough);
+        if (passthroughStyle !== undefined) {
+            reduced.style =
+                reduced.style === undefined ? passthroughStyle : [reduced.style, passthroughStyle];
+        }
+        const childProps = Object.assign(Object.create(null), reduced, { ref: captureRef });
+        return createElement(Component, childProps);
+    }
+    AnimatedComponent.displayName = `Animated(${Component.displayName ?? Component.name ?? 'Anonymous'})`;
+    return AnimatedComponent;
+}

package/build/modules/animated/index.d.ts

@@ -0,0 +1,52 @@
+import { AnimatedValue, AnimatedValueXY, AnimatedColor, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent } from '@symbiote-native/engine';
+import { createAnimatedComponent } from './create-animated-component';
+export { createAnimatedComponent } from './create-animated-component';
+export { AnimatedProps, AnimatedStyle, AnimatedTransform } from '@symbiote-native/engine';
+export declare const Animated: {
+    Value: typeof AnimatedValue;
+    ValueXY: typeof AnimatedValueXY;
+    Color: typeof AnimatedColor;
+    Easing: {
+        step0(n: number): number;
+        step1(n: number): number;
+        linear(t: number): number;
+        ease(t: number): number;
+        quad(t: number): number;
+        cubic(t: number): number;
+        poly(n: number): import("@symbiote-native/engine").IEasingFunction;
+        sin(t: number): number;
+        circle(t: number): number;
+        exp(t: number): number;
+        elastic(bounciness?: number): import("@symbiote-native/engine").IEasingFunction;
+        back(s?: number): import("@symbiote-native/engine").IEasingFunction;
+        bounce(t: number): number;
+        bezier(x1: number, y1: number, x2: number, y2: number): import("@symbiote-native/engine").IEasingFunction;
+        in(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
+        out(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
+        inOut(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
+    };
+    timing: typeof timing;
+    spring: typeof spring;
+    decay: typeof decay;
+    parallel: typeof parallel;
+    sequence: typeof sequence;
+    stagger: typeof stagger;
+    loop: typeof loop;
+    delay: typeof delay;
+    add: typeof add;
+    subtract: typeof subtract;
+    multiply: typeof multiply;
+    divide: typeof divide;
+    modulo: typeof modulo;
+    diffClamp: typeof diffClamp;
+    event: typeof event;
+    forkEvent: typeof forkEvent;
+    unforkEvent: typeof unforkEvent;
+    View: import("react").ComponentType<import("./create-animated-component").IAnimatedComponentProps>;
+    Text: import("react").ComponentType<import("./create-animated-component").IAnimatedComponentProps>;
+    Image: import("react").ComponentType<import("./create-animated-component").IAnimatedComponentProps>;
+    ScrollView: ReturnType<typeof createAnimatedComponent>;
+    FlatList: ReturnType<typeof createAnimatedComponent>;
+    SectionList: ReturnType<typeof createAnimatedComponent>;
+    createAnimatedComponent: typeof createAnimatedComponent;
+};

package/build/modules/animated/index.js

@@ -0,0 +1,84 @@
+// The Animated namespace for @symbiote-native/react. createAnimatedComponent applied to
+// the adapter's primitives gives Animated.View / Text / Image; the value graph,
+// easing and imperative drivers come from @symbiote-native/engine (framework-agnostic,
+// JS-driven, ADR 0016). Both halves meet here in one `Animated` object so the
+// familiar surface (`Animated.timing(new Animated.Value(0), …).start()`) works.
+import { AnimatedValue, AnimatedValueXY, AnimatedColor, Easing, Platform, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, } from '@symbiote-native/engine';
+import { View, Text } from '../../components';
+import { Image } from '../../components/image';
+import { ScrollView } from '../../components/scroll-view';
+import { FlatList } from '../../components/flat-list';
+import { SectionList } from '../../components/section-list';
+import { createAnimatedComponent } from './create-animated-component';
+import { AnimatedMock } from '@symbiote-native/engine';
+export { createAnimatedComponent } from './create-animated-component';
+// The pure graph leaves now live in @symbiote-native/engine (they extend AnimatedWithChildren,
+// no React); re-exported here so @symbiote-native/react's Animated surface is unchanged.
+export { AnimatedProps, AnimatedStyle, AnimatedTransform } from '@symbiote-native/engine';
+// View/Text/Image are pure host primitives, so wrap them eagerly.
+const AnimatedView = createAnimatedComponent(View);
+const AnimatedText = createAnimatedComponent(Text);
+const AnimatedImage = createAnimatedComponent(Image);
+// RN's AnimatedExports.js:13-58 exposes all six animated components. The scrolling
+// containers (ScrollView/FlatList/SectionList) are wrapped behind LAZY getters,
+// mirroring RN's `get ScrollView() { return require(...) }`: ScrollView's module
+// chain pulls in scroll-view/sticky-header, which imports this Animated namespace
+// back, and a static `createAnimatedComponent(ScrollView)` at init would read ScrollView
+// inside its own TDZ. A memoized getter defers the wrap past module init, so the
+// cycle never fires. The wrappers carry no per-component animation logic; they only
+// add animated-prop support, so the adapter stays thin (invariant adapters_stay_thin).
+// The native scroll-event attach (Animated.event onto contentOffset) is owned by
+// ScrollView itself.
+let animatedScrollView;
+let animatedFlatList;
+let animatedSectionList;
+// The live, JS-driven driver namespace (real frames). RN's AnimatedImplementation.
+const liveDrivers = {
+    Value: AnimatedValue,
+    ValueXY: AnimatedValueXY,
+    Color: AnimatedColor,
+    Easing,
+    timing,
+    spring,
+    decay,
+    parallel,
+    sequence,
+    stagger,
+    loop,
+    delay,
+    add,
+    subtract,
+    multiply,
+    divide,
+    modulo,
+    diffClamp,
+    event,
+    forkEvent,
+    unforkEvent,
+};
+// RN's AnimatedExports.js:21 swaps the WHOLE namespace for the mock when the host
+// reports isDisableAnimations (reduced motion / test env): the mock keeps the same
+// surface but jumps each animation to its final value synchronously, no frames.
+// The animated COMPONENTS (View/Text/Image + the lazy container getters) are live in
+// both branches; only the drivers/value/operators/events half is swapped, exactly
+// like RN spreading `...Animated` (impl or mock) over the same component getters.
+const drivers = Platform.isDisableAnimations ? AnimatedMock : liveDrivers;
+export const Animated = {
+    View: AnimatedView,
+    Text: AnimatedText,
+    Image: AnimatedImage,
+    get ScrollView() {
+        animatedScrollView ??= createAnimatedComponent(ScrollView);
+        return animatedScrollView;
+    },
+    get FlatList() {
+        animatedFlatList ??= createAnimatedComponent(FlatList);
+        return animatedFlatList;
+    },
+    get SectionList() {
+        animatedSectionList ??= createAnimatedComponent(SectionList);
+        return animatedSectionList;
+    },
+    createAnimatedComponent,
+    ...drivers,
+};

package/build/modules/app-registry/index.d.ts

@@ -0,0 +1,7 @@
+import { type ComponentType } from 'react';
+import { type IAppParameters } from '@symbiote-native/engine';
+export type IComponentProvider = () => ComponentType<object>;
+export type IWrapperComponentProvider = (appParameters: IAppParameters) => ComponentType<object>;
+declare const AppRegistry: import("@symbiote-native/engine").IAppRegistry<IComponentProvider, IWrapperComponentProvider>, setHostRegistrar: (registrar: import("@symbiote-native/engine").IHostRegistrar) => void;
+export { AppRegistry, setHostRegistrar };
+export type { IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from '@symbiote-native/engine';

package/build/modules/app-registry/index.js

@@ -0,0 +1,26 @@
+// AppRegistry: the JS entry point RN apps already use:
+//   AppRegistry.registerComponent(appKey, () => App)
+// The registry bookkeeping (sections, host-registrar bridge, headless tasks) is
+// framework-agnostic and lives in @symbiote-native/engine's createAppRegistry; this file supplies
+// only the one React-specific seam — building a runnable from a component provider via
+// createElement + mount — so existing RN app-entry code ports verbatim.
+import { createElement } from 'react';
+import { createAppRegistry, dlog, } from '@symbiote-native/engine';
+import { mount } from '../../render';
+function runnableFor(componentProvider, getWrapperComponentProvider) {
+    return appParameters => {
+        dlog(`AppRegistry: mounting on rootTag ${String(appParameters.rootTag)}`);
+        let element = createElement(componentProvider(), appParameters.initialProps);
+        // Wrap the root when a provider is set, mirroring RN's `registerComponent`
+        // passing `wrapperComponentProvider && wrapperComponentProvider(...)` into
+        // renderApplication (AppRegistryImpl.js:80). Read live (not at registration time) so
+        // setWrapperComponentProvider affects every runnable's next run, not just future ones.
+        const wrapperComponentProvider = getWrapperComponentProvider();
+        if (wrapperComponentProvider !== undefined) {
+            element = createElement(wrapperComponentProvider(appParameters), null, element);
+        }
+        mount(appParameters.rootTag, element);
+    };
+}
+const { AppRegistry, setHostRegistrar } = createAppRegistry(runnableFor);
+export { AppRegistry, setHostRegistrar };

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

@@ -0,0 +1,2 @@
+export { AppState } from '@symbiote-native/engine';
+export type { IAppStateStatus, IAppStateEvent } from '@symbiote-native/engine';

package/build/modules/app-state.js

@@ -0,0 +1,3 @@
+// AppState moved to @symbiote-native/engine (a framework-agnostic device-state module re-exported
+// by every adapter). This thin re-export keeps @symbiote-native/react's public surface identical.
+export { AppState } from '@symbiote-native/engine';

package/build/modules/appearance.d.ts

@@ -0,0 +1,2 @@
+export { Appearance } from '@symbiote-native/engine';
+export type { IColorSchemeName, IColorSchemePreference } from '@symbiote-native/engine';

package/build/modules/appearance.js

@@ -0,0 +1,3 @@
+// Appearance moved to @symbiote-native/engine (a framework-agnostic device-state module re-exported
+// by every adapter). This thin re-export keeps @symbiote-native/react's public surface identical.
+export { Appearance } from '@symbiote-native/engine';

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

@@ -0,0 +1,2 @@
+export { BackHandler } from '@symbiote-native/engine';
+export type { IBackPressEventName, IBackPressHandler } from '@symbiote-native/engine';

package/build/modules/back-handler.js

@@ -0,0 +1,3 @@
+// BackHandler moved to @symbiote-native/engine (a framework-agnostic device-state module re-exported
+// by every adapter). This thin re-export keeps @symbiote-native/react's public surface identical.
+export { BackHandler } from '@symbiote-native/engine';

package/build/modules/dimensions.d.ts

@@ -0,0 +1,2 @@
+export { Dimensions } from '@symbiote-native/engine';
+export type { IDisplayMetrics, IDisplayMetricsAndroid, IDimensionsPayload, IDimensionsSet, IDimensionsKey, IDimensionsChangeListener, IDimensionsStatic, } from '@symbiote-native/engine';

package/build/modules/dimensions.js

@@ -0,0 +1,3 @@
+// Dimensions moved to @symbiote-native/engine (a framework-agnostic device-state module re-exported
+// by every adapter). This thin re-export keeps @symbiote-native/react's public surface identical.
+export { Dimensions } from '@symbiote-native/engine';

package/build/modules/i18n-manager.d.ts

@@ -0,0 +1,2 @@
+export { I18nManager } from '@symbiote-native/engine';
+export type { II18nManagerConstants } from '@symbiote-native/engine';

package/build/modules/i18n-manager.js

@@ -0,0 +1,4 @@
+// I18nManager now lives framework-agnostic in @symbiote-native/engine (imperative
+// native-bridge module, no visual, no lifecycle). The React adapter re-exports it
+// verbatim so the public surface is unchanged. See ADR 0019.
+export { I18nManager } from '@symbiote-native/engine';

package/build/modules/keyboard.d.ts

@@ -0,0 +1,2 @@
+export { Keyboard, KEYBOARD_EVENT } from '@symbiote-native/engine';
+export type { IKeyboardEventName, IKeyboardEvent, IKeyboardMetrics } from '@symbiote-native/engine';

package/build/modules/keyboard.js

@@ -0,0 +1,3 @@
+// Keyboard moved to @symbiote-native/engine (a framework-agnostic device-state module re-exported
+// by every adapter). This thin re-export keeps @symbiote-native/react's public surface identical.
+export { Keyboard, KEYBOARD_EVENT } from '@symbiote-native/engine';

package/build/modules/layout-animation.d.ts

@@ -0,0 +1,2 @@
+export { LayoutAnimation } from '@symbiote-native/engine';
+export type { ILayoutAnimationType, ILayoutAnimationProperty, ILayoutAnimationConfig, ILayoutAnimationAnim, ILayoutAnimationTypes, ILayoutAnimationProperties, } from '@symbiote-native/engine';