@symbiote-native/solid 1.0.0 → 3.0.0

package/build/components/{scroll-view → virtualized-list}/sticky-header.jsx

@@ -1,6 +1,16 @@
 // Sticky headers — the Solid lifecycle half of the JS layer RN implements in ScrollView.js /
 // ScrollViewStickyHeader.js.
 //
+// PRIVATE TO VIRTUALIZED-LIST since 2026-09-11. It used to live under `../scroll-view` and back
+// that component's `stickyHeaderIndices` too; the tag `<scroll-view>` now honors that prop through
+// the engine's own `sticky-header` intrinsic (`core/components/src/behaviors/scroll-view/sticky.ts`)
+// with no adapter code at all — see that primitive's props header. VirtualizedList still needs its
+// OWN implementation because it hand-builds its scroll host (`shared.tsx`'s own header explains
+// why) rather than emitting the tag, so it wraps a flagged CELL itself instead of leaning on the
+// engine's per-child walk. `wrapStickyHeaders`/`IStickyWrapInputs` — the generic child-array wrapper
+// ScrollView used and this file never called — were dropped with the move; `virtualized-list/
+// shared.tsx` wraps the cell it already owns directly.
+//
 // RN does stickiness PURELY IN JS: ScrollView wraps each flagged child in a ScrollViewStickyHeader
 // fed by ONE scroll AnimatedValue, and the native scroll view ignores `stickyHeaderIndices`
 // entirely — forwarding that array to Fabric is a silent no-op, so we replicate the JS layer
@@ -21,8 +31,7 @@
 // underneath; Solid does not (.claude/rules/solid-descriptor-bridge.md §4).
 import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { createInitialStickyState, readLayoutNumber, reduceSticky, STICKY_HEADER_Z_INDEX, } from '@symbiote-native/components';
-import { AnimatedInterpolation, Platform, dlog, isSymbioteNode, } from '@symbiote-native/engine';
-import { Animated } from '../../modules/animated/index.js';
+import { AnimatedInterpolation, Platform, dlog, } from '@symbiote-native/engine';
 // One sticky header. Measures its own y/height through onLayout, interpolates the shared scroll
 // offset into a translateY that pins it to the top (or the bottom, inverted) until the next header
 // collides with it, and drives that translate through the native driver when available so the pin
@@ -137,46 +146,29 @@ export function ScrollViewStickyHeader(props) {
         props.onLayout(event);
     };
     // The EXPLICIT debounced translateY overrides the committed transform for hit-testing, while
-    // animatedTranslateY does the smooth (native-driven) pin.
+    // animatedTranslateY does the smooth (native-driven) pin. It rides the style ARRAY now rather
+    // than `passthroughAnimatedPropExplicitValues`: that prop was read by `createAnimatedComponent`,
+    // and the host is a bare tag, where the engine ignores it
+    // (core/engine/src/animated/host-binding.ts calls it a wrapper-ism by name). The wrapper did
+    // exactly this merge — `[reduced.style, passthroughStyle]` — so a later array entry overriding
+    // the transform is the same semantics, one layer down, and the engine still binds the
+    // interpolation it finds in entry 0.
     const passthrough = createMemo(() => {
         // Read the bump so a committed translateY repaints.
         version();
         if (state.translateY === null)
-            return null;
-        return { style: { transform: [{ translateY: state.translateY }] } };
+            return undefined;
+        return { transform: [{ translateY: state.translateY }] };
     });
     // collapsable:false keeps the wrapper a real Yoga node; zIndex makes the pinned header paint OVER
     // the rows scrolling up under it.
