@symbiote-native/solid 1.0.0 → 2.0.0

package/README.md

@@ -61,16 +61,15 @@ exactly what react-refresh's `isLikelyComponentType` heuristic looks for. It the
 React Fiber tree that does not exist in this path, and the update is swallowed with no error. Force a
 full reload instead: `unstable_forceFullRefreshPatterns: [/\.tsx$/]`.
 
-## Host-primitive lowering — `<View>`/`<Text>`/`<Pressable>` compile to intrinsics, not components
-
-`babel-preset-solid` (wired above) runs `babel-lower-host-primitives.cjs` before compiling: a
-`<View>`/`<Text>` with no reactive prop, and a `<Pressable>` whose `style`/children don't need a
-component instance, rewrite to the engine's intrinsic tags (`symbiote-view`, `symbiote-text`,
-`symbiote-pressable`) instead of going through `createComponent` + a props Proxy. Nothing in app
-code has to opt in — the preset does it transparently, and a call site that can't be lowered
-(a spread, a render-prop child, an unreadable attribute) falls back to the component path
-unchanged. See root `CLAUDE.md`, "Where we stand against stock React Native", for the measured
-device numbers this bought — do not hand-copy them here, they move with every engine/adapter cut.
+## Primitives are plain intrinsic tags — `<view>`/`<text>`/`<pressable>`, no component involved
+
+An app writes the lowercase tags directly (`view`, `text`, `pressable`, …) — `babel-preset-solid`'s
+own `isComponent` check already treats a lowercase name as an element, so JSX compiles straight to
+`createElement`/`setProp` calls against `symbiote-view` etc., no import and nothing to opt into.
+This retires the compile-time lowering transform that used to rewrite a `<View>`/`<Text>`/
+`<Pressable>` COMPONENT call site into the same intrinsics (`babel-lower-host-primitives.cjs`,
+deleted 2026-09-08) — there is no component call site left to rewrite. See root `CLAUDE.md`,
+"Where we stand against stock React Native", for the measured device numbers.
 
 ## `./renderer` is a compiler target, not a convenience export
 

package/babel-preset.cjs

@@ -24,11 +24,6 @@
 // React-JSX transform gets a chance to claim the same JSX nodes.
 module.exports = function symbioteSolidBabelPreset(_api, options = {}) {
   return {
-    // Babel runs PLUGINS before PRESETS, which is exactly the order this needs: the lowering
-    // rewrites <View>/<Text> to their intrinsic tags while they are still JSX, so babel-preset-solid
-    // then compiles them as elements (createElement + setProp) instead of as components
-    // (createComponent + a props Proxy). Reversed, there would be nothing left to rewrite.
-    plugins: [require('./babel-lower-host-primitives.cjs')],
     presets: [
       [
         require('babel-preset-solid'),

package/build/components/activity-indicator-props.d.ts

@@ -0,0 +1,5 @@
+import type { IActivityIndicatorProps as IActivityIndicatorBaseProps } from '@symbiote-native/components';
+import type { IClassNameValue } from '@symbiote-native/engine';
+export type IActivityIndicatorProps = IActivityIndicatorBaseProps & {
+    class?: IClassNameValue;
+};

package/build/components/activity-indicator-props.js

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

package/build/components/button-props.d.ts

@@ -0,0 +1,5 @@
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { IButtonProps as IButtonBaseProps } from '@symbiote-native/components';
+export type IButtonProps = IButtonBaseProps & {
+    class?: IClassNameValue;
+};

package/build/components/button-props.js

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

package/build/components/flat-list/index.jsx

@@ -66,7 +66,7 @@ export function FlatList(props) {
             : props.columnWrapperStyle,
     ]);
     function renderRow(info) {
-        return (<symbiote-view style={rowStyle()}>
+        return (<view style={rowStyle()}>
         <Index each={info().item.items}>
           {(item, column) => {
                 // Called ONCE and untracked, the shape VirtualizedList's own cell build uses: a
@@ -79,10 +79,10 @@ export function FlatList(props) {
                     // separators handle — the divider sits between rows, not between columns.
                     separators: info().separators,
                 })));
-                return (<symbiote-view style={COLUMN_STYLE}>{content}</symbiote-view>);
+                return <view style={COLUMN_STYLE}>{content}</view>;
             }}
         </Index>
-      </symbiote-view>);
+      </view>);
     }
     // The divider between rows shows real items (last of the row above, first of the row below), so
     // the caller's separator, typed on ItemT, never sees the IRow wrapper.

