@symbiote-native/engine 0.1.0

package/build/fabric.d.ts

@@ -0,0 +1,32 @@
+export type IRootTag = number;
+export interface IFabricNode {
+    readonly __fabricNode: unique symbol;
+}
+export interface IFabricChildSet {
+    readonly __fabricChildSet: unique symbol;
+}
+export type IFabricProps = Record<string, unknown>;
+export type IFabricEventHandler = (instanceHandle: unknown, topLevelType: string, nativeEvent: Record<string, unknown>) => void;
+export type IMeasureOnSuccess = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
+export type IMeasureInWindowOnSuccess = (x: number, y: number, width: number, height: number) => void;
+export type IMeasureLayoutOnSuccess = (left: number, top: number, width: number, height: number) => void;
+export interface IFabricSlot {
+    createNode(reactTag: number, viewName: string, rootTag: IRootTag, props: IFabricProps, instanceHandle: unknown): IFabricNode;
+    cloneNodeWithNewProps(node: IFabricNode, newProps: IFabricProps): IFabricNode;
+    cloneNodeWithNewChildren(node: IFabricNode): IFabricNode;
+    cloneNodeWithNewChildrenAndProps(node: IFabricNode, newProps: IFabricProps): IFabricNode;
+    createChildSet(rootTag: IRootTag): IFabricChildSet;
+    appendChild(parent: IFabricNode, child: IFabricNode): IFabricNode;
+    appendChildToSet(childSet: IFabricChildSet, child: IFabricNode): void;
+    completeRoot(rootTag: IRootTag, childSet: IFabricChildSet): void;
+    registerEventHandler(handler: IFabricEventHandler): void;
+    dispatchCommand(node: IFabricNode, commandName: string, args: readonly unknown[]): void;
+    sendAccessibilityEvent(node: IFabricNode, eventType: string): void;
+    measure(node: IFabricNode, callback: IMeasureOnSuccess): void;
+    measureInWindow(node: IFabricNode, callback: IMeasureInWindowOnSuccess): void;
+    measureLayout(node: IFabricNode, relativeToNode: IFabricNode, onFail: () => void, onSuccess: IMeasureLayoutOnSuccess): void;
+}
+declare global {
+    var nativeFabricUIManager: IFabricSlot | undefined;
+}
+export declare function getSlot(): IFabricSlot;

package/build/fabric.js

@@ -0,0 +1,59 @@
+// The one seam symbiote drives. `global.nativeFabricUIManager` is the
+// framework-agnostic, JSI-bound mutation API that Fabric exposes; React's
+// renderer is just one client of it. We bind to it directly.
+//
+// The live object is a lazy caching proxy: every property access mints a fresh
+// host function, so we read each method once and cache a plain facade.
+import { dlog } from './debug';
+let cached;
+export function getSlot() {
+    if (cached)
+        return cached;
+    const host = globalThis.nativeFabricUIManager;
+    if (host === undefined) {
+        throw new Error('nativeFabricUIManager is not installed on the global. ' +
+            'Is this running on a Fabric (New Architecture) host with InitializeCore loaded?');
+    }
+    // Read each method exactly once: the live binding re-mints host functions on
+    // every property access, so caching the references avoids that churn.
+    const { createNode } = host;
+    const { cloneNodeWithNewProps } = host;
+    const { cloneNodeWithNewChildren } = host;
+    const { cloneNodeWithNewChildrenAndProps } = host;
+    const { createChildSet } = host;
+    const { appendChild } = host;
+    const { appendChildToSet } = host;
+    const { completeRoot } = host;
+    const { registerEventHandler } = host;
+    const { dispatchCommand } = host;
+    // Optional on some hosts: read it off the live binding and feature-detect below so an
+    // older slot without it degrades to a logged no-op instead of throwing.
+    const { sendAccessibilityEvent } = host;
+    const { measure } = host;
+    const { measureInWindow } = host;
+    const { measureLayout } = host;
+    cached = {
+        createNode: (reactTag, viewName, rootTag, props, instanceHandle) => createNode(reactTag, viewName, rootTag, props, instanceHandle),
+        cloneNodeWithNewProps: (node, newProps) => cloneNodeWithNewProps(node, newProps),
+        cloneNodeWithNewChildren: node => cloneNodeWithNewChildren(node),
+        cloneNodeWithNewChildrenAndProps: (node, newProps) => cloneNodeWithNewChildrenAndProps(node, newProps),
+        createChildSet: rootTag => createChildSet(rootTag),
+        appendChild: (parent, child) => appendChild(parent, child),
+        appendChildToSet: (childSet, child) => appendChildToSet(childSet, child),
+        completeRoot: (rootTag, childSet) => completeRoot(rootTag, childSet),
+        registerEventHandler: handler => registerEventHandler(handler),
+        dispatchCommand: (node, commandName, args) => dispatchCommand(node, commandName, args),
+        sendAccessibilityEvent: (node, eventType) => {
+            if (typeof sendAccessibilityEvent !== 'function') {
+                dlog(`sendAccessibilityEvent("${eventType}") -> host lacks the method (no-op)`);
+                return;
+            }
+            sendAccessibilityEvent(node, eventType);
+        },
+        measure: (node, callback) => measure(node, callback),
+        measureInWindow: (node, callback) => measureInWindow(node, callback),
+        measureLayout: (node, relativeToNode, onFail, onSuccess) => measureLayout(node, relativeToNode, onFail, onSuccess),
+    };
+    dlog('slot bound to nativeFabricUIManager');
+    return cached;
+}

