@symbiote-native/solid 3.2.0 → 3.4.0

package/build/components/virtualized-list/virtualized-list-props.js

@@ -0,0 +1,53 @@
+// The public prop contract of the Solid VirtualizedList
+// Consumed by the lifecycle itself, everything LEFT OVER is the accessibility surface that rides
+// down onto the scroll host
+export const HANDLED_PROPS = [
+    'data',
+    'getItem',
+    'getItemCount',
+    'renderItem',
+    'ListItemComponent',
+    'getItemLayout',
+    'initialNumToRender',
+    'windowSize',
+    'disableVirtualization',
+    'ListHeaderComponent',
+    'ListFooterComponent',
+    'ListEmptyComponent',
+    'ItemSeparatorComponent',
+    'CellRendererComponent',
+    'ref',
+    'onEndReached',
+    'onEndReachedThreshold',
+    'onStartReached',
+    'onStartReachedThreshold',
+    'keyExtractor',
+    'onViewableItemsChanged',
+    'viewabilityConfig',
+    'viewabilityConfigCallbackPairs',
+    'onScroll',
+    'onScrollBeginDrag',
+    'onScrollEndDrag',
+    'onMomentumScrollBegin',
+    'onMomentumScrollEnd',
+    'scrollEventThrottle',
+    'keyboardShouldPersistTaps',
+    'keyboardDismissMode',
+    'horizontal',
+    'inverted',
+    'style',
+    'contentContainerStyle',
+    'ListHeaderComponentStyle',
+    'ListFooterComponentStyle',
+    'class',
+    'onScrollToIndexFailed',
+    'onRefresh',
+    'refreshing',
+    'progressViewOffset',
+    'stickyHeaderIndices',
+    'maintainVisibleContentPosition',
+    'initialScrollIndex',
+    'maxToRenderPerBatch',
+    'updateCellsBatchingPeriod',
+    'extraData',
+];

package/build/components/virtualized-section-list/index.d.ts

@@ -1,30 +1,37 @@
 import { type Accessor, type Ref } from 'solid-js';
 import type { JSX } from '../../jsx-runtime';