-    return (<Animated.View style={{
-            transform: [{ translateY: animatedTranslateY() }],
-            zIndex: STICKY_HEADER_Z_INDEX,
-        }} onLayout={onLayout} collapsable={false} passthroughAnimatedPropExplicitValues={passthrough()}>
+    return (<view style={[
+            {
+                transform: [{ translateY: animatedTranslateY() }],
+                zIndex: STICKY_HEADER_Z_INDEX,
+            },
+            passthrough(),
+        ]} onLayout={onLayout} collapsable={false}>
       {props.children}
-    </Animated.View>);
-}
-// Wrap each child flagged by `stickyHeaderIndices` in the sticky header component, fed by the shared
-// scroll AnimatedValue (RN ScrollView.js's render-time children.map). Unflagged children pass
-// through untouched.
-//
-// Cross-talk (RN's _headerLayoutYs + _onStickyHeaderLayout): each header reports its own y through
-// `onHeaderLayoutY`, and every header is fed the y of the NEXT flagged one — the point past which it
-// gets pushed off. The LAST flagged header has no successor, so its nextHeaderLayoutY stays
-// undefined and it sticks indefinitely, which is correct.
-export function wrapStickyHeaders(children, inputs) {
-    const Wrapper = inputs.StickyHeaderComponent ?? ScrollViewStickyHeader;
-    return children.map((child, index) => {
-        const indexOfIndex = inputs.stickyHeaderIndices.indexOf(index);
-        // A non-node child (a bare string or number in a scroll view) has no frame to pin and cannot be
-        // wrapped meaningfully, so it passes through like an unflagged one.
-        if (indexOfIndex === -1 || !isSymbioteNode(child))
-            return child;
-        dlog(`Solid ScrollView sticky-header wrap index=${index}`);
-        return (<Wrapper nextHeaderLayoutY={inputs.readNextHeaderLayoutY(indexOfIndex)} onLayout={(event) => {
-                const y = readLayoutNumber(event, 'y');
-                if (y !== undefined)
-                    inputs.onHeaderLayoutY(index, y);
-            }} scrollAnimatedValue={inputs.scrollAnimatedValue} inverted={inputs.readInverted()} scrollViewHeight={inputs.readScrollViewHeight()}>
-        {child}
-      </Wrapper>);
-    });
+    </view>);
 }

package/build/components.d.ts

@@ -1,28 +1,20 @@
-export { View } from './components/view';
-export type { IViewProps } from './components/view';
-export { Text } from './components/text';
-export type { ITextProps } from './components/text';
-export { SafeAreaView } from './components/safe-area-view';
-export type { ISafeAreaViewProps } from './components/safe-area-view';
-export { Image } from './components/image';
-export type { IImageProps } from './components/image';
-export { Pressable } from './components/pressable';
-export type { IPressableProps } from './components/pressable';
-export { ActivityIndicator } from './components/activity-indicator';
-export type { IActivityIndicatorProps } from './components/activity-indicator';
+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 { IImageProps } from './components/image-props';
+export type { IPressableProps } from './components/pressable-props';
+export type { IActivityIndicatorProps } from './components/activity-indicator-props';
 export type { IImageStatics, IPressState, IPressableAndroidRippleConfig, } from '@symbiote-native/components';
-export { Switch } from './components/switch';
-export type { ISwitchProps, ISwitchTrackColor } from './components/switch';
-export { TextInput } from './components/text-input';
-export type { ITextInputProps, ITextInputHandle, ITextInputSelection, } from './components/text-input';
+export type { ISwitchProps, ISwitchTrackColor, ISwitchChangeEvent, } from './components/switch-props';
+export type { ITextInputProps } from './components/text-input-props';
+export type { ITextInputHandle, ITextInputSelection, ITextInputChangeEvent, } from '@symbiote-native/components';
 export { Modal } from './components/modal';
 export type { IModalProps, IModalAnimationType, IModalPresentationStyle, IModalOrientation, IModalOrientationChangeEvent, } from './components/modal';
 export { KeyboardAvoidingView } from './components/keyboard-avoiding-view';
 export type { IKeyboardAvoidingViewProps, IKeyboardAvoidingBehavior, } from './components/keyboard-avoiding-view';
-export { RefreshControl } from './components/refresh-control';
-export type { IRefreshControlProps } from './components/refresh-control';
-export { ScrollView } from './components/scroll-view';
-export type { IScrollViewProps, IScrollViewHandle, } from './components/scroll-view';
+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 { FlatList } from './components/flat-list';
@@ -31,13 +23,11 @@ export { VirtualizedSectionList } from './components/virtualized-section-list';
 export type { IVirtualizedSectionListProps, IVirtualizedSectionListHandle, ISectionHeaderInfo, ISectionCellInfo, ISection, } from './components/virtualized-section-list';
 export { SectionList } from './components/section-list';
 export type { ISectionListProps, ISectionListHandle, } from './components/section-list';