package/build/host-instance/index.d.ts

@@ -0,0 +1,11 @@
+import { type ISymbioteNode } from '../node';
+import type { IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess } from '../fabric';
+export interface IHostInstance extends ISymbioteNode {
+    measure(callback: IMeasureOnSuccess): void;
+    measureInWindow(callback: IMeasureInWindowOnSuccess): void;
+    measureLayout(relativeToNativeNode: IHostInstance | number, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void): void;
+    setNativeProps(nativeProps: Record<string, unknown>): void;
+    focus(): void;
+    blur(): void;
+}
+export declare function toPublicInstance(node: ISymbioteNode): IHostInstance;

package/build/host-instance/index.js

@@ -0,0 +1,49 @@
+// The public instance a host ref hands back, RN's ReactFabricHostComponent. toPublicInstance
+// augments the retained node with the imperative API libraries reach through (reanimated,
+// gesture-handler, react-navigation): measure / measureInWindow / measureLayout /
+// setNativeProps / focus / blur. The methods are attached onto the node object itself (not its
+// props, so they never reach Fabric); each resolves the node's CURRENT committed handle at call
+// time through the engine, so a clone-on-write commit between calls is transparent.
+//
+// This lives in the engine, not an adapter: it depends only on engine internals (the commit
+// free functions + the retained node), so every adapter inherits the SAME public instance for
+// free — React's getPublicInstance and the Vue renderer both graft this onto their host nodes.
+import { measure as engineMeasure, measureInWindow as engineMeasureInWindow, measureLayout as engineMeasureLayout, setNativeProps as engineSetNativeProps, dispatchViewCommand, } from '../commit';
+import { isSymbioteNode } from '../node';
+import { dlog } from '../debug';
+const FOCUS_COMMAND = 'focus';
+const BLUR_COMMAND = 'blur';
+function isHostInstance(node) {
+    return typeof Reflect.get(node, 'measure') === 'function';
+}
+// Augment the retained node with the public-instance methods, once. The same node
+// instance persists across commits, so attaching once is enough, every method reads
+// the live handle through the engine on each call.
+export function toPublicInstance(node) {
+    if (isHostInstance(node))
+        return node;
+    return Object.assign(node, {
+        measure(callback) {
+            engineMeasure(node, callback);
+        },
+        measureInWindow(callback) {
+            engineMeasureInWindow(node, callback);
+        },
+        measureLayout(relativeToNativeNode, onSuccess, onFail) {
+            if (!isSymbioteNode(relativeToNativeNode)) {
+                dlog('measureLayout: relative target must be a host ref');
+                return;
+            }
+            engineMeasureLayout(node, relativeToNativeNode, onSuccess, onFail);
+        },
+        setNativeProps(nativeProps) {
+            engineSetNativeProps(node, nativeProps);
+        },
+        focus() {
+            dispatchViewCommand(node, FOCUS_COMMAND, []);
+        },
+        blur() {
+            dispatchViewCommand(node, BLUR_COMMAND, []);
+        },
+    });
+}

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