-import { type ISection, type IAccessibilityProps, type IAriaProps, type ISeparatorProps, type ISeparators, type IVirtualizedSectionListHandle } from '@symbiote-native/components';
+import { type ISection as ICoreSection, type IAccessibilityProps, type IAriaProps, type IInnerViewRef, type ISeparatorProps, type ISeparators, type IVirtualizedSectionListHandle } from '@symbiote-native/components';
 import { type IClassNameValue, type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
-export type { ISection, IVirtualizedSectionListHandle };
-export interface ISectionHeaderInfo<ItemT> {
+import { type ICellRendererComponent } from '../virtualized-list';
+export type { IVirtualizedSectionListHandle };
+export type ISection<ItemT> = ICoreSection<ItemT> & {
+    renderItem?: (info: Accessor<ISectionCellInfo<ItemT>>) => JSX.Element;
+    ItemSeparatorComponent?: (props: ISeparatorProps<ItemT>) => JSX.Element;
+};
+export type ISectionHeaderInfo<ItemT> = {
     section: ISection<ItemT>;
-}
-export interface ISectionCellInfo<ItemT> {
+};
+export type ISectionCellInfo<ItemT> = {
     item: ItemT;
     index: number;
     section: ISection<ItemT>;
     separators: ISeparators;
-}
-export interface IVirtualizedSectionListProps<ItemT> extends IAccessibilityProps, IAriaProps {
+};
+export type IVirtualizedSectionListProps<ItemT> = IAccessibilityProps & IAriaProps & {
     sections: ReadonlyArray<ISection<ItemT>>;
     renderItem: (info: Accessor<ISectionCellInfo<ItemT>>) => JSX.Element;
     renderSectionHeader?: (info: Accessor<ISectionHeaderInfo<ItemT>>) => JSX.Element;
     renderSectionFooter?: (info: Accessor<ISectionHeaderInfo<ItemT>>) => JSX.Element;
     stickySectionHeadersEnabled?: boolean;
-    SectionSeparatorComponent?: () => JSX.Element;
+    SectionSeparatorComponent?: (props: ISeparatorProps<ItemT>) => JSX.Element;
     keyExtractor?: (item: ItemT, index: number) => string;
     ItemSeparatorComponent?: (props: ISeparatorProps<ItemT>) => JSX.Element;
     ref?: Ref<IVirtualizedSectionListHandle>;
     ListHeaderComponent?: JSX.Element;
     ListFooterComponent?: JSX.Element;
     ListEmptyComponent?: JSX.Element;
+    ListHeaderComponentStyle?: IStyleProp<IViewStyle>;
+    ListFooterComponentStyle?: IStyleProp<IViewStyle>;
     extraData?: unknown;
     onEndReached?: (info: {
         distanceFromEnd: number;
@@ -42,7 +49,10 @@ export interface IVirtualizedSectionListProps<ItemT> extends IAccessibilityProps
     maxToRenderPerBatch?: number;
     updateCellsBatchingPeriod?: number;
     windowSize?: number;
+    disableVirtualization?: boolean;
+    CellRendererComponent?: ICellRendererComponent<unknown>;
     inverted?: boolean;
+    horizontal?: boolean;
     maintainVisibleContentPosition?: {
         minIndexForVisible: number;
         autoscrollToTopThreshold?: number;
@@ -52,13 +62,16 @@ export interface IVirtualizedSectionListProps<ItemT> extends IAccessibilityProps
     onScrollEndDrag?: (event: ISymbioteEvent) => void;
     onMomentumScrollBegin?: (event: ISymbioteEvent) => void;
     onMomentumScrollEnd?: (event: ISymbioteEvent) => void;
+    onContentSizeChange?: (width: number, height: number) => void;
     scrollEventThrottle?: number;
     keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
     keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
     removeClippedSubviews?: boolean;
     nestedScrollEnabled?: boolean;
+    stickyHeaderHiddenOnScroll?: boolean;
+    innerViewRef?: IInnerViewRef;
     style?: IStyleProp<IViewStyle>;
     contentContainerStyle?: IStyleProp<IViewStyle> | string;
     class?: IClassNameValue;
-}
+};
 export declare function VirtualizedSectionList<ItemT>(props: IVirtualizedSectionListProps<ItemT>): JSX.Element;

package/build/components/virtualized-section-list/index.jsx

@@ -1,12 +1,10 @@
-// VirtualizedSectionList: sections flattened into one virtualized stream. Each section contributes
-// a header row, its item rows, then a footer row; the flattened tagged sequence feeds
-// VirtualizedList as a single list, so headers, items and footers are windowed by the same
-// machinery. The flattening, entry keying, separator-item unwrap and scrollToLocation mapping are
-// shared verbatim from @symbiote-native/components; this file wires only Solid's lifecycle.
+// Sections flattened into one virtualized stream: header, items and footer per section
+// Flattening, keying and `scrollToLocation` are shared, this file wires Solid's lifecycle
 import { createMemo, splitProps } from 'solid-js';
-import { flattenSections, resolveStickySectionHeaders, scrollLocationToFlatIndex, sectionEntryKey, unwrapEntryItem, } from '@symbiote-native/components';
+import { cellGapsFor, createSeparatorBoard, flattenSections, renderSectionEntry, resolveScrollLocation, resolveStickySectionHeaders, routeScrollHandle, SECTION_ENTRY_KIND, SEPARATOR_GAP_KIND, sectionEntryKey, } from '@symbiote-native/components';
 import { Platform, dlog, } from '@symbiote-native/engine';
 import { VirtualizedList, } from '../virtualized-list';
+import { SectionItemCell } from './section-item-cell.jsx';
 // Consumed by this layer; everything LEFT OVER is VirtualizedList's own surface (the scroll host,
 // the list chrome, the windowing knobs, the accessibility props) and rides down untouched, exactly
 // as React's VirtualizedSectionList spreads its `...rest` onto the inner list.
@@ -21,125 +19,99 @@ const HANDLED_PROPS = [
     'stickySectionHeadersEnabled',
     'ref',
 ];
-export function VirtualizedSectionList(props) {
-    const [, listRest] = splitProps(props, HANDLED_PROPS);
-    const flattened = createMemo(() => flattenSections(props.sections, props.SectionSeparatorComponent !== undefined));
-    const entries = () => flattened().entries;
-    // RN sticks section headers by default only on iOS; Android does not unless asked. The
-    // headerIndices are the flat positions of every section header, which the inner list wraps.
-    const stickyHeaderIndices = () => resolveStickySectionHeaders(props.stickySectionHeadersEnabled, flattened().headerIndices, Platform.OS);
-    // The entry under a row keeps its KIND for as long as the row lives — sectionEntryKey namespaces
-    // header/footer/separator keys away from item keys, so <For> never hands a row an entry of a
-    // different kind. `previous` covers only the tick where new sections have landed but the row has
-    // not been disposed yet, during which the row's index can point at a neighbouring entry.
-    function sectionInfo(info, initial) {
-        return createMemo((previous) => {
-            const entry = info().item;
-            return entry.kind === 'section-separator'
-                ? previous
-                : { section: entry.section };
-        }, { section: initial });
-    }
-    function cellInfo(info, initial) {
-        return createMemo((previous) => {
-            const entry = info().item;
-            if (entry.kind !== 'item')
-                return previous;
-            return {
-                item: entry.item,
-                index: entry.itemIndex,
-                section: entry.section,
-                separators: info().separators,
-            };
-        }, initial);
-    }
-    // The inner list, held by identity in a plain variable: everything this handle adds over
-    // VirtualizedList's own is the (section, item) -> flat index resolution, and the rest routes
-    // straight through — the shared IScrollRoutingHandle tail both list handles extend.
-    let inner;
-    const handle = {
+// Every entry kind carries its section, so a row whose index briefly points at a neighbour
+// still reads a valid one
+function sectionInfoOf(info) {
+    return createMemo(() => ({ section: info().item.section }));
+}
+function cellInfoOf(info, initial) {
+    return createMemo((previous) => {
+        const entry = info().item;
+        if (entry.kind !== SECTION_ENTRY_KIND.item)
+            return previous;
+        return {
+            item: entry.item,
+            index: entry.itemIndex,
+            section: entry.section,
+            separators: initial.separators,
+        };
+    }, initial);
+}
+// The separator for a gap: the section one, or the item one where a section's own beats the list's
+function separatorRenderFor(gap, props) {
+    if (gap.props === undefined)
+        return undefined;
+    const gapProps = gap.props;
+    const Separator = gap.kind === SEPARATOR_GAP_KIND.section
+        ? props.SectionSeparatorComponent
+        : (gapProps.section.ItemSeparatorComponent ??
+            props.ItemSeparatorComponent);
+    if (Separator === undefined)
+        return undefined;
+    return ({ isHighlighted, override }) => (<Separator highlighted={isHighlighted} {...gapProps} {...override}/>);
+}
+// An item entry becomes a cell that paints its own separators around the row
+function itemCellFor(rendering, info, entry) {
+    const { props, entries, keyOf } = rendering;
+    const gaps = createMemo(() => cellGapsFor(entries(), info().index));
+    const renderItem = entry.section.renderItem ?? props.renderItem;
+    return (<SectionItemCell board={rendering.board} cellKey={createMemo(() => keyOf(info().item))} prevCellKey={createMemo(() => {
+            const previous = entries()[info().index - 1];
+            return previous === undefined ? undefined : keyOf(previous);
+        })} renderItem={separators => renderItem(cellInfoOf(info, {
+            item: entry.item,
+            index: entry.itemIndex,
+            section: entry.section,
+            separators,
+        }))} leadingSeparator={createMemo(() => separatorRenderFor(gaps().leading, props))} trailingSeparator={createMemo(() => separatorRenderFor(gaps().trailing, props))} isInverted={props.inverted === true}/>);
+}
+// Called once per cell, `buildCell` of `VirtualizedList` already untracks it
+function entryRendererFor(rendering) {
+    const { props } = rendering;
+    return info => renderSectionEntry({
+        header: () => props.renderSectionHeader?.(sectionInfoOf(info)),
+        footer: () => props.renderSectionFooter?.(sectionInfoOf(info)),
+        item: entry => itemCellFor(rendering, info, entry),
+    }, info().item);
+}
+// This handle adds the (section, item) to flat index resolution over the list's own handle
+// The rest routes straight through the shared `IScrollRoutingHandle` tail
+function buildSectionHandle(getInner, locate) {
+    return {
         scrollToLocation: (params) => {
-            const flatIndex = scrollLocationToFlatIndex(flattened().headerIndices, params.sectionIndex, params.itemIndex);
-            if (flatIndex === undefined) {
+            const target = locate(params);
+            if (target === undefined) {
                 dlog(`VirtualizedSectionList scrollToLocation: section ${params.sectionIndex} out of range`);
                 return;
             }
             dlog(`VirtualizedSectionList scrollToLocation section=${params.sectionIndex} ` +
-                `item=${params.itemIndex} -> flat ${flatIndex}`);
-            inner?.scrollToIndex({
-                index: flatIndex,
-                viewOffset: params.viewOffset,
-                viewPosition: params.viewPosition,
-                animated: params.animated,
-            });
-        },
-        flashScrollIndicators: () => {
-            inner?.flashScrollIndicators();
-        },
-        getNativeScrollRef: () => inner?.getNativeScrollRef() ?? null,
-        getScrollableNode: () => inner?.getScrollableNode() ?? null,
-        getScrollResponder: () => inner?.getScrollResponder() ?? null,
-        getScrollNode: () => inner?.getScrollNode() ?? null,
-        recordInteraction: () => {
-            inner?.recordInteraction();
+                `item=${params.itemIndex} -> flat ${target.index}`);
+            getInner()?.scrollToIndex(target);
         },
+        ...routeScrollHandle(getInner),
     };
+}
+export function VirtualizedSectionList(props) {
+    const [, listRest] = splitProps(props, HANDLED_PROPS);
+    const flattened = createMemo(() => flattenSections(props.sections));
+    const entries = () => flattened().entries;
+    // RN sticks section headers by default only on iOS; Android does not unless asked. The
+    // headerIndices are the flat positions of every section header, which the inner list wraps.
+    const stickyHeaderIndices = () => resolveStickySectionHeaders(props.stickySectionHeadersEnabled, flattened().headerIndices, Platform.OS);
+    // The inner list, held by identity in a plain variable
+    let inner;
+    const handle = buildSectionHandle(() => inner, params => resolveScrollLocation(flattened().headerIndices, stickyHeaderIndices(), params));
     if (typeof props.ref === 'function')
         props.ref(handle);
-    // Section chrome keys off its section (and never reaches the user's extractor, which is typed on
-    // ItemT); an item keys off the user's extractor with its index INSIDE its section.
-    function entryKeyExtractor(entry, index) {
-        return sectionEntryKey(entry, index, props.keyExtractor);
-    }
-    function entrySeparatorProps(entryProps) {
-        return {
-            ...entryProps,
-            leadingItem: unwrapEntryItem(entryProps.leadingItem),
-            trailingItem: unwrapEntryItem(entryProps.trailingItem),
-        };
-    }
-    // The user's separator is typed on ItemT while the inner stream carries the entry wrapper, so
-    // each side is unwrapped back to its item — undefined for a gap next to section chrome, which has
-    // no item on that side.
-    const entrySeparatorComponent = createMemo(() => {
-        const ItemSeparator = props.ItemSeparatorComponent;
-        if (ItemSeparator === undefined)
-            return undefined;
-        // ONE bag, not a spread plus two overriding attributes: Solid's mergeProps resolves a key by
-        // scanning its sources back to front and taking the first NON-undefined value, so an override
-        // that unwraps to `undefined` (every gap next to section chrome) falls back to the raw entry
-        // instead of clearing it, and the user's `leadingItem` reads as the wrapper object. Building the
-        // whole bag in one function keeps a single source — and, being a spread of a CALL, it compiles
-        // to mergeProps(() => …) so the separator's props stay live.
-        return (entryProps) => (<ItemSeparator {...entrySeparatorProps(entryProps)}/>);
+    // Section chrome keys off its section and never reaches the user's extractor, typed on ItemT
+    const entryKeyExtractor = (entry) => sectionEntryKey(entry, props.keyExtractor);
+    const renderEntry = entryRendererFor({
+        props,
+        entries,
+        board: createSeparatorBoard(),
+        keyOf: entryKeyExtractor,
     });
-    // Called ONCE per cell and already untracked by VirtualizedList's buildCell.
-    function renderEntry(info) {
-        const entry = info().item;
-        if (entry.kind === 'header') {
-            const header = props.renderSectionHeader;
-            return header === undefined
-                ? undefined
-                : header(sectionInfo(info, entry.section));
-        }
-        if (entry.kind === 'footer') {
-            const footer = props.renderSectionFooter;
-            return footer === undefined
-                ? undefined
-                : footer(sectionInfo(info, entry.section));
-        }
-        if (entry.kind === 'section-separator') {
-            const SectionSeparator = props.SectionSeparatorComponent;
-            return SectionSeparator === undefined ? undefined : <SectionSeparator />;
-        }
-        return props.renderItem(cellInfo(info, {
-            item: entry.item,
-            index: entry.itemIndex,
-            section: entry.section,
-            separators: info().separators,
-        }));
-    }
-    return (<VirtualizedList {...listRest} data={entries()} getItem={(_source, index) => entries()[index]} getItemCount={() => entries().length} renderItem={renderEntry} stickyHeaderIndices={stickyHeaderIndices()} keyExtractor={entryKeyExtractor} ItemSeparatorComponent={entrySeparatorComponent()} ref={list => {
+    return (<VirtualizedList {...listRest} data={entries()} getItem={(_source, index) => entries()[index]} getItemCount={() => entries().length} renderItem={renderEntry} stickyHeaderIndices={stickyHeaderIndices()} keyExtractor={entryKeyExtractor} ref={list => {
             inner = list;
         }}/>);
 }

package/build/components/virtualized-section-list/section-item-cell.d.ts

@@ -0,0 +1,18 @@
+import { type Accessor } from 'solid-js';
+import type { JSX } from '../../jsx-runtime';
+import { type ISeparatorBoard, type ISeparators } from '@symbiote-native/components';
+export type ISeparatorState = {
+    isHighlighted: boolean;
+    override: Record<string, unknown> | undefined;
+};
+export type ISeparatorRender = (state: ISeparatorState) => JSX.Element;
+export type ISectionItemCellProps = {
+    board: ISeparatorBoard<Record<string, unknown>>;
+    cellKey: Accessor<string>;
+    prevCellKey: Accessor<string | undefined>;
+    renderItem: (separators: ISeparators) => JSX.Element;
+    leadingSeparator: Accessor<ISeparatorRender | undefined>;
+    trailingSeparator: Accessor<ISeparatorRender | undefined>;
+    isInverted: boolean;
+};
+export declare function SectionItemCell(props: ISectionItemCellProps): JSX.Element;

package/build/components/virtualized-section-list/section-item-cell.jsx

@@ -0,0 +1,37 @@
+// Item cell with its separators around it, as in RN's `ItemWithSeparator`
+// Their state sits in a shared board, т.к. `highlight()` also lights the previous cell's one
+import { createEffect, createSignal, onCleanup, untrack, } from 'solid-js';
+import { createCellSeparators, } from '@symbiote-native/components';
+export function SectionItemCell(props) {
+    const { board } = props;
+    const [state, setState] = createSignal(untrack(() => board.read(props.cellKey())));
+    createEffect(() => {
+        const cellKey = props.cellKey();
+        setState(board.read(cellKey));
+        const unsubscribe = board.subscribe(cellKey, () => setState(board.read(cellKey)));
+        onCleanup(() => {
+            unsubscribe();
+            board.release(cellKey);
+        });
+    });
+    const separators = createCellSeparators(board, () => ({
+        cellKey: props.cellKey(),
+        prevCellKey: props.prevCellKey(),
+        has: {
+            leading: props.leadingSeparator() !== undefined,
+            trailing: props.trailingSeparator() !== undefined,
+        },
+    }));
+    const content = untrack(() => props.renderItem(separators));
+    const leading = () => props.leadingSeparator()?.({
+        isHighlighted: state().leadingHighlighted,
+        override: state().leadingOverride,
+    });
+    const trailing = () => props.trailingSeparator()?.({
+        isHighlighted: state().trailingHighlighted,
+        override: state().trailingOverride,
+    });
+    return props.isInverted
+        ? [trailing, content, leading]
+        : [leading, content, trailing];
+}

package/build/components.d.ts

@@ -1,6 +1,8 @@
 export type { IViewProps } from './components/view-props';
 export type { ITextProps } from './components/text-props';
 export type { ISafeAreaViewProps } from './components/safe-area-view-props';
+export type { ILayoutConformanceProps } from './components/layout-conformance-props';
+export type { ILayoutConformanceMode } from '@symbiote-native/components';
 export type { IImageProps } from './components/image-props';
 export type { IPressableProps } from './components/pressable-props';
 export type { IActivityIndicatorProps } from './components/activity-indicator-props';
@@ -16,7 +18,9 @@ export type { IRefreshControlProps } from './components/refresh-control-props';
 export type { IScrollViewProps } from './components/scroll-view-props';
 export type { IScrollViewHandle } from '@symbiote-native/components';
 export { VirtualizedList } from './components/virtualized-list';
-export type { IVirtualizedListProps, IVirtualizedListHandle, IVirtualizedListCellInfo, IVirtualizedListRenderItem, ICellLayout, ISeparators, ISeparatorProps, IViewToken, IViewableItemsChangedInfo, IViewabilityConfig, IViewabilityConfigCallbackPair, } from './components/virtualized-list';
+export { useVirtualizedListScope } from './components/virtualized-list/nested-scope';
+export type { IListScope } from '@symbiote-native/components';
+export type { IVirtualizedListProps, IVirtualizedListHandle, ICellRendererComponent, ICellRendererProps, IVirtualizedListCellInfo, IVirtualizedListRenderItem, ICellLayout, ISeparators, ISeparatorProps, IViewToken, IViewableItemsChangedInfo, IViewabilityConfig, IViewabilityConfigCallbackPair, } from './components/virtualized-list';
 export { FlatList } from './components/flat-list';
 export type { IFlatListProps, IFlatListHandle } from './components/flat-list';
 export { VirtualizedSectionList } from './components/virtualized-section-list';

package/build/components.js

@@ -8,6 +8,7 @@ export { KeyboardAvoidingView } from './components/keyboard-avoiding-view.jsx';
 // for the same import as the component. `IVirtualizedListComponent` stays internal — it is the
 // platform factory's return type, not API.
 export { VirtualizedList } from './components/virtualized-list';
+export { useVirtualizedListScope } from './components/virtualized-list/nested-scope.js';
 // FlatList carries no platform split of its own — the iOS/Android divergence is
 // VirtualizedList's refreshControlMode, inherited by importing that folder, so Metro picks the
 // right variant with nothing here to switch on. IFlatListProps is an Omit over

package/build/index.d.ts

@@ -1,5 +1,6 @@
 import './register';
 export { mount, unmount } from './render';
+export { RootTagContext } from './root-tag-context';
 export { findNodeHandle } from './host-instance';
 export type { IHostInstance } from './host-instance';
 export * from './components';
@@ -8,8 +9,8 @@ export { setImageSourceResolver } from '@symbiote-native/components';
 export { descriptorToSolid } from './descriptor-to-solid';
 export { defineDescriptorComponent } from './define-descriptor-component';
 export { defineOptionalDescriptorComponent } from './define-optional-descriptor-component';
-export { AppRegistry, setHostRegistrar } from './modules/app-registry';
-export type { IComponentProvider, IWrapperComponentProvider, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from './modules/app-registry';
+export { AppRegistry, HeadlessJsTaskError, setHostRegistrar, } from './modules/app-registry';
+export type { IComponentProvider, IWrapperComponentProvider, IAppConfig, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from './modules/app-registry';
 export { StatusBar } from './modules/status-bar';
 export type { IStatusBarProps, IStatusBarStyle } from './modules/status-bar';
 export { Image } from './modules/image';
@@ -19,6 +20,7 @@ export { createTunnel } from './create-tunnel';
 export type { ITunnel, ITunnelInProps } from './create-tunnel';
 export { createColorScheme } from './primitives/create-color-scheme';
 export { createWindowDimensions } from './primitives/create-window-dimensions';
+export { createAnimatedColor, createAnimatedValue, createAnimatedValueXY, } from '@symbiote-native/engine';
 export { createPermissionHook } from './primitives/create-permission-hook';
 export { createResourceHook } from './primitives/create-resource-hook';
 export { defineNativeViewComponent } from './primitives/define-native-view-component';
@@ -27,13 +29,17 @@ export { useEvent, useEventListener } from './primitives/use-event';
 export { Animated, createAnimatedComponent } from './modules/animated';
 export type { IAnimatedComponentProps } from './modules/animated';
 export { Platform, StyleSheet, PixelRatio, PlatformColor, DynamicColorIOS, processColor, } from '@symbiote-native/engine';
-export { setNativeViewConfigSource, setColorProcessor, setDeviceEventSource, } from '@symbiote-native/engine';
+export { setNativeViewConfigSource, setColorProcessor, } from '@symbiote-native/engine';
 export { dlog, isDebug } from '@symbiote-native/engine';
 export type { IViewStyle, ITextStyle, IFlexAlign, IFlexJustify, ISymbioteEvent, ISymbioteNode, IRootTag, INativeViewConfig, INativeViewConfigSource, IColorValue, IOpaqueColorValue, IDynamicColorIOSTuple, IPixelRatioStatic, IPlatformStatic, IPlatformOSType, IPlatformConstantsIOS, IPlatformConstantsAndroid, IPlatformSelectSpec, } from '@symbiote-native/engine';
-export { Alert, Share, ActionSheetIOS, Linking, Vibration, ToastAndroid, Settings, I18nManager, Dimensions, Appearance, AppState, Keyboard, KEYBOARD_EVENT, BackHandler, PermissionsAndroid, PERMISSIONS, RESULTS, LayoutAnimation, InteractionManager, } from '@symbiote-native/engine';
+export { Alert, Share, ActionSheetIOS, Linking, Vibration, ToastAndroid, Settings, I18nManager, Dimensions, Appearance, matchMedia, MediaQueryList, MediaQueryListEvent, setVariable, getComputedVariable, registerProperty, AppState, Keyboard, KEYBOARD_EVENT, TextInputState, BackHandler, PermissionsAndroid, PERMISSIONS, RESULTS, LayoutAnimation, InteractionManager, } from '@symbiote-native/engine';
 export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlertOptions, IShareContent, IShareOptions, IShareAction, IActionSheetIOSOptions, IShareActionSheetIOSOptions, IShareActionSheetError, IUrlEvent, II18nManagerConstants, IDisplayMetrics, IDisplayMetricsAndroid, IDimensionsPayload, IDimensionsSet, IDimensionsKey, IDimensionsChangeListener, IDimensionsStatic, IColorSchemeName, IColorSchemePreference, IAppStateStatus, IAppStateEvent, IKeyboardEventName, IKeyboardEvent, IKeyboardMetrics, IBackPressEventName, IBackPressHandler, IPermission, IPermissionStatus, IRationale, ILayoutAnimationType, ILayoutAnimationProperty, ILayoutAnimationConfig, ILayoutAnimationAnim, IInteractionEvent, ISimpleTask, IPromiseTask, ITask, IHandle, } from '@symbiote-native/engine';
 export { PanResponder } from '@symbiote-native/engine';
 export type { IPanResponderGestureState, IPanResponderCallbacks, IGestureResponderHandlers, IPanResponderInstance, } from '@symbiote-native/engine';
 export { AccessibilityInfo } from '@symbiote-native/engine';
 export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from '@symbiote-native/engine';
 export { For, Index, Show, ErrorBoundary, Suspense, SuspenseList, } from 'solid-js';
+export { DeviceEventEmitter, Easing, EventEmitter, NativeAppEventEmitter, NativeEventEmitter, } from '@symbiote-native/engine';
+export type { IEasing, IEasingFunction, IEmitterSubscription, IEventEmitter, IEventEmitterModule, IEventSubscription, INativeEventListener, } from '@symbiote-native/engine';
+export { codegenNativeCommands, codegenNativeComponent, DevMenu, DevSettings, LogBox, NativeComponentRegistry, NativeModules, Networking, PushNotificationIOS, ReactNativeVersion, registerCallableModule, requireNativeComponent, Systrace, Touchable, TurboModuleRegistry, UIManager, UTFSequence, } from '@symbiote-native/engine';
+export type { IDevSettings } from '@symbiote-native/engine';

package/build/index.js

@@ -4,13 +4,9 @@
 // uses. All Fabric clone-on-write lives in the engine, shared cross-adapter. App code imports
 // @symbiote-native/solid, never react-native.
 //
-// Layer status (symbiote-new-adapter §7): L4 in progress. The primitives, the stateful touch
-// components, the Touchable family, Button / ImageBackground / InputAccessoryView, StatusBar and
-// the list family are done at full parity with the React reference, and the engine-owned runtime
-// modules are re-exported below. Content relocation is in too: `Portal` (same-surface, React's
-// createPortal twin) and `createTunnel` (cross-surface), both written over the universal renderer
-// — solid-js/web's DOM-bound Portal was never the route to either. This barrel grows a layer at a
-// time on purpose, so a break localizes to the layer that introduced it.
+// Layer status (symbiote-new-adapter §7): L4 in progress, the barrel grows a layer at a time
+// Primitives, touch components, lists and the engine runtime modules are at full parity with React
+// `Portal` (same-surface) and `createTunnel` (cross-surface) sit on the universal renderer
 //
 // The two lifecycle primitives are spelled `createColorScheme` / `createWindowDimensions`, not
 // `use*`: in Solid `use*` means consuming something that already exists (useContext,
@@ -24,6 +20,7 @@
 // Bare, side-effect only, and deliberately NOT `export * from './register'` — see that file.
 import './register.js';
 export { mount, unmount } from './render.js';
+export { RootTagContext } from './root-tag-context.js';
 export { findNodeHandle } from './host-instance.js';
 export * from './components.js';
 // The app-entry seam that hands Image RN's own source resolver; grouped with the Image types it
@@ -37,14 +34,10 @@ export { defineDescriptorComponent } from './define-descriptor-component.js';
 export { defineOptionalDescriptorComponent } from './define-optional-descriptor-component.js';
 // Safe in the barrel (unlike ./bootstrap, which imports react-native): the registry seam itself
 // only reaches the engine and solid-js.
-export { AppRegistry, setHostRegistrar } from './modules/app-registry/index.js';
-// Animated: the three list/scroll components that are still components, over the engine's
-// framework-agnostic value graph. There is no `Animated.View` / `Animated.Text` / `Animated.Image`
-// — those primitives are tags, and `<view style={{ opacity: someAnimatedValue }}>` is the whole
-// API (.claude/rules/animated-values-resolve-in-the-engine.md). Solid's JSX takes the dotted form
-// of what remains directly — `<Animated.ScrollView/>` compiles to
-// createComponent(Animated.ScrollView, …) — so no local alias is needed, unlike Angular, whose AOT
-// compiler cannot trace a class through property access (.claude/rules/dotted-component-tags.md).
+export { AppRegistry, HeadlessJsTaskError, setHostRegistrar, } from './modules/app-registry/index.js';
+// Animated keeps only the list and scroll components, over the engine's value graph
+// The primitives are tags: `<view style={{ opacity: someAnimatedValue }}>` is the whole API
+// Solid's JSX takes `<Animated.ScrollView/>` directly, unlike Angular (dotted-component-tags.md)
 export { StatusBar } from './modules/status-bar.js';
 // What survives of `Image` once the primitive is the `<image>` tag: RN's statics namespace, no
 // view. Grouped with the runtime modules rather than the components for exactly that reason.
@@ -64,6 +57,7 @@ export { createTunnel } from './create-tunnel/index.jsx';
 // the subscription logic; these add only the Solid lifecycle (signal + onCleanup).
 export { createColorScheme } from './primitives/create-color-scheme.js';
 export { createWindowDimensions } from './primitives/create-window-dimensions.js';
+export { createAnimatedColor, createAnimatedValue, createAnimatedValueXY, } from '@symbiote-native/engine';
 export { createPermissionHook } from './primitives/create-permission-hook.js';
 export { createResourceHook } from './primitives/create-resource-hook.js';
 export { defineNativeViewComponent } from './primitives/define-native-view-component.js';
@@ -76,16 +70,15 @@ export { Animated, createAnimatedComponent } from './modules/animated/index.js';
 // Pure utilities and the color surface: no native event, no lifecycle, so they live in the engine
 // per <runtime_modules_layering>.
 export { Platform, StyleSheet, PixelRatio, PlatformColor, DynamicColorIOS, processColor, } from '@symbiote-native/engine';
-// The three app-entry seams, wired once on a real host. setNativeViewConfigSource is how a
-// third-party Fabric view auto-derives its metadata:
-//   setNativeViewConfigSource(name => ReactNativeViewConfigRegistry.get(name))
-export { setNativeViewConfigSource, setColorProcessor, setDeviceEventSource, } from '@symbiote-native/engine';
+// Seams wired once on a real host: `setNativeViewConfigSource` derives third-party view configs
+//   `setNativeViewConfigSource(name => ReactNativeViewConfigRegistry.get(name))`
+export { setNativeViewConfigSource, setColorProcessor, } from '@symbiote-native/engine';
 // Diagnostics gated by DEBUG (<keep_logs_gate_behind_DEBUG>): app code logs through the same seam
 // the engine does, never a bare console.log.
 export { dlog, isDebug } from '@symbiote-native/engine';
 // Imperative runtime modules: thin JS over getNativeModule + device events, no Fabric component
 // of their own, so there is nothing per-framework to write.
-export { Alert, Share, ActionSheetIOS, Linking, Vibration, ToastAndroid, Settings, I18nManager, Dimensions, Appearance, AppState, Keyboard, KEYBOARD_EVENT, BackHandler, PermissionsAndroid, PERMISSIONS, RESULTS, LayoutAnimation, InteractionManager, } from '@symbiote-native/engine';
+export { Alert, Share, ActionSheetIOS, Linking, Vibration, ToastAndroid, Settings, I18nManager, Dimensions, Appearance, matchMedia, MediaQueryList, MediaQueryListEvent, setVariable, getComputedVariable, registerProperty, AppState, Keyboard, KEYBOARD_EVENT, TextInputState, BackHandler, PermissionsAndroid, PERMISSIONS, RESULTS, LayoutAnimation, InteractionManager, } from '@symbiote-native/engine';
 // PanResponder: the gesture recognizer over the engine's responder events, shared by every adapter.
 export { PanResponder } from '@symbiote-native/engine';
 // AccessibilityInfo comes STRAIGHT from the engine, which owns the iOS/Android split
@@ -93,21 +86,12 @@ export { PanResponder } from '@symbiote-native/engine';
 // name, but that folder is a pure passthrough of these exact names — matching it means matching
 // the engine module, not growing a second one here.
 export { AccessibilityInfo } from '@symbiote-native/engine';
-// Solid's control flow is pure reactivity with no DOM dependency, so it works verbatim over the
-// universal renderer and is re-exported here to keep an app on one import. solid-js/web's own
-// `Portal` is NOT among them and cannot be — it allocates its container with
-// `document.createElement` — but the CAPABILITY is not missing: this package ships its own
-// `Portal` over the universal renderer (./create-portal, exported above), at the same
-// same-surface scope React and Angular chose for theirs. `Dynamic` is the one member of that DOM-bound pair still absent.
-// It is absent on its own terms, not as fallout from Portal: nothing here needed it (a tunnel
-// renders stored content by calling a thunk inside <For>, no dynamic component involved), and no
-// other adapter ships a twin of it for parity to require one.
-//
-// Solid's own control-flow `Switch`/`Match` pair is ABSENT for a different reason: `Switch` collides
-// head-on with RN's Switch component, which every other adapter exports under exactly that name and
-// which P0 parity (<adapters_reach_full_feature_parity>) pins here too. The RN component wins the
-// name; the control-flow pair keeps its canonical home, `import { Switch, Match } from 'solid-js'`
-// (alias it there if both are needed in one file). `Match` is withheld ALONGSIDE it deliberately —
-// re-exporting a lone `Match` while `Switch` means something else would compile fine and then fail
-// at runtime, which is worse than a missing export.
+// Control flow from `solid-js` works over the universal renderer as is, `Portal` is our own above
+// `Switch` is RN's component here, so the `Switch`/`Match` pair stays in `solid-js`
+// A lone `Match` would compile and then fail at runtime, so it is withheld too
 export { For, Index, Show, ErrorBoundary, Suspense, SuspenseList, } from 'solid-js';
+// The device event bus and the easing curves, shared verbatim from the engine
+export { DeviceEventEmitter, Easing, EventEmitter, NativeAppEventEmitter, NativeEventEmitter, } from '@symbiote-native/engine';
+// RN's dev and native-module utilities, shared verbatim from the engine. The ones RN owns forward
+// to its own module, which `registerApp` hands over
+export { codegenNativeCommands, codegenNativeComponent, DevMenu, DevSettings, LogBox, NativeComponentRegistry, NativeModules, Networking, PushNotificationIOS, ReactNativeVersion, registerCallableModule, requireNativeComponent, Systrace, Touchable, TurboModuleRegistry, UIManager, UTFSequence, } from '@symbiote-native/engine';