-export { TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, } from './components/touchable';
-export type { ITouchableOpacityProps, ITouchableHighlightProps, ITouchableWithoutFeedbackProps, } from './components/touchable';
-export { TouchableNativeFeedback } from './components/touchable-native-feedback';
-export type { ITouchableNativeFeedbackProps, INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, } from './components/touchable-native-feedback';
-export { Button } from './components/button';
-export type { IButtonProps } from './components/button';
-export { ImageBackground } from './components/image-background';
-export type { IImageBackgroundProps } from './components/image-background';
-export { InputAccessoryView } from './components/input-accessory-view';
-export type { IInputAccessoryViewProps } from './components/input-accessory-view';
+export type { ITouchableOpacityProps, ITouchableHighlightProps, } from './components/touchable-props';
+export type { ITouchableWithoutFeedbackProps } from './components/touchable-without-feedback/touchable-without-feedback-props';
+export { TouchableNativeFeedback } from '@symbiote-native/components';
+export type { INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, } from '@symbiote-native/components';
+export type { ITouchableNativeFeedbackProps } from './components/touchable-native-feedback/touchable-native-feedback-props';
+export type { IButtonProps } from './components/button-props';
+export type { IImageBackgroundProps } from './components/image-background-props';
+export type { IInputAccessoryViewProps } from './components/input-accessory-view-props';

package/build/components.js

@@ -1,31 +1,12 @@
 // The component re-export barrel, flat at the package root like every other adapter's. Grouping
 // under components/ is internal; this file plus src/index.ts is the whole public surface.
-export { View } from './components/view.jsx';
-export { Text } from './components/text.jsx';
-export { SafeAreaView } from './components/safe-area-view.jsx';
-export { Image } from './components/image.js';
-export { Pressable } from './components/pressable.jsx';
-export { ActivityIndicator } from './components/activity-indicator';
-export { Switch } from './components/switch';
-export { TextInput } from './components/text-input.js';
 export { Modal } from './components/modal.jsx';
 export { KeyboardAvoidingView } from './components/keyboard-avoiding-view.jsx';
-export { RefreshControl } from './components/refresh-control.jsx';
-// ScrollViewStickyHeader is NOT exported, matching react-native itself: it lives at
-// Libraries/Components/ScrollView/ScrollViewStickyHeader.js and is absent from RN's public
-// index.js, so it is ScrollView's internal, not part of the public surface. React's and Vue's
-// barrels agree. Svelte's and Angular's do export it, but as a WORKAROUND rather than an API
-// decision — Svelte documents `stickyHeaderIndices` as a KNOWN GAP, so its apps have to compose the
-// wrapper by hand. This adapter auto-wraps flagged children the way React and Vue do, so the escape
-// hatch has nothing to escape. `IStickyHeaderComponentType` stays internal for the same reason even
-// though `IScrollViewProps.StickyHeaderComponent` is typed by it — React has the identical shape.
-export { ScrollView } from './components/scroll-view';
 // The shared list detail types (ISeparators, IViewToken, IViewabilityConfig…) come through the
 // component module rather than straight from '@symbiote-native/components', matching React's own
 // virtualized-list barrel: a consumer typing a renderItem callback or a viewability config reaches
 // for the same import as the component. `IVirtualizedListComponent` stays internal — it is the
-// platform factory's return type, not API, exactly as ScrollView keeps `IScrollViewHostPlatform`
-// out of this barrel.
+// platform factory's return type, not API.
 export { VirtualizedList } from './components/virtualized-list';
 // 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
@@ -39,16 +20,8 @@ export { VirtualizedSectionList } from './components/virtualized-section-list/in
 // SectionList declares no input of its own — it is the preset over VirtualizedSectionList, the same
 // relation React's 25-line section-list has to its 262-line virtualized twin.
 export { SectionList } from './components/section-list/index.jsx';