@@ -0,0 +1,13 @@
+export type II18nManagerConstants = {
+    isRTL: boolean;
+    doLeftAndRightSwapInRTL: boolean;
+    localeIdentifier?: string;
+};
+export declare const I18nManager: {
+    isRTL: boolean;
+    doLeftAndRightSwapInRTL: boolean;
+    getConstants(): II18nManagerConstants;
+    allowRTL(allow: boolean): void;
+    forceRTL(force: boolean): void;
+    swapLeftAndRightInRTL(swap: boolean): void;
+};

package/build/i18n-manager/index.js

@@ -0,0 +1,91 @@
+// I18nManager module: exposes RTL (right-to-left) layout state and lets the app
+// allow / force / swap-left-and-right RTL. Mirrors RN's
+// Libraries/ReactNative/I18nManager.js, iOS path only. RN reads the native
+// constants eagerly at module load (a synchronous getConstants) and exposes them
+// both via getConstants() and as the plain `isRTL` / `doLeftAndRightSwapInRTL`
+// fields; we keep that shape. The setters are imperative JS->native calls with no
+// Fabric view of their own, like Vibration / Keyboard.
+//
+// The native contract is confirmed from RN's TurboModule spec at
+// specs_DEPRECATED/modules/INativeI18nManager.js (`'I18nManager'`):
+//   getConstants(): { doLeftAndRightSwapInRTL, isRTL, localeIdentifier? }
+//   allowRTL(allowRTL: boolean)
+//   forceRTL(forceRTL: boolean)
+//   swapLeftAndRightInRTL(flipStyles: boolean)
+import { dlog } from '../debug';
+import { getNativeModule } from '../native-modules';
+// The iOS native module name RN registers this under (the same name on both
+// platforms). NOTE: per the symbiote invariant, a module name is only provable on
+// a real host (a headless fake answers to any name); this name is
+// device-verify-pending. See .docs/native-module-platform-routing.md.
+const I18N_MANAGER_MODULE = 'I18nManager';
+// RN's fallback constants when no native module is linked (headless / not yet on
+// device): not RTL, and the iOS default of swapping in RTL.
+const DEFAULT_CONSTANTS = {
+    isRTL: false,
+    doLeftAndRightSwapInRTL: true,
+};
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+// Narrow the untyped native getConstants() return into our type: a runtime guard
+// at the trust boundary rather than an `as`. Falls back to the defaults if any
+// field is missing or the wrong type.
+function readConstants(module) {
+    const raw = module.getConstants();
+    if (typeof raw !== 'object' || raw === null)
+        return DEFAULT_CONSTANTS;
+    const isRTL = Reflect.get(raw, 'isRTL');
+    const doLeftAndRightSwapInRTL = Reflect.get(raw, 'doLeftAndRightSwapInRTL');
+    const localeIdentifier = Reflect.get(raw, 'localeIdentifier');
+    if (!isBoolean(isRTL) || !isBoolean(doLeftAndRightSwapInRTL))
+        return DEFAULT_CONSTANTS;
+    const constants = { isRTL, doLeftAndRightSwapInRTL };
+    if (isOptionalString(localeIdentifier) && localeIdentifier !== undefined) {
+        constants.localeIdentifier = localeIdentifier;
+    }
+    return constants;
+}
+// Resolved once, at module load: RN reads the constants eagerly via a single
+// synchronous getConstants. `null` when the module isn't linked.
+const i18nModule = getNativeModule(I18N_MANAGER_MODULE);
+dlog(`I18nManager: module ${i18nModule ? 'resolved' : 'NOT resolved (null)'}`);
+const constants = i18nModule === null ? DEFAULT_CONSTANTS : readConstants(i18nModule);
+export const I18nManager = {
+    isRTL: constants.isRTL,
+    doLeftAndRightSwapInRTL: constants.doLeftAndRightSwapInRTL,
+    getConstants() {
+        return constants;
+    },
+    // Allow the app to render RTL when the device locale is RTL. No-op (logged)
+    // without a module: a missing native module must never throw on a device.
+    allowRTL(allow) {
+        if (i18nModule === null) {
+            dlog('I18nManager.allowRTL -> I18nManager native module unavailable, no-op');
+            return;
+        }
+        dlog(`I18nManager.allowRTL -> ${allow}`);
+        i18nModule.allowRTL(allow);
+    },
+    // Force RTL regardless of the device locale (takes effect after an app reload).
+    forceRTL(force) {
+        if (i18nModule === null) {
+            dlog('I18nManager.forceRTL -> I18nManager native module unavailable, no-op');
+            return;
+        }
+        dlog(`I18nManager.forceRTL -> ${force}`);
+        i18nModule.forceRTL(force);
+    },
+    // Control whether left/right style properties flip in RTL.
+    swapLeftAndRightInRTL(swap) {
+        if (i18nModule === null) {
+            dlog('I18nManager.swapLeftAndRightInRTL -> I18nManager native module unavailable, no-op');
+            return;
+        }
+        dlog(`I18nManager.swapLeftAndRightInRTL -> ${swap}`);
+        i18nModule.swapLeftAndRightInRTL(swap);
+    },
+};