package/build/components/{image-background.d.ts → image-background-props.d.ts}

@@ -1,10 +1,9 @@
+import type { IImageProps } from '@symbiote-native/components';
+import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
 import type { JSX } from '../jsx-runtime';
-import { type IImageProps } from '@symbiote-native/components';
-import { type IClassNameValue, type IStyleProp, type IViewStyle } from '@symbiote-native/engine';
 export interface IImageBackgroundProps extends Omit<IImageProps, 'style'> {
     style?: IStyleProp<IViewStyle>;
     imageStyle?: IStyleProp<IViewStyle> | string;
     class?: IClassNameValue;
     children?: JSX.Element;
 }
-export declare function ImageBackground(props: IImageBackgroundProps): JSX.Element;

package/build/components/image-background-props.js

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

package/build/components/image-props.d.ts

@@ -0,0 +1,5 @@
+import type { IImageProps as IImageBaseProps } from '@symbiote-native/components';
+import type { IClassNameValue } from '@symbiote-native/engine';
+export type IImageProps = IImageBaseProps & {
+    class?: IClassNameValue;
+};

package/build/components/image-props.js

@@ -0,0 +1,6 @@
+// The `<image>` tag's prop surface. `renderImage`'s whole fold — the source / src / srcSet
+// resolution, the width+height fold into style, resizeMode and tintColor read back off the style,
+// alt -> accessibilityLabel, the array shape native expects — runs in the tag's own behavior
+// (`registerImageBehavior`, wired by `../register`), so the wrapper that used to call it is gone.
+// The Image STATICS moved to `../modules/image`: an imperative API with no view.
+export {};

package/build/components/{input-accessory-view.d.ts → input-accessory-view-props.d.ts}

@@ -1,5 +1,5 @@
 import type { JSX } from '../jsx-runtime';
-import { type IAccessibilityProps, type IAriaProps } from '@symbiote-native/components';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
 import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
 export interface IInputAccessoryViewProps extends IAccessibilityProps, IAriaProps {
     nativeID?: string;
@@ -8,4 +8,3 @@ export interface IInputAccessoryViewProps extends IAccessibilityProps, IAriaProp
     class?: IClassNameValue;
     children?: JSX.Element;
 }
-export declare function InputAccessoryView(props: IInputAccessoryViewProps): JSX.Element;

package/build/components/input-accessory-view-props.js

@@ -0,0 +1,5 @@
+// The `<input-accessory-view>` tag's prop surface. The wrapper that used to carry it is gone —
+// `renderInputAccessoryView`'s nativeID / backgroundColor / style mapping runs in the tag's own
+// behavior (`registerInputAccessoryViewBehavior`, wired by `../register`), and the aria/role fold
+// runs in the engine's `fabricProps`.
+export {};

package/build/components/keyboard-avoiding-view.jsx

@@ -25,7 +25,7 @@
 import { createMemo, createSignal, onCleanup, splitProps } from 'solid-js';
 import { computeInset, keyboardAvoidingEventNamesFor, readKeyboardFrame, readLayoutFrame, readPrefersCrossFadeTransitions, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from '@symbiote-native/components';
 import { Keyboard, Platform, dlog, } from '@symbiote-native/engine';
-import { View } from './view.jsx';
+import { withStableKeys } from '../utils/stable-keys.js';
 // Read by KeyboardAvoidingView itself; everything else (the aria/role aliases, accessibility*,
 // testID, class) forwards onto the wrapper View, which folds them once through
 // resolveAccessibilityProps and widens the vanished-key case with withStableKeys.
@@ -144,9 +144,14 @@ export function KeyboardAvoidingView(props) {
         // Last, so KAV's own measure always runs; the caller's handler is invoked from inside it.
         onLayout: handleLayout,
     }));