-// The Touchable family, all composed over Pressable exactly as React's and Vue's are — so the
-// press machine, the aria fold and the class+style merge each happen once, in Pressable/View.
-export { TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, } from './components/touchable/index.jsx';
-// Android's native ripple/theme-attr feedback. The background factories are the SHARED functions
-// hung on the component value, not adapter wrappers, so every adapter offers the identical set.
-export { TouchableNativeFeedback } from './components/touchable-native-feedback/index.jsx';
-// IButtonProps is agnostic and lives in @symbiote-native/components; this re-exports it rather
-// than redeclaring it, matching react/vue/svelte/angular (CLAUDE.md prop-type split).
-export { Button } from './components/button.jsx';
-// Both take `children`, a framework value, so their public prop types are declared per-adapter
-// over the shared agnostic field base — never imported from another adapter.
-export { ImageBackground } from './components/image-background.jsx';
-export { InputAccessoryView } from './components/input-accessory-view.jsx';
+// Android's native ripple/theme-attr feedback. `TouchableNativeFeedback` is now RN's STATIC
+// NAMESPACE, not a component: the element is the tag `<touchable-native-feedback>`, which commits no
+// node of its own and clones onto its single child. `.Ripple(…)` / `.SelectableBackground(…)` are
+// unchanged, and are the SHARED functions every adapter already offered.
+export { TouchableNativeFeedback } from '@symbiote-native/components';

package/build/create-portal/index.jsx

@@ -35,7 +35,7 @@
 // structurally the same silent no-paint React documents for its own resetAfterCommit. Cross-
 // surface content sharing is a different mechanism entirely: `createTunnel` (../create-tunnel).
 import { createMemo, createRenderEffect, onCleanup } from 'solid-js';
-import { createAnchor, dlog, isSymbioteNode, SymbioteSurface, } from '@symbiote-native/engine';
+import { componentOf, createAnchor, dlog, isSymbioteNode, SymbioteSurface, } from '@symbiote-native/engine';
 import { insert, insertNode, removeNode } from '../renderer.js';
 // The Solid flavour of React's isSymbioteNode guard, and it needs its own wording: React tells the
 // caller to check for a forgotten `.current`, which does not exist here. A Solid `ref` is a plain