package/build/index.d.ts

@@ -0,0 +1,80 @@
+export { createElement, createRawText, createAnchor, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, getExplicitStyle, setText, isSymbioteNode, RAW_TEXT_COMPONENT, } from './node';
+export { isEventFor } from './view-config';
+export { registerComponent, setNativeViewConfigSource } from './registry';
+export { InteractionManager, Events as InteractionManagerEvents } from './interaction-manager';
+export type { IInteractionEvent, ISimpleTask, IPromiseTask, ITask, IHandle, ICancellable, } from './interaction-manager';
+export { default as PanResponder } from './pan-responder';
+export type { IPanResponderGestureState, IPanResponderCallbacks, IGestureResponderHandlers, IPanResponderInstance, } from './pan-responder';
+export type { IComponentRegistration, INativeEventBinding, INativeViewConfig, INativeViewConfigSource, IPropProcessor, } from './registry';
+export type { ISymbioteNode, ISymbioteEvent, IListener } from './node';
+export { SymbioteSurface, createSurface } from './surface';
+export { setEventDispatcher } from './dispatch';
+export { setColorProcessor, processColor, dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, } from './commit';
+export { toPublicInstance } from './host-instance';
+export type { IHostInstance } from './host-instance';
+export { PlatformColor, DynamicColorIOS, isOpaqueColorValue } from './platform-color';
+export type { IColorValue, IOpaqueColorValue, IDynamicColorIOSTuple } from './platform-color';
+export { processBoxShadow } from './process-box-shadow';
+export type { IParsedBoxShadow } from './process-box-shadow';
+export { processFilter } from './process-filter';
+export type { IParsedFilter, IParsedDropShadow } from './process-filter';
+export { processTransformOrigin } from './process-transform-origin';
+export { processTransform } from './process-transform';
+export { processAspectRatio } from './process-aspect-ratio';
+export { processFontVariant } from './process-font-variant';
+export { processBackgroundImage } from './process-background-image';
+export type { IParsedBackgroundImage } from './process-background-image';
+export { flattenStyle } from './style';
+export type { IViewStyle, ITextStyle, IStyleProp, IDimensionValue, IFlexAlign, IFlexJustify, ITransformProp, IBoxShadowValue, IDropShadowValue, IFilterFunction, IColorStopValue, ILinearGradientValue, IRadialGradientValue, IRadialGradientPosition, IRadialGradientShape, IRadialGradientSize, IBackgroundImageValue, IBlendMode, } from './styles';
+export { StyleSheet, computeHairlineWidth } from './style-sheet';
+export { registerStyles, resolveClassName, clearGlobalStyles, scopeClassName, isClassNameValue, } from './style-registry';
+export type { IClassNameValue, IClassToggleMap, IScopableClassValue } from './style-registry';
+export { Platform } from './platform';
+export type { IPlatformStatic, IPlatformOSType, IPlatformSelectSpec } from './platform';
+export type { IPlatformConstantsIOS } from './platform/index.ios';
+export type { IPlatformConstantsAndroid } from './platform/index.android';
+export { dlog, isDebug } from './debug';
+export { getNativeModule, getEnforcingNativeModule } from './native-modules';
+export { installDeviceEventHub, NativeEventEmitter, setDeviceEventSource } from './native-events';
+export type { IEventSubscription, IEventEmitterModule, INativeEventListener, IDeviceEventSource, } from './native-events';
+export { AnimatedNode, AnimatedWithChildren, AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedInterpolation, AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, AnimatedEvent, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, flushValue, Easing, createNumericInterpolation, checkValidRanges, TimingAnimation, SpringAnimation, DecayAnimation, AnimatedTracking, timing, spring, decay, parallel, sequence, stagger, loop, delay, nativeAnimated, isNativeAnimatedAvailable, AnimatedProps, AnimatedStyle, AnimatedTransform, AnimatedMock, reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './animated';
+export type { IValueXY, IRgbaValue, IColorInput, IEventConfig, IEventListener, IAnimatedEventHandler, INativeEventAttachment, IValueListener, IEasingFunction, IInterpolationConfig, IExtrapolateType, IAnimation, IEndCallback, IEndResult, ICompositeAnimation, ITimingConfig, ISpringConfig, IDecayConfig, IParallelConfig, ILoopAnimationConfig, INativeNodeConfig, INativeAnimationConfig, INativeEventMapping, IPlatformConfig, } from './animated';
+export { getSlot } from './fabric';
+export type { IFabricSlot, IFabricNode, IFabricChildSet, IFabricProps, IFabricEventHandler, IRootTag, IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess, } from './fabric';
+export { Alert } from './alert';
+export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlertOptions, } from './alert';
+export { Share } from './share';
+export type { IShareContent, IShareOptions, IShareAction } from './share';
+export { ActionSheetIOS } from './action-sheet-ios';
+export type { IActionSheetIOSOptions, IShareActionSheetIOSOptions, IShareActionSheetError, } from './action-sheet-ios';
+export { Linking } from './linking';
+export type { IUrlEvent } from './linking';
+export { Vibration } from './vibration';
+export { ToastAndroid } from './toast-android';
+export { Settings } from './settings';
+export { I18nManager } from './i18n-manager';
+export type { II18nManagerConstants } from './i18n-manager';
+export { Dimensions } from './dimensions';
+export type { IDisplayMetrics, IDisplayMetricsAndroid, IDimensionsPayload, IDimensionsSet, IDimensionsKey, IDimensionsChangeListener, IDimensionsStatic, } from './dimensions';
+export { PixelRatio } from './pixel-ratio';
+export type { IPixelRatioStatic } from './pixel-ratio';
+export { Appearance } from './appearance';
+export type { IColorSchemeName, IColorSchemePreference } from './appearance';
+export { AppState } from './app-state';
+export type { IAppStateStatus, IAppStateEvent } from './app-state';
+export { createAppRegistry } from './app-registry';
+export type { IAppRegistry, ICreateAppRegistryResult, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from './app-registry';
+export { Keyboard, KEYBOARD_EVENT } from './keyboard';
+export type { IKeyboardEventName, IKeyboardEvent, IKeyboardMetrics } from './keyboard';
+export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, } from './text-input-state';
+export { LayoutAnimation } from './layout-animation';
+export type { ILayoutAnimationType, ILayoutAnimationProperty, ILayoutAnimationConfig, ILayoutAnimationAnim, ILayoutAnimationTypes, ILayoutAnimationProperties, } from './layout-animation';
+export { BackHandler } from './back-handler';
+export type { IBackPressEventName, IBackPressHandler } from './back-handler';
+export { PermissionsAndroid, PERMISSIONS, RESULTS } from './permissions-android';
+export type { IPermission, IPermissionStatus, IRationale } from './permissions-android';
+export { AccessibilityInfo } from './accessibility-info';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityInfoStatic, IAccessibilityEventType, IAccessibilityHandle, } from './accessibility-info/shared';
+export { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight } from './status-bar';
+export { hideTransition, STATUS_BAR_MANAGER, ANIMATED_HIDE_TRANSITION, STATIC_HIDE_TRANSITION, } from './status-bar/shared';
+export type { IStatusBarProps, IStatusBarStyle, IStatusBarAnimation, IStatusBarImperative, } from './status-bar/shared';