+    // The half `View` used to supply, now that the wrapper is a bare tag: `spread` has no removal
+    // pass, so a key that stops being emitted (`rest` is a splitProps proxy, and `wrapperStyle` is
+    // absent in some behaviors) would keep its last value on the native view forever
+    // (.claude/rules/solid-descriptor-bridge.md §1).
+    const stableWrapperProps = withStableKeys(wrapperProps);
     // 'nested' ('position') pushes the children in an inner View by `bottom: inset`; the wrapper modes
     // ('padding' / 'height' / no behavior) adjust the single wrapper directly.
-    return (<View {...wrapperProps()}>
-      {isNested() ? (<View style={innerStyle()}>{local.children}</View>) : (local.children)}
-    </View>);
+    return (<view {...stableWrapperProps()}>
+      {isNested() ? (<view style={innerStyle()}>{local.children}</view>) : (local.children)}
+    </view>);
 }

package/build/components/modal.jsx

@@ -18,8 +18,8 @@
 // user's components, which is the case the render-fn boundary rules OUT of core
 // (.claude/rules/component-render-fn-boundary.md), so the bridge would have nothing to do with the
 // half that matters and would hand back a root whose container child we would then have to reach
-// into to `insert` into. renderModal always paints the SAME two-tag shape (one symbiote-modal host
-// wrapping one collapsable symbiote-view container; only prop VALUES vary), so the tags are written
+// into to `insert` into. renderModal always paints the SAME two-tag shape (one modal host
+// wrapping one collapsable view container; only prop VALUES vary), so the tags are written
 // out and the computed props read off the fixed positions — the same call React's createElement
 // chain, Vue's h() chain and Svelte's markup all make. `children` then reaches the container
 // through the compiler's own `insert`, which is the point of view.tsx's header.
@@ -100,7 +100,7 @@ export function Modal(props) {
         style: local.style,
         passthrough: resolveAccessibilityProps(rest),
     });
-    // root = symbiote-modal > [container]; the user children nest UNDER the container View, never as
+    // root = modal > [container]; the user children nest UNDER the container View, never as
     // a direct sibling of the host (RN's modal content layout, render-modal.ts).
     const container = () => {
         const [first] = descriptor().children;
@@ -118,8 +118,8 @@ export function Modal(props) {
         class: local.class,
     }));
     return (<Show when={shouldRender()}>
-      <symbiote-modal {...hostBag()}>
-        <symbiote-view {...containerBag()}>{local.children}</symbiote-view>
-      </symbiote-modal>
+      <modal {...hostBag()}>
+        <view {...containerBag()}>{local.children}</view>
+      </modal>
     </Show>);
 }

package/build/components/{pressable.d.ts → pressable-props.d.ts}

@@ -1,10 +1,10 @@
-import { type Accessor } from 'solid-js';
+import type { Ref } from 'solid-js';
 import type { JSX } from '../jsx-runtime';
-import { type IAccessibilityProps, type IAriaProps, type IPressHandler, type IPressState, type IPressableAndroidRippleConfig, type IRectOffset } from '@symbiote-native/components';
-import { type IClassNameValue, type IStyleProp, type IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps, IPressHandler, IPressState, IPressableAndroidRippleConfig, IRectOffset } from '@symbiote-native/components';
+import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IHostInstance } from '../host-instance';
 export type { IPressState, IPressableAndroidRippleConfig, } from '@symbiote-native/components';
 type IPressableStyle = IStyleProp<IViewStyle> | ((state: IPressState) => IStyleProp<IViewStyle>);