@@ -45,7 +45,7 @@ import { insert, insertNode, removeNode } from '../renderer.js';
 function assertPortalTarget(target) {
     if (target instanceof SymbioteSurface || isSymbioteNode(target))
         return target;
-    throw new Error('Portal `mount` must be an already-mounted host node (a ref off a rendered <View>) or a surface — got something else. Did you pass the signal instead of CALLING it (`mount={overlay()}`), read it before the target element existed (gate the Portal behind <Show when={overlay()}>), or pass a CSS-selector-style string?');
+    throw new Error('Portal `mount` must be an already-mounted host node (a ref off a rendered <view>) or a surface — got something else. Did you pass the signal instead of CALLING it (`mount={overlay()}`), read it before the target element existed (gate the Portal behind <Show when={overlay()}>), or pass a CSS-selector-style string?');
 }
 export function Portal(props) {
     // One engine ANCHOR per Portal instance, used as a fragment host: it is a real retained node, so
@@ -68,7 +68,7 @@ export function Portal(props) {
     // deferred createEffect because a DOM append IS the paint.
     createRenderEffect(() => {
         const to = target();
-        dlog(`solid portal -> ${to instanceof SymbioteSurface ? 'surface' : to.component}`);
+        dlog(`solid portal -> ${to instanceof SymbioteSurface ? 'surface' : componentOf(to)}`);
         insertNode(to, host);
         // Runs both on a `mount` change (before the effect re-attaches elsewhere) and on the Portal's
         // own disposal — the content leaves the target either way.

package/build/descriptor-to-solid.js

@@ -14,7 +14,7 @@
 // So the tree is built ONCE and every node's props are wired through the renderer's own `spread`,
 // which is a render effect that diffs prop-by-prop against the previous values and calls
 // setProperty -> routeProp only for the ones that actually changed. Same mechanism, same node
-// identity, as compiled `<symbiote-switch value={v()} />`.
+// identity, as compiled `<switch value={v()} />`.
 //
 // This relies on `render-*.ts` producing a SHAPE-STABLE Descriptor: same type, same child count,
 // text where text was — only prop VALUES vary between calls. That is already the contract the

package/build/host-instance.js

@@ -9,7 +9,7 @@
 // The node -> tag resolution itself belongs to the engine (getNativeTag, keyed on the raw node in the
 // commit mirror); this only unwraps the Solid-shaped inputs onto it. An uncommitted or unknown input
 // has no tag yet and surfaces as null.
-import { getNativeTag, isSymbioteNode, dlog } from '@symbiote-native/engine';
+import { componentOf, getNativeTag, isSymbioteNode, dlog, } from '@symbiote-native/engine';
 // Solid's counterpart to Vue's isRef branch. Solid has no ref wrapper — `ref={el}` writes the node
 // straight into a variable — but holding that node in a signal is idiomatic, and a signal reads as a
 // zero-argument accessor. Calling it is the only way to unwrap one (there is no isSignal predicate:
@@ -28,7 +28,7 @@ export function findNodeHandle(componentOrHandle) {
         return candidate;
     if (isSymbioteNode(candidate)) {
         const tag = getNativeTag(candidate) ?? null;
-        dlog(`findNodeHandle: component=${candidate.component} tag=${tag}`);
+        dlog(`findNodeHandle: component=${componentOf(candidate)} tag=${tag}`);
         return tag;
     }
     dlog('findNodeHandle: input did not resolve to a symbiote host node');

package/build/index.d.ts

@@ -10,6 +10,7 @@ export { AppRegistry, setHostRegistrar } from './modules/app-registry';
 export type { IComponentProvider, IWrapperComponentProvider, 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';
 export { Portal } from './create-portal';
 export type { IPortalProps, IPortalTarget } from './create-portal';
 export { createTunnel } from './create-tunnel';

package/build/index.js

@@ -36,11 +36,19 @@ export { descriptorToSolid } from './descriptor-to-solid.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 six animated components RN exposes, over the engine's framework-agnostic value
-// graph. Solid's JSX takes the dotted form directly — `<Animated.View/>` compiles to
-// createComponent(Animated.View, …) — so no local alias is needed, unlike Angular, whose AOT
+// 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 { 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.
+// `IImageStatics` is not re-exported here — `./components` already carries it, straight from the
+// shared package, and a second export of one name is a build error rather than a convenience.
+export { Image } from './modules/image.js';
 // Portal: same-surface content relocation, the twin of React's createPortal and Angular's
 // PortalDirective/PortalOutletDirective. `mount` takes an already-mounted host node in THIS
 // surface (a ref off a rendered component) or the surface itself; reaching a second, separately

package/build/jsx-runtime.d.ts

@@ -1,9 +1,46 @@
-import type { ISymbioteIntrinsic } from '@symbiote-native/components';
+import type { ICrossTypedIntrinsics } from '@symbiote-native/components';
 import type { ISymbioteNode } from '@symbiote-native/engine';
+import type { IViewProps } from './components/view-props';
+import type { ITextProps } from './components/text-props';
+import type { IPressableProps } from './components/pressable-props';
+import type { IButtonProps } from './components/button-props';
+import type { IImageProps } from './components/image-props';
+import type { IImageBackgroundProps } from './components/image-background-props';
+import type { IInputAccessoryViewProps } from './components/input-accessory-view-props';
+import type { IRefreshControlProps } from './components/refresh-control-props';
+import type { ISafeAreaViewProps } from './components/safe-area-view-props';
+import type { ITouchableNativeFeedbackProps } from './components/touchable-native-feedback/touchable-native-feedback-props';
+import type { ITouchableOpacityProps, ITouchableHighlightProps } from './components/touchable-props';
+import type { ITouchableWithoutFeedbackProps } from './components/touchable-without-feedback/touchable-without-feedback-props';
+import type { IScrollViewProps } from './components/scroll-view-props';
+import type { ISwitchProps } from './components/switch-props';
+import type { ITextInputProps } from './components/text-input-props';
+import type { IModalProps } from './components/modal';
+import type { IActivityIndicatorProps } from './components/activity-indicator-props';
 type ISymbioteHostAttributes = {
     readonly children?: JSX.Element;
     readonly [attribute: string]: unknown;
 };
+interface ICrossedPrimitiveProps {
+    view: IViewProps;
+    text: ITextProps;
+    pressable: IPressableProps;
+    button: IButtonProps;
+    image: IImageProps;
+    'image-background': IImageBackgroundProps;
+    'input-accessory-view': IInputAccessoryViewProps;
+    'refresh-control': IRefreshControlProps;
+    'safe-area-view': ISafeAreaViewProps;
+    'touchable-native-feedback': ITouchableNativeFeedbackProps;
+    'touchable-opacity': ITouchableOpacityProps;
+    'touchable-highlight': ITouchableHighlightProps;
+    'touchable-without-feedback': ITouchableWithoutFeedbackProps;
+    'scroll-view': IScrollViewProps;
+    switch: ISwitchProps;
+    'text-input': ITextInputProps;
+    modal: IModalProps;
+    'activity-indicator': IActivityIndicatorProps;
+}
 export declare namespace JSX {
     type Element = ISymbioteNode | IArrayElement | IFunctionElement | (string & {}) | number | boolean | null | undefined;
     interface IArrayElement extends Array<Element> {
@@ -20,7 +57,7 @@ export declare namespace JSX {
     }
     interface IntrinsicAttributes {
     }
-    interface IntrinsicElements extends Record<ISymbioteIntrinsic, ISymbioteHostAttributes> {
+    interface IntrinsicElements extends ICrossTypedIntrinsics<ISymbioteHostAttributes, ICrossedPrimitiveProps> {
     }
 }
 export {};

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

@@ -8,25 +8,7 @@ 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;
-    };
+    Easing: import("@symbiote-native/engine").IEasing;
     timing: typeof timing;
     spring: typeof spring;
     decay: typeof decay;
@@ -44,10 +26,31 @@ export declare const Animated: {
     event: typeof event;
     forkEvent: typeof forkEvent;
     unforkEvent: typeof unforkEvent;
-    View: (props: import("./create-animated-component").IAnimatedComponentProps) => import("@symbiote-native/solid/jsx-runtime").JSX.Element;
-    Text: (props: import("./create-animated-component").IAnimatedComponentProps) => import("@symbiote-native/solid/jsx-runtime").JSX.Element;
-    Image: (props: import("./create-animated-component").IAnimatedComponentProps) => import("@symbiote-native/solid/jsx-runtime").JSX.Element;
-    ScrollView: IAnimatedComponent;
+    FlatList: IAnimatedComponent;
+    SectionList: IAnimatedComponent;
+    createAnimatedComponent: typeof createAnimatedComponent;
+} | {
+    Value: typeof AnimatedValue;
+    ValueXY: typeof AnimatedValueXY;
+    Color: typeof AnimatedColor;
+    Easing: import("@symbiote-native/engine").IEasing;
+    timing: (value: AnimatedValue, config: import("@symbiote-native/engine").ITimingConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    spring: (value: AnimatedValue, config: import("@symbiote-native/engine").ISpringConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    decay: (_value: AnimatedValue, _config: import("@symbiote-native/engine").IDecayConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    parallel: (animations: import("@symbiote-native/engine").ICompositeAnimation[], _config?: import("@symbiote-native/engine").IParallelConfig) => import("@symbiote-native/engine").ICompositeAnimation;
+    sequence: (animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
+    stagger: (_time: number, animations: import("@symbiote-native/engine").ICompositeAnimation[]) => import("@symbiote-native/engine").ICompositeAnimation;
+    loop: (_animation: import("@symbiote-native/engine").ICompositeAnimation) => import("@symbiote-native/engine").ICompositeAnimation;
+    delay: (_time: number) => import("@symbiote-native/engine").ICompositeAnimation;
+    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;
     FlatList: IAnimatedComponent;
     SectionList: IAnimatedComponent;
     createAnimatedComponent: typeof createAnimatedComponent;

package/build/modules/animated/index.js

@@ -1,19 +1,25 @@
-// The Animated namespace for @symbiote-native/solid. createAnimatedComponent applied to this
-// adapter's primitives gives the six animated components RN exposes; the value graph, easing and
-// imperative drivers come from @symbiote-native/engine (framework-agnostic), so both halves meet
-// here in one object and `Animated.timing(new Animated.Value(0), …).start()` reads as it does in
-// RN. Solid's JSX takes the dotted form directly — `<Animated.View/>` compiles to
-// createComponent(Animated.View, …), no local alias needed.
+// The Animated namespace for @symbiote-native/solid. The value graph, easing and imperative drivers
+// come from @symbiote-native/engine (framework-agnostic), so both halves meet here in one object and
+// `Animated.timing(new Animated.Value(0), …).start()` reads as it does in RN.
+//
+// THERE IS NO `Animated.View` / `Animated.Text` / `Animated.Image` / `Animated.ScrollView`, and
+// nothing replaced any of them: `<view style={{ opacity: someAnimatedValue }}>` is the whole API
+// for style, and `<scroll-view onScroll={Animated.event(…)}>` is the whole API for a native-driven
+// scroll listener. The engine resolves an AnimatedNode written into any prop of any host node
+// (`core/engine/src/animated/host-binding.ts`) — it publishes the current value, subscribes the
+// leaf, writes each frame through its own targeted setNativeProps commit, and releases at the
+// commit sweep; `setEventListener` calls `bindAnimatedEvent` on any `on*` prop for EVERY host node,
+// not just a scroll one. Those four were aliases of the wrappers, and a wrapper is a tag now, which
+// is not a value `<Animated.X>` can call.
+//
+// The two below REMAIN because they are tier 3: a render prop decides the list family's output
+// shape in JS, so there is no tag for `<Animated.X>` to be an alias of.
 //
 // The NATIVE DRIVER is not this module's doing and must not be re-derived here. A
 // useNativeDriver animation promotes the value graph itself (animations/base.ts ->
 // value.__startNativeAnimation -> graph.__makeNative), and the props leaf follows automatically
 // through graph.__addChild. This file only assembles the surface.
 import { AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedMock, 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 } from '../../components/view.jsx';
-import { Text } from '../../components/text.jsx';
-import { Image } from '../../components/image.js';
-import { ScrollView } from '../../components/scroll-view';
 import { FlatList } from '../../components/flat-list/index.jsx';
 import { SectionList } from '../../components/section-list/index.jsx';
 import { createAnimatedComponent } from './create-animated-component.jsx';
@@ -21,11 +27,6 @@ export { createAnimatedComponent } from './create-animated-component.jsx';
 // The pure graph leaves live in the engine (they extend AnimatedWithChildren, no framework);
 // re-exported so this adapter's Animated surface matches React's.
 export { AnimatedProps, AnimatedStyle, AnimatedTransform, } from '@symbiote-native/engine';
-// View/Text/Image are pure host primitives with no cycle back to here, so wrap them eagerly.
-const AnimatedView = createAnimatedComponent(View);
-const AnimatedText = createAnimatedComponent(Text);
-const AnimatedImage = createAnimatedComponent(Image);
-let animatedScrollView;
 let animatedFlatList;
 let animatedSectionList;
 // The live, JS-driven driver half. RN's AnimatedImplementation.
@@ -58,13 +59,6 @@ const liveDrivers = {
 // spreads `...Animated` 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;

package/build/modules/image.d.ts

@@ -0,0 +1,3 @@
+import { type IImageStatics } from '@symbiote-native/components';
+export type { IImageStatics };
+export declare const Image: IImageStatics;

package/build/modules/image.js

@@ -0,0 +1,12 @@
+// RN's Image STATICS — `getSize`, `prefetch`, `queryCache`, `abortPrefetch`, `resolveAssetSource`.
+//
+// IN `modules/`, NOT `components/`. The primitive is the `<image>` tag and its fold runs in the
+// engine (`behaviors/image.ts`); what survives under the name `Image` is an imperative API with no
+// view, which is what this bucket is for. Sitting in `components/` was what made a statics object
+// read as a component.
+//
+// A NAMESPACE OBJECT rather than five bare functions, deliberately: `Alert`, `Share`, `Linking`
+// and `Vibration` all take that shape, and an app porting from RN writes `Image.getSize(...)`
+// verbatim. Shared verbatim via `imageStatics`, the same source every other adapter attaches.
+import { imageStatics } from '@symbiote-native/components';
+export const Image = imageStatics;

package/build/register.d.ts

@@ -1 +1 @@
-export {};
+import '@symbiote-native/components/register';

package/build/register.js

@@ -1,31 +1,15 @@
 // Side-effect ONLY. Exports nothing, and must never be re-exported from the barrel.
 //
-// The engine's host-behavior registry is reached through a `register*` call, and CLAUDE.md records
-// what happens to one of those behind a barrel: Metro turns on `inlineRequires` for PRODUCTION
-// only, moving a `require` down to the first place its binding is used as a VALUE, and
-// `export { X } from './x'` compiles to a lazy getter. If nothing ever names the module as a value,
-// it never evaluates and the registration silently never happens — in Release builds alone,
-// invisible to tsc, to vitest, and to grepping the bundle.
+// The fourteen calls live once, in `@symbiote-native/components/register` — they were identical in
+// all five adapters, and each copy carried a migration ledger justifying a call against a wrapper
+// that no longer exists. What is per-adapter is only the SPELLING of the import below: every
+// `*-tag.test.*` here reaches the registry through `import './register';`, and this adapter's own
+// barrel guard pins that line.
 //
-// A bare `import './register';` next to a re-export of the same specifier does NOT help: Babel
-// merges the two into one dependency and the merged dependency stays lazy. The shape that works is
-// this one — a module imported ONLY for its side effect and never re-exported — the same shape
-// `packages/slider/src/{react,vue,svelte,angular}/index.ts` uses. `barrel-side-effect.test.ts` is
-// what stops a later tidy-up from "fixing" the bare import into a re-export.
-import { registerImageBehavior, registerInputAccessoryViewBehavior, registerPressableBehavior, registerSwitchBehavior, registerTextInputBehavior, } from '@symbiote-native/components';
-registerPressableBehavior();
-// Only the LOWERED tags carry this — the wrapper renders `symbiote-text-input-managed` and
-// keeps running its own lifecycle. One owner per node; see `component-names/shared.ts`.
-registerTextInputBehavior();
-// Same reason as TextInput: the wrapper renders `symbiote-switch-managed` and runs its own
-// lastNativeReport/snap-back lifecycle, so the engine's copy attaches only to the bare tag.
-registerSwitchBehavior();
-// Image owns no runtime — its behavior is a prop FOLD and nothing else, and it is registered on the
-// same `symbiote-image` the wrapper already emits rather than on a `-managed` twin. That is safe
-// only because the mapping is idempotent, which `core/components/src/behaviors/image.test.ts`
-// asserts rather than assumes; a wrapper-built node simply folds a second time and nothing moves.
-registerImageBehavior();
-// Fold-only, and it shares the wrapper's tag for the same reason Image does: the mapping has no
-// aliasing at all, so a wrapper-built node folding a second time moves nothing.
-// `core/components/src/behaviors/input-accessory-view.test.ts` asserts that rather than assuming it.
-registerInputAccessoryViewBehavior();
+// WHY A SIDE-EFFECT SUBPATH AND NOT A BARREL EXPORT. Metro turns on `inlineRequires` for PRODUCTION
+// only: it moves a `require` down to the first place its binding is used as a VALUE, and
+// `export { X } from './x'` compiles to a lazy getter. A registration reached that way never
+// evaluates in a Release build — invisible to tsc, to vitest, and to grepping the bundle. A bare
+// `import` placed NEXT TO a re-export of the same specifier does not help either: Babel merges the
+// two into one dependency and the merged dependency stays lazy.
+import '@symbiote-native/components/register';