package/build/index.js

@@ -0,0 +1,72 @@
+// @symbiote-native/engine: the retained shadow-tree + clone-on-write commit engine.
+// Every framework adapter drives this tiny mutation API; all Fabric-specific
+// logic (tag allocation, view-name resolution, clone-on-write, event
+// normalization) lives behind it, in one place.
+export { createElement, createRawText, createAnchor, isAnchor, appendChild, insertBefore, removeChild, setProp, setEventListener, routeProp, getExplicitStyle, setText, isSymbioteNode, RAW_TEXT_COMPONENT, } from './node';
+export { isEventFor } from './view-config';
+export { registerComponent, setNativeViewConfigSource } from './registry';
+// InteractionManager: pure JS (timers + emitter), framework-agnostic, so it lives
+// here; every adapter re-exports it.
+export { InteractionManager, Events as InteractionManagerEvents } from './interaction-manager';
+// PanResponder: pure JS gesture recognition over the View responder props,
+// framework-agnostic, so it lives here; every adapter re-exports it.
+export { default as PanResponder } from './pan-responder';
+export { SymbioteSurface, createSurface } from './surface';
+export { setEventDispatcher } from './dispatch';
+export { setColorProcessor, processColor, dispatchViewCommand, sendAccessibilityEvent, setNativeProps, getNativeTag, getNativeNode, whenCommitted, measure, measureInWindow, measureLayout, disposeRoot, } from './commit';
+// The public instance grafted onto a host node by every adapter (React's getPublicInstance,
+// the Vue renderer's createElement): the imperative measure/setNativeProps/focus API. Lives
+// here because it depends only on engine internals, so all adapters inherit it identically.
+export { toPublicInstance } from './host-instance';
+export { PlatformColor, DynamicColorIOS, isOpaqueColorValue } from './platform-color';
+// CSS-style processors (boxShadow/filter): RN parses these in JS before native because
+// enableNativeCSSParsing() defaults to false. Exported so an adapter / test can reuse them.
+export { processBoxShadow } from './process-box-shadow';
+export { processFilter } from './process-filter';
+export { processTransformOrigin } from './process-transform-origin';
+export { processTransform } from './process-transform';
+export { processAspectRatio } from './process-aspect-ratio';
+export { processFontVariant } from './process-font-variant';
+export { processBackgroundImage } from './process-background-image';
+export { flattenStyle } from './style';
+export { StyleSheet, computeHairlineWidth } from './style-sheet';
+export { registerStyles, resolveClassName, clearGlobalStyles, scopeClassName, isClassNameValue, } from './style-registry';
+export { Platform } from './platform';
+export { dlog, isDebug } from './debug';
+export { getNativeModule, getEnforcingNativeModule } from './native-modules';
+export { installDeviceEventHub, NativeEventEmitter, setDeviceEventSource } from './native-events';
+export { AnimatedNode, AnimatedWithChildren, AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedInterpolation, AnimatedAddition, AnimatedSubtraction, AnimatedMultiplication, AnimatedDivision, AnimatedModulo, AnimatedDiffClamp, AnimatedEvent, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, attachNativeEvent, attachNativeEventHandler, flushValue, Easing, createNumericInterpolation, checkValidRanges, TimingAnimation, SpringAnimation, DecayAnimation, AnimatedTracking, timing, spring, decay, parallel, sequence, stagger, loop, delay, nativeAnimated, isNativeAnimatedAvailable, AnimatedProps, AnimatedStyle, AnimatedTransform, AnimatedMock, reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './animated';
+export { getSlot } from './fabric';
+// Imperative runtime modules: framework-agnostic native-bridge consumers (no visual, no
+// lifecycle), moved here from @symbiote-native/react so every adapter re-exports the SAME module.
+// Native module names are platform-selected and device-verified, not headless (CLAUDE.md
+// <native_module_name_is_platform_specific>).
+export { Alert } from './alert';
+export { Share } from './share';
+export { ActionSheetIOS } from './action-sheet-ios';
+export { Linking } from './linking';
+export { Vibration } from './vibration';
+export { ToastAndroid } from './toast-android';
+export { Settings } from './settings';
+export { I18nManager } from './i18n-manager';
+// Device-state / event modules (Dimensions, Appearance, AppState, Keyboard, …).
+export { Dimensions } from './dimensions';
+// PixelRatio: derives from the Dimensions singleton, framework-agnostic, so it lives
+// here; every adapter re-exports it.
+export { PixelRatio } from './pixel-ratio';
+export { Appearance } from './appearance';
+export { AppState } from './app-state';
+// AppRegistry core: registry bookkeeping + host-registrar bridge + headless tasks, shared by
+// every adapter. Each adapter calls createAppRegistry with its own runnableFor (the one
+// framework-specific seam — how to build a runnable from a component provider).
+export { createAppRegistry } from './app-registry';
+export { Keyboard, KEYBOARD_EVENT } from './keyboard';
+export { currentlyFocusedInput, setInputFocused, setInputBlurred, blurTextInput, } from './text-input-state';
+export { LayoutAnimation } from './layout-animation';
+export { BackHandler } from './back-handler';
+export { PermissionsAndroid, PERMISSIONS, RESULTS } from './permissions-android';
+export { AccessibilityInfo } from './accessibility-info';
+// StatusBar: values from the platform-selected './status-bar', types from '-shared' (the
+// .ios re-export would otherwise duplicate-export the type symbols).
+export { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight } from './status-bar';
+export { hideTransition, STATUS_BAR_MANAGER, ANIMATED_HIDE_TRANSITION, STATIC_HIDE_TRANSITION, } from './status-bar/shared';

package/build/interaction-manager/index.d.ts

@@ -0,0 +1,45 @@
+export declare const Events: {
+    readonly interactionStart: "interactionStart";
+    readonly interactionComplete: "interactionComplete";
+};
+export type IInteractionEvent = (typeof Events)[keyof typeof Events];
+export type ISimpleTask = {
+    name: string;
+    run: () => void;
+};
+export type IPromiseTask = {
+    name: string;
+    gen: () => Promise<unknown>;
+};
+export type ITask = ISimpleTask | IPromiseTask | (() => void);
+export type IHandle = number;
+export type ICancellable<T> = {
+    then: Promise<T>['then'];
+    done: (onDone?: () => void) => void;
+    cancel: () => void;
+};
+type IEventListener = (...args: unknown[]) => void;
+declare class InteractionManagerImpl {
+    readonly Events: {
+        readonly interactionStart: "interactionStart";
+        readonly interactionComplete: "interactionComplete";
+    };
+    private emitter;
+    private taskQueue;
+    private interactionHandleCount;
+    private nextHandle;
+    private deadline;
+    private flushScheduled;
+    addListener(eventType: IInteractionEvent, listener: IEventListener): {
+        remove: () => void;
+    };
+    runAfterInteractions(task?: ITask): ICancellable<void>;
+    createInteractionHandle(): IHandle;
+    clearInteractionHandle(handle: IHandle): void;
+    setDeadline(deadline: number): void;
+    private runTask;
+    private scheduleFlush;
+    private flushQueue;
+}
+export declare const InteractionManager: InteractionManagerImpl;
+export {};