-type IPressableChildren = JSX.Element | ((state: Accessor<IPressState>) => JSX.Element);
 export interface IPressableProps extends IAccessibilityProps, IAriaProps {
     onPress?: IPressHandler;
     onPressIn?: IPressHandler;
@@ -13,10 +13,12 @@ export interface IPressableProps extends IAccessibilityProps, IAriaProps {
     onLongPress?: IPressHandler;
     delayLongPress?: number;
     disabled?: boolean;
+    focusable?: boolean;
     cancelable?: boolean;
     hitSlop?: IRectOffset;
     pressRetentionOffset?: IRectOffset;
     unstable_pressDelay?: number;
+    minPressDuration?: number;
     android_ripple?: IPressableAndroidRippleConfig;
     android_disableSound?: boolean;
     onHoverIn?: IPressHandler;
@@ -25,7 +27,6 @@ export interface IPressableProps extends IAccessibilityProps, IAriaProps {
     delayHoverOut?: number;
     style?: IPressableStyle;
     class?: IClassNameValue;
-    children?: IPressableChildren;
+    ref?: Ref<IHostInstance>;
+    children?: JSX.Element;
 }
-export declare function Pressable(props: IPressableProps): JSX.Element;
-export declare function TouchablePressable(props: IPressableProps): JSX.Element;

package/build/components/pressable-props.js

@@ -0,0 +1,13 @@
+// The `<pressable>` tag's prop surface. The press machine — timers, the retention region, the
+// long-press and hover legs, the `disabled`/`focusable`/`accessible` folds and the Android ripple —
+// lives on the engine node as `core/components/src/behaviors/pressable.ts`, wired by
+// `../register`.
+//
+// THERE IS NO RENDER-PROP CHILD, and that is the one surface a tag cannot carry — same fact as
+// Vue's scoped slot (`adapters/vue/src/components/pressable-props.ts`), Solid's own version of it.
+// Press state lives on the engine node and never crosses back into Solid's reactivity as an
+// accessor, so `{state => …}` has no channel any more. A `style` CALLBACK still works — the engine
+// resolves it at both values of `pressed` (`isStyleCallback`, `core/engine/src/node.ts`) — and a
+// `:active` CSS rule is cheaper still. A CHILD that needs the state has to be given it: mirror
+// `onPressIn`/`onPressOut` into a local signal, which is what any app styling a descendant does.
+export {};

package/build/components/{refresh-control.d.ts → refresh-control-props.d.ts}

@@ -1,8 +1,9 @@
 import type { JSX } from '../jsx-runtime';
-import { type IAccessibilityProps, type IAriaProps } from '@symbiote-native/components';
-import { type IClassNameValue } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
+import type { IClassNameValue } from '@symbiote-native/engine';
 export interface IRefreshControlProps extends IAccessibilityProps, IAriaProps {
     refreshing: boolean;
+    id?: string;
     onRefresh?: () => void | Promise<void>;
     tintColor?: string;
     title?: string;
@@ -15,4 +16,3 @@ export interface IRefreshControlProps extends IAccessibilityProps, IAriaProps {
     class?: IClassNameValue;
     children?: JSX.Element;
 }
-export declare function RefreshControl(props: IRefreshControlProps): JSX.Element;

package/build/components/refresh-control-props.js

@@ -0,0 +1,7 @@
+// The `<refresh-control>` tag's prop surface. On iOS the tag resolves to Fabric's PullToRefreshView,
+// which lives INSIDE a scroll view as a childless sibling before the content container; on Android it
+// is AndroidSwipeRefreshLayout and WRAPS the scroll view instead. Which shape is built is the scroll
+// view's job, and the controlled-spinner handshake — mirror what native reported, command the value
+// back down when the app's `refreshing` disagrees — is the tag's own behavior
+// (`registerRefreshControlBehavior`, wired by `../register`).
+export {};

package/build/components/safe-area-view-props.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from '../jsx-runtime';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
+import type { IClassNameValue, IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+export interface ISafeAreaViewProps extends IAccessibilityProps, IAriaProps {
+    style?: IStyleProp<IViewStyle>;
+    id?: string;
+    class?: IClassNameValue;
+    onLayout?: (event: ISymbioteEvent) => void;
+    children?: JSX.Element;
+}

package/build/components/safe-area-view-props.js

@@ -0,0 +1,5 @@
+// The `<safe-area-view>` tag's prop surface. The wrapper forwarded a bag and nothing else — the
+// host does all the inset math, there is no JS-side layout anywhere in this project, and the
+// `id -> nativeID` alias plus the aria/role fold both run below the adapter (`foldHostBag` and the
+// engine's `fabricProps`). So there was nothing left for a component to hold.
+export {};

package/build/components/{scroll-view/shared.d.ts → scroll-view-props.d.ts}

@@ -1,14 +1,11 @@
-import { type Ref } from 'solid-js';
-import type { JSX } from '../../jsx-runtime';
-import { type IAccessibilityProps, type IAriaProps, type IScrollViewHandle } from '@symbiote-native/components';
-import { type IClassNameValue, type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
-import { type IStickyHeaderComponentType } from './sticky-header';
+import type { Ref } from 'solid-js';
+import type { JSX } from '../jsx-runtime';
+import type { ISymbioteEvent } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
+import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IHostInstance } from '../host-instance';
 export type { IScrollViewHandle } from '@symbiote-native/components';
-export type { IStickyHeaderComponentType, IStickyHeaderComponentProps, } from './sticky-header';
 type IScrollHandler = (event: ISymbioteEvent) => void;
-export type IScrollViewHostPlatform = {
-    refreshControlMode: 'sibling' | 'wrap';
-};
 export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
     style?: IStyleProp<IViewStyle>;
     class?: IClassNameValue;
@@ -31,7 +28,6 @@ export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
         x: number;
         y: number;
     };
-    refreshControl?: JSX.Element;
     removeClippedSubviews?: boolean;
     onContentSizeChange?: (width: number, height: number) => void;
     snapToInterval?: number;
@@ -42,7 +38,6 @@ export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
     disableIntervalMomentum?: boolean;
     stickyHeaderIndices?: number[];
     invertStickyHeaders?: boolean;
-    StickyHeaderComponent?: IStickyHeaderComponentType;
     keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
     keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
     maintainVisibleContentPosition?: {
@@ -79,7 +74,6 @@ export interface IScrollViewProps extends IAccessibilityProps, IAriaProps {
     onMomentumScrollBegin?: IScrollHandler;
     onMomentumScrollEnd?: IScrollHandler;
     onScrollToTop?: IScrollHandler;
-    ref?: Ref<IScrollViewHandle>;
+    ref?: Ref<IHostInstance>;
     children?: JSX.Element;
 }
-export declare function createScrollView(platform: IScrollViewHostPlatform): (props: IScrollViewProps) => JSX.Element;

package/build/components/scroll-view-props.js

@@ -0,0 +1,29 @@
+// `<scroll-view>` / `<horizontal-scroll-view>`'s prop surface, for Solid. No component left to
+// type — the tag IS the element, and the engine owns everything the wrapper used to assemble:
+// `buildStructure` builds the content node, `slotProps` carries `contentContainerStyle` onto it,
+// `claimedChildren` places a `<refresh-control>` child (a sibling on iOS, an inverting wrap on
+// Android), and the sticky seam lives in `core/components/src/behaviors/scroll-view/`.
+// `../register` names it.
+//
+// `stickyHeaderIndices` works on a bare tag — the behavior walks the COMMITTED children rather
+// than pulling "child at index N" out of a render function, so it needs no wrapper at all. The
+// `sticky-header` TAG is the other spelling, better for markup you control directly since it pins
+// by document order and no index has to stay in step with the children.
+//
+// TWO PROPS ARE NOT WHAT THEY LOOK LIKE:
+//
+//   horizontal            DELETED from the payload and rewritten from the TAG (`ownerFold`,
+//                         behaviors/scroll-view/shared.ts). Horizontal scroll is a separate native
+//                         ViewManager on Android, so the axis is the tag; a prop contradicting it
+//                         is dropped with a dlog. Typed here for parity and for a ported app.
+//   nestedScrollEnabled   defaults to `true` in the behavior, on both platforms, which every
+//                         wrapper used to write by hand.
+//
+// NO `refreshControl` PROP, deliberately — write a `<refresh-control>` CHILD instead; the
+// behavior claims it and places it per platform. Nothing reads a prop by that name, so typing one
+// would compile and paint nothing; leaving it out fails loudly at `tsc` with this comment beside
+// it, same as React's and Vue's barrels.
+//
+// `children` is a Solid `JSX.Element`, so this type is per-adapter by construction
+// (<prop_types_split_agnostic_vs_per_adapter>).
+export {};

package/build/components/switch-props.d.ts

@@ -0,0 +1,6 @@
+import type { ISwitchProps as ISwitchBaseProps } from '@symbiote-native/components';
+import type { IClassNameValue } from '@symbiote-native/engine';
+export type { ISwitchTrackColor, ISwitchChangeEvent, } from '@symbiote-native/components';
+export type ISwitchProps = ISwitchBaseProps & {
+    class?: IClassNameValue;
+};

package/build/components/switch-props.js

@@ -0,0 +1,5 @@
+// The `<switch>` tag's prop surface. The controlled handshake the wrapper used to run — the
+// lastNativeReport mirror, the snap-back command when the parent rejects a toggle, the platform
+// track-colour mapping — is the tag's own behavior now (`registerSwitchBehavior`, wired by
+// `../register`), which is also where the iOS/Android command-name split lives.
+export {};

package/build/components/text-input-props.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'solid-js';
+import type { ITextInputProps as ITextInputBaseProps } from '@symbiote-native/components';
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { IHostInstance } from '../host-instance';
+export type ITextInputProps = ITextInputBaseProps & {
+    class?: IClassNameValue;
+    ref?: Ref<IHostInstance>;
+};

package/build/components/text-input-props.js

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

package/build/components/{text.d.ts → text-props.d.ts}

@@ -1,6 +1,6 @@
-import { type Ref } from 'solid-js';
+import type { Ref } from 'solid-js';
 import type { JSX } from '../jsx-runtime';
-import { type IAccessibilityProps, type IAriaProps } from '@symbiote-native/components';
+import type { IAccessibilityProps, IAriaProps } from '@symbiote-native/components';
 import type { IClassNameValue, IStyleProp, ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
 import type { IHostInstance } from '../host-instance';
 export interface ITextProps extends IAccessibilityProps, IAriaProps {
@@ -15,6 +15,7 @@ export interface ITextProps extends IAccessibilityProps, IAriaProps {
     numberOfLines?: number;
     ellipsizeMode?: 'head' | 'middle' | 'tail' | 'clip';
     selectable?: boolean;
+    disabled?: boolean;
     adjustsFontSizeToFit?: boolean;
     minimumFontScale?: number;
     allowFontScaling?: boolean;
@@ -23,4 +24,3 @@ export interface ITextProps extends IAccessibilityProps, IAriaProps {
     ref?: Ref<IHostInstance>;
     children?: JSX.Element;
 }
-export declare function Text(props: ITextProps): JSX.Element;

package/build/components/text-props.js

@@ -0,0 +1,11 @@
+// The `<text>` tag's prop surface. Same story as `./view-props.ts` — the wrapper forwarded a bag
+// and its two folds live below the adapter now, with one addition: RN's `Text` DEFAULTS
+// (`ellipsizeMode`, `allowFontScaling`) are seeded by the renderer at `createElement` and re-seeded
+// on a patch that clears them, so a bare tag carries them exactly as the component did.
+//
+// THE NESTING (`RCTText` vs `RCTVirtualText`) was never this file's job and still is not. React
+// Native tracks a TextAncestor context so a Text inside another Text renders as a virtual span;
+// here the engine's commit walk carries `hasTextAncestor` down and picks the view name itself
+// (`viewNameFor`, core/engine/src/commit.ts), re-creating the node when the kind flips. Every
+// adapter emits the same flat `text` and the engine resolves it for all of them.
+export {};

package/build/components/touchable-native-feedback/touchable-native-feedback-props.d.ts

@@ -0,0 +1,8 @@
+import type { INativeFeedbackBackground } from '@symbiote-native/components';
+import type { JSX } from '../../jsx-runtime';
+import type { IPressableProps } from '../pressable-props';
+export interface ITouchableNativeFeedbackProps extends Omit<IPressableProps, 'style' | 'children'> {
+    background?: INativeFeedbackBackground;
+    useForeground?: boolean;
+    children?: JSX.Element;
+}

package/build/components/touchable-native-feedback/touchable-native-feedback-props.js

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

package/build/components/touchable-props.d.ts

@@ -0,0 +1,18 @@
+import type { JSX } from '../jsx-runtime';
+import type { IPressTimingProps } from '@symbiote-native/components';
+import type { IClassNameValue, IStyleProp, IViewStyle } from '@symbiote-native/engine';
+import type { IPressableProps } from './pressable-props';
+export type ITouchableBaseProps = Omit<IPressableProps, 'style' | 'class' | 'children'> & IPressTimingProps & {
+    style?: IStyleProp<IViewStyle>;
+    class?: IClassNameValue;
+    children?: JSX.Element;
+};
+export interface ITouchableOpacityProps extends ITouchableBaseProps {
+    activeOpacity?: number;
+}
+export interface ITouchableHighlightProps extends ITouchableBaseProps {
+    activeOpacity?: number;
+    underlayColor?: string;
+    onShowUnderlay?: () => void;
+    onHideUnderlay?: () => void;
+}

package/build/components/touchable-props.js

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

package/build/components/touchable-without-feedback/touchable-without-feedback-props.d.ts

@@ -0,0 +1,6 @@
+import type { IPressTimingProps } from '@symbiote-native/components';
+import type { JSX } from '../../jsx-runtime';
+import type { IPressableProps } from '../pressable-props';
+export interface ITouchableWithoutFeedbackProps extends Omit<IPressableProps, 'style' | 'children'>, IPressTimingProps {
+    children?: JSX.Element;
+}

package/build/components/touchable-without-feedback/touchable-without-feedback-props.js

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

package/build/components/{view.d.ts → view-props.d.ts}

@@ -1,6 +1,6 @@
-import { type Ref } from 'solid-js';
+import type { Ref } from 'solid-js';
 import type { JSX } from '../jsx-runtime';
-import { type IAccessibilityProps, type IAriaProps, type IResponderProps } from '@symbiote-native/components';
+import type { IAccessibilityProps, IAriaProps, IResponderProps } from '@symbiote-native/components';
 import type { IClassNameValue, IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
 import type { IHostInstance } from '../host-instance';
 export interface IViewProps extends IAccessibilityProps, IAriaProps, IResponderProps {
@@ -29,4 +29,3 @@ export interface IViewProps extends IAccessibilityProps, IAriaProps, IResponderP
     ref?: Ref<IHostInstance>;
     children?: JSX.Element;
 }
-export declare function View(props: IViewProps): JSX.Element;

package/build/components/view-props.js

@@ -0,0 +1,11 @@
+// The `<view>` tag's prop surface. The wrapper is gone: it forwarded a bag onto one host element
+// and did two folds, both of which now run below the adapter — `id -> nativeID` in the renderer's
+// `foldAliasKey` (which covers `createElement` and every later prop write, not just the wrapper's
+// one path) and the aria/role fold in the engine's `fabricProps`.
+//
+// ONE THING THE WRAPPER DID IS NOT INHERITED, and a consumer that builds a whole bag has to do it
+// itself: `withStableKeys`. Solid's `spread` walks only the CURRENT key set and has no removal
+// pass, so a key that stops being emitted keeps its last value on the native view forever
+// (`.claude/rules/solid-descriptor-bridge.md` §1). A bag whose keys are all statically present —
+// an ordinary attribute list, a `splitProps` rest proxy — is unaffected.
+export {};

package/build/components/virtualized-list/index.android.js

@@ -2,8 +2,9 @@
 // cannot sit beside the content the way iOS allows ("addViewAt: failed to insert view … at index 1").
 // Instead the RefreshControl (AndroidSwipeRefreshLayout) WRAPS the scroll host, which nests inside it
 // so the inner scroll takes the gesture before the refresh parent — RN's own ScrollView.js android
-// branch. Metro picks this file on an Android host; no Platform.OS read.
+// branch, decided by the `<scroll-view>` tag's own engine behavior registered for this platform
+// (`core/components/src/behaviors/scroll-view/index.android.ts`). Metro picks this file on an
+// Android host; no Platform.OS read. iOS and Android share one `createVirtualizedList` now — nothing
+// here differs per platform any more except which file Metro resolves.
 import { createVirtualizedList } from './shared.jsx';
-export const VirtualizedList = createVirtualizedList({
-    refreshControlMode: 'wrap',
-});
+export const VirtualizedList = createVirtualizedList();

package/build/components/virtualized-list/index.ios.js

@@ -1,9 +1,9 @@
 // VirtualizedList on iOS. The RefreshControl (PullToRefreshView) is a CHILD of the scroll host,
 // rendered as a childless SIBLING BEFORE the content container — RN ScrollView.js's
-// `{refreshControl}{contentContainer}`, the same fact this adapter's ScrollView and adapters/react's,
-// adapters/vue's and adapters/svelte's iOS bindings encode. Metro picks this file on an iOS host; no
-// Platform.OS read.
+// `{refreshControl}{contentContainer}`, decided by the `<scroll-view>` tag's own engine behavior
+// registered for this platform (`core/components/src/behaviors/scroll-view/index.ios.ts`), the same
+// one every other adapter's iOS binding registers. Metro picks this file on an iOS host; no
+// Platform.OS read. iOS and Android share one `createVirtualizedList` now — nothing here differs
+// per platform any more except which file Metro resolves.
 import { createVirtualizedList } from './shared.jsx';
-export const VirtualizedList = createVirtualizedList({
-    refreshControlMode: 'sibling',
-});
+export const VirtualizedList = createVirtualizedList();

package/build/components/virtualized-list/shared.d.ts

@@ -2,8 +2,6 @@ import { type Accessor, type Ref } from 'solid-js';
 import type { JSX } from '../../jsx-runtime';
 import { type IAccessibilityProps, type IAriaProps, type ICellLayout, type IViewabilityConfig, type IViewabilityConfigCallbackPair, type IViewableItemsChangedInfo, type ISeparatorProps, type ISeparators, type IViewToken, type IVirtualizedListHandle } from '@symbiote-native/components';
 import { type IClassNameValue, type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
-import type { IScrollViewHostPlatform } from '../scroll-view/shared';
-export type { IScrollViewHostPlatform };
 export type { ICellLayout, ISeparators, ISeparatorProps, IViewToken, IViewableItemsChangedInfo, IViewabilityConfig, IViewabilityConfigCallbackPair, IVirtualizedListHandle, };
 export interface IVirtualizedListCellInfo<ItemT> {
     item: ItemT;
@@ -72,4 +70,4 @@ export interface IVirtualizedListProps<ItemT> extends IAccessibilityProps, IAria
     }) => void;
 }
 export type IVirtualizedListComponent = <ItemT>(props: IVirtualizedListProps<ItemT>) => JSX.Element;
-export declare function createVirtualizedList(platform: IScrollViewHostPlatform): IVirtualizedListComponent;
+export declare function createVirtualizedList(): IVirtualizedListComponent;