@symbiote-native/solid 2.0.0 → 3.0.0

package/README.md

@@ -1,75 +1,101 @@
 # @symbiote-native/solid
 
-SolidJS adapter for SymbioteNative. Compiled Solid JSX drives real native iOS/Android views through
-the same `@symbiote-native/engine` every other adapter uses — React's renderer is never in the path.
-
-**Status: L4 done (parity phase complete).** The renderer seam, `mount`/`unmount`, the
-primitives, the stateful touch components, the Touchable family, Button / ImageBackground /
-InputAccessoryView, StatusBar and the list family all ship at full parity with the React
-reference — off `@symbiote-native/components`, via `descriptorToSolid` where the component has a
-shared render fn. The engine-owned runtime modules are re-exported from the barrel. `Portal`
-(same-surface content relocation, this adapter's twin of React's `createPortal`) and
-`createTunnel` (cross-surface) both ship, built over the universal renderer rather than
-`solid-js/web`'s DOM-bound `Portal`/`Dynamic`. `Dynamic` itself stays absent by design — nothing
-here needs it, and no other adapter ships a twin for parity to require one. See
-`symbiote-new-adapter` §7 for what each layer means.
+The **SolidJS adapter** for [SymbioteNative](../../README.md) — compiled Solid JSX drives real
+native iOS/Android views through the same `@symbiote-native/engine` every other adapter uses,
+with React's renderer never in the path. It targets `createRenderer` from `solid-js/universal`,
+Solid's own custom-renderer API — no shimming of private internals, no compiler running beside
+Metro, no custom Babel transformer path.
+
+<div align="center">
+
+![Solid driving real native iOS views through SymbioteNative](../../assets/solid-demo.gif)
+
+</div>
+
+> New to SymbioteNative? The [root README](../../README.md) has the architecture.
+
+---
+
+## Install
+
+```bash
+npm install @symbiote-native/solid react-native solid-js
+```
+
+`react-native` and `solid-js` stay your app's own top-level dependencies — this package only
+replaces the JS renderer that drives them. `npx @symbiote-native/cli new --framework solid` wires
+the Babel preset, Metro config, and `jsxImportSource` below for a new app; wiring them into an
+existing one still follows [`examples/solid`](../../examples/solid) rather than a generator.
 
-Solid's own control-flow `Switch`/`Match` are NOT re-exported from this package: `Switch` collides
-with RN's Switch component, which every adapter must export under that name. Import the control-flow
-pair from `solid-js` directly.
+Targets **Solid 1.9**, deliberately not 2.0 (RC as of 2026-08) — 2.0 moves the package to
+`@solidjs/universal`, changes `RendererOptions`, and changes the compiled-output shape. Moving to
+it is a rewrite of `src/renderer.ts`, not a range bump.
 
-The adapter is a regular publishable package (`@symbiote-native/solid` on npm, alongside React,
-Vue, Svelte and Angular) — it carries no `"private"` flag, so `changeset publish` and the
-pkg.pr.new canary cover it the same as every other adapter.
+---
 
-## Why Solid needs no DOM shim and no Metro transformer
+## Use it
 
-Solid ships an official custom-renderer API, `createRenderer` from `solid-js/universal`. That is
-exactly the framework-agnostic seam this project looks for in every framework, so the adapter is
-`RendererOptions`' ten methods mapped onto the engine's mutation API — no shimming of private
-internals (the Svelte adapter's approach, forced by an unmerged upstream PR), no compiler running
-beside Metro (Angular's AOT), and no custom `babelTransformerPath` at all.
+The app is ordinary Solid — the native primitives are plain lowercase intrinsic tags, no import
+needed:
 
-Targets **Solid 1.9**, deliberately not 2.0 (RC as of 2026-08): 2.0 moved the package to
-`@solidjs/universal`, changed `RendererOptions` (added `createSentinel`/`cleanupNodes`, gave
-`createElement` a staticProps argument) and changed the compiled-output shape (`use()` →
-`applyRef`/`ref`, `effect(fn, init)` → `effect(fn, effectFn)`). Moving to it is a rewrite of
-`src/renderer.ts`, not a range bump.
+```jsx
+import { createSignal } from 'solid-js';
 
-## Wiring an app
+export default function App() {
+  const [count, setCount] = createSignal(0);
+  return (
+    <view style={{ padding: 24 }}>
+      <text>Taps: {count()}</text>
+      <pressable onPress={() => setCount(c => c + 1)}>
+        <text>Tap me</text>
+      </pressable>
+    </view>
+  );
+}
+```
 
-`babel.config.js` — the preset ships preconfigured, so the app can't get `moduleName` or `generate`
-wrong:
+The zero-config entry wires the RN-backed host seams and registers the app in one call — this is
+what [`examples/solid`](../../examples/solid) actually uses:
 
 ```js
-module.exports = {
-  presets: [
-    'module:@react-native/babel-preset',
-    // LAST on purpose: Babel applies presets in reverse order, so this runs FIRST and claims the
-    // JSX before the React Native preset's own React-JSX transform can.
-    '@symbiote-native/solid/babel-preset',
-  ],
-};
+// index.js
+import { createApp } from '@symbiote-native/solid/bootstrap';
+import App from './App';
+import { name as appName } from './app.json';
+
+createApp(App).mount(appName);
 ```
 
-`metro.config.js` needs `unstable_conditionNames: ['browser']` — `solid-js`'s export map has a `node`
-branch pointing at its SSR build, and resolving that into a native bundle is the same failure mode
-the Svelte example hit (`lifecycle_function_unavailable` on the first mount).
+For anything the defaults don't cover, drive the lower-level seam directly — the same
+`registerRunnable` seam every other adapter uses:
+
+```js
+// index.js
+import { AppRegistry } from 'react-native';
+import { mount } from '@symbiote-native/solid';
+import App from './App';
+import { name as appName } from './app.json';
+
+AppRegistry.registerRunnable(appName, ({ rootTag }) => {
+  mount(rootTag, App);
+});
+```
 
-Solid compiles a component to `function App(props)` — a function with an uppercase name, which is
-exactly what react-refresh's `isLikelyComponentType` heuristic looks for. It then tries to patch a
-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$/]`.
+`babel.config.js` needs the adapter's preset LAST — Babel applies presets in reverse order, so
+listing it last runs it first, claiming the JSX before RN's own React-JSX transform can:
+
+```js
+module.exports = {
+  presets: ['module:@react-native/babel-preset', '@symbiote-native/solid/babel-preset'],
+};
+```
 
 ## 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.
+Nothing rewrites the source on the way there, so this adapter carries no Babel plugin of its own.
 
 ## `./renderer` is a compiler target, not a convenience export
 
@@ -95,46 +121,94 @@ cite the runtime line that forces them.
    through those lookups, so hiding a node it inserted itself desyncs its bookkeeping from the tree.
    Anchors are invisible to Fabric, not to traversal.
 
-## Typing — the app points `jsxImportSource` here, and that is the whole setup
+`tsconfig.json` points `jsxImportSource` at this package — the whole typing setup, no
+`solid-env.d.ts`, no per-file pragma:
 
 ```jsonc
-// tsconfig.json
-"jsx": "preserve",
-"jsxImportSource": "@symbiote-native/solid"
+{ "jsx": "preserve", "jsxImportSource": "@symbiote-native/solid" }
 ```
 
-That is all an app needs. No `/// <reference types>` line, no `solid-env.d.ts`, no per-file pragma:
-TypeScript resolves the entire JSX namespace from this package's `./jsx-runtime` entry, which is
-type-only (the emitted JS is `export {};` and nothing ever imports it — JSX becomes calls on
-`./renderer` through babel-preset-solid's `moduleName`, a separate mechanism).
+Solid's own control-flow `Switch`/`Match` are **not** re-exported from this package — `Switch`
+collides with RN's `Switch` component, which every adapter must export under that name. Import
+the control-flow pair from `solid-js` directly.
+
+---
+
+## Parity — and the one gap
+
+Solid reaches the same primitives, runtime modules, `Animated` on both drivers, gestures,
+accessibility, and the `VirtualizedList` family as React, Vue, Svelte, and Angular, verified
+on-device on iOS and Android — the root README's ["How Fast, Against Stock React
+Native"](../../README.md#how-fast-against-stock-react-native) section has the measured numbers.
+That parity is **structural, not hand-copied**: the component logic (state machines +
+render functions) is written **once** in `@symbiote-native/components`, and Solid supplies only
+its lifecycle via `descriptorToSolid`. `Portal` (same-surface content relocation) and
+`createTunnel` (cross-surface) both ship, built over the universal renderer rather than
+`solid-js/web`'s DOM-bound equivalents; `Dynamic` stays absent by design — nothing here needs it.
+
+The one deliberate gap, same as every other non-React adapter — **third-party React component
+packages** (`@react-native-community/slider` used directly) run only under the React adapter:
+their body calls React hooks off the React dispatcher, which is null under Solid.
+`@symbiote-native/slider` (this repo's own wrapper) _does_ ship a real Solid build through the
+same `createNode`-by-ViewConfig path Solid uses for its own primitives.
+
+---
+
+## A Solid-specific gotcha — Fast Refresh, not Metro's export conditions
+
+A compiled Solid component is a function with an uppercase name (`function App(props)`) —
+exactly what react-refresh's `isLikelyComponentType` heuristic accepts as a React component.
+Metro's HMR then tries to patch a React Fiber tree that doesn't exist here (no `react-reconciler`
+in this path), and the update is silently swallowed: no error, no visible change.
+`metro.config.js` needs `unstable_forceFullRefreshPatterns: [/\.tsx$/]` to force every `.tsx`
+edit to a full reload instead.
 
-Two things follow that the earlier `declare module 'solid-js'` shim could not give:
+`solid-js`'s export map does have a `node` branch pointing at its SSR build — the same shape that
+broke the Svelte canary — but Metro's own default condition set (`['react-native']`, contributed
+by `@react-native/metro-config`) never includes `node`, so the SSR branch is unreachable and the
+client build resolves correctly with no extra `unstable_conditionNames` config. Adding one would
+not fix anything that's broken and would actively drop `'react-native'` from the condition set
+(`mergeConfig` replaces the array rather than extending it) — leave it alone.
 
-- **A web tag is a compile error.** `<div>` reports `TS2339: Property 'div' does not exist on type
-'JSX.IntrinsicElements'` instead of building fine and failing on device. Augmenting solid-js's
-  namespace merges into its HTML/SVG list, so `<div>` stayed legal there. The Svelte adapter needed
-  a whole preprocessor for the same guarantee.
-- **JSX children are type-checked at all.** solid-js's `JSX.Element` names the DOM's `Node`, which
-  does not resolve without a DOM lib — and `skipLibCheck` swallows that error rather than reporting
-  it, leaving `Element` as `any` and every JSX child position unchecked. The visible symptom was
-  small (a render-prop parameter needed an explicit annotation); the cause was not.
+---
 
-The risk recorded when this was deferred — that our `Element` must line up with what solid-js's own
-`<Show>`/`<For>` return — resolves for the same reason: solid's is `any` in the DOM-less programs we
-target, so it is assignable to anything of ours. `src/jsx-runtime.test.tsx` pins the runtime half;
-the type half rides on `examples/solid`'s typecheck. Full rationale, the measurements behind each
-claim, and the one config that would break it: `.claude/rules/solid-jsx-namespace.md`.
+## Run it
+
+[`examples/solid`](../../examples/solid) is a stock React Native 0.86 app — the steps are
+identical to the [React adapter](../react/README.md#run-it), just swap the directory:
+
+```bash
+cd examples/solid
+npm install
+bundle install                 # first time only — installs CocoaPods itself
+bundle exec pod install        # fetch native pods
+
+# terminal 1 — Metro (DEBUG=1 turns on diagnostic logs)
+DEBUG=1 npm start --reset-cache
+
+# terminal 2 — build + launch
+npm run ios                    # iOS simulator
+npm run android                # Android emulator
+```
+
+---
+
+## Test it
+
+```bash
+pnpm test                      # vitest, from the workspace root — headless, fake Fabric slot
+```
 
-## Single root per process
+The canary's own real-device verification is the perf benchmark run (see [Run
+it](#run-it) plus the root README's device numbers), not an automated on-device suite —
+`examples/solid` is the one canary without a Detox `e2e/` setup yet, unlike React/Vue/Svelte/
+Angular. Why headless testing comes for free otherwise: see
+[Testing](../../README.md#testing).
 
-Compiled JSX calls module-level functions with no surface argument, so there is nowhere to thread a
-per-surface renderer through — the active surface is module state, set by `mount`. The Svelte adapter
-reached the same single-root conclusion for its own reasons.
+---
 
 ## Reference
 
-- The canary app: `examples/solid` (its README covers running it and the checks it carries).
-- The engine API this targets: the `symbiote-engine-core` skill, `core/engine/src/node.ts`.
-- Building/porting an adapter: the `symbiote-new-adapter` skill.
+- The canary app: [`examples/solid`](../../examples/solid).
 - The nodeOps table this mirrors: `adapters/vue/src/renderer/index.ts`.
 - The same seam on an ANSI target: `wolf-tui/packages/solid/src/renderer/node-ops.ts`.

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

@@ -113,6 +113,6 @@ export function FlatList(props) {
     // rebuilds (RN documents changing it live as unsupported — "change the key prop" — which is the
     // same fresh start) while every other prop change re-props the live list.
     return (<Show when={isMultiColumn()} fallback={<VirtualizedList {...passthrough} data={props.data} getItem={(_source, index) => props.data[index]} getItemCount={() => props.data.length} renderItem={props.renderItem} keyExtractor={props.keyExtractor} ItemSeparatorComponent={props.ItemSeparatorComponent} onViewableItemsChanged={props.onViewableItemsChanged} viewabilityConfigCallbackPairs={props.viewabilityConfigCallbackPairs}/>}>
-      <VirtualizedList {...passthrough} data={rows()} getItem={(_source, index) => rows()[index]} getItemCount={() => rows().length} renderItem={renderRow} keyExtractor={rowKeyExtractor} ItemSeparatorComponent={rowSeparatorComponent()} onViewableItemsChanged={rowViewability()} viewabilityConfigCallbackPairs={rowViewabilityPairs()}/>
+      <VirtualizedList {...passthrough} data={rows()} getItem={(_source, index) => rows()[index]} getItemCount={() => rows().length} renderItem={renderRow} keyExtractor={(row) => rowKeyExtractor(row, props.keyExtractor)} ItemSeparatorComponent={rowSeparatorComponent()} onViewableItemsChanged={rowViewability()} viewabilityConfigCallbackPairs={rowViewabilityPairs()}/>
     </Show>);
 }

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

@@ -23,7 +23,7 @@
 // keyboard event without re-subscribing (React re-runs its useEffect for that; here the closure
 // already sees the live value).
 import { createMemo, createSignal, onCleanup, splitProps } from 'solid-js';
-import { computeInset, keyboardAvoidingEventNamesFor, readKeyboardFrame, readLayoutFrame, readPrefersCrossFadeTransitions, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from '@symbiote-native/components';
+import { computeInset, configureKeyboardAvoidingAnimation, keyboardAvoidingEventNamesFor, readKeyboardAnimationTiming, readKeyboardFrame, readLayoutFrame, readPrefersCrossFadeTransitions, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from '@symbiote-native/components';
 import { Keyboard, Platform, dlog, } from '@symbiote-native/engine';
 import { withStableKeys } from '../utils/stable-keys.js';
 // Read by KeyboardAvoidingView itself; everything else (the aria/role aliases, accessibility*,
@@ -62,6 +62,7 @@ export function KeyboardAvoidingView(props) {
     const onShow = (payload) => {
         const keyboard = readKeyboardFrame(payload);
         const offset = local.keyboardVerticalOffset ?? DEFAULT_VERTICAL_OFFSET;
+        const previousInset = inset();
         const next = computeInset(frame, keyboard, offset, {
             behavior: local.behavior,
             // The inset CURRENTLY applied (RN's this.state.bottom). Read from the signal at event time so
@@ -69,9 +70,12 @@ export function KeyboardAvoidingView(props) {
             // frame shorter by exactly that much and core adds it back to cancel the shrink. Without it
             // each further keyboard event computes a smaller overlap and the view walks back down under
             // the keyboard. Core gates the correction on 'height'; the other modes ignore the value.
-            previousInset: inset(),
+            previousInset,
             prefersCrossFadeTransitions,
         });
+        // RN's `_updateBottomIfNecessary` skips the animation when the inset did not change.
+        if (next !== previousInset)
+            configureKeyboardAvoidingAnimation(readKeyboardAnimationTiming(payload), local.enabled !== false);
         dlog(`KeyboardAvoidingView show -> inset ${next}`);
         setInset(next);
     };

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

@@ -15,7 +15,9 @@ export interface IPressableProps extends IAccessibilityProps, IAriaProps {
     disabled?: boolean;
     focusable?: boolean;
     cancelable?: boolean;
+    blockNativeResponder?: boolean;
     hitSlop?: IRectOffset;
+    testOnly_pressed?: boolean;
     pressRetentionOffset?: IRectOffset;
     unstable_pressDelay?: number;
     minPressDuration?: number;

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

@@ -5,4 +5,5 @@ export interface ITouchableNativeFeedbackProps extends Omit<IPressableProps, 'st
     background?: INativeFeedbackBackground;
     useForeground?: boolean;
     children?: JSX.Element;
+    touchSoundDisabled?: boolean;
 }

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

@@ -13,6 +13,8 @@ export interface ITouchableOpacityProps extends ITouchableBaseProps {
 export interface ITouchableHighlightProps extends ITouchableBaseProps {
     activeOpacity?: number;
     underlayColor?: string;
+    touchSoundDisabled?: boolean;
+    testOnly_pressed?: boolean;
     onShowUnderlay?: () => void;
     onHideUnderlay?: () => void;
 }

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

@@ -3,4 +3,5 @@ import type { JSX } from '../../jsx-runtime';
 import type { IPressableProps } from '../pressable-props';
 export interface ITouchableWithoutFeedbackProps extends Omit<IPressableProps, 'style' | 'children'>, IPressTimingProps {
     children?: JSX.Element;
+    touchSoundDisabled?: boolean;
 }

package/build/components/virtualized-list/shared.jsx

@@ -54,7 +54,7 @@
 //    the flip is an explicit rebuild boundary (trap 5), with the build untracked so every other prop
 //    re-props the SAME nodes through `spread`.
 import { For, Show, createEffect, createMemo, createSignal, on, onCleanup, splitProps, untrack, } from 'solid-js';
-import { DEFAULT_END_REACHED_THRESHOLD, DEFAULT_INITIAL_NUM_TO_RENDER, DEFAULT_MAX_TO_RENDER_PER_BATCH, DEFAULT_START_REACHED_THRESHOLD, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD, DEFAULT_WINDOW_SIZE, EMPTY_OFFSET, FIRST_INDEX, NO_INDEX, INVERTED_X_STYLE, INVERTED_Y_STYLE, buildListPlan, buildScrollViewHandle, buildViewabilityPairs, nextStickyHeaderY, isSeparatorGapInRange, listEffectSignature, attachStickyScroll, forwardScrollEvent, resolveAccessibilityProps, resolveScrollForwarding, selectScrollIntrinsics, createInitialListState, readLayoutLength, readLayoutOffset, readLayoutNumber, readScrollOffset, reduceList, resolveItemKey, } from '@symbiote-native/components';
+import { DEFAULT_INITIAL_NUM_TO_RENDER, DEFAULT_MAX_TO_RENDER_PER_BATCH, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD, DEFAULT_WINDOW_SIZE, EMPTY_OFFSET, FIRST_INDEX, NO_INDEX, INVERTED_X_STYLE, INVERTED_Y_STYLE, buildListPlan, buildScrollViewHandle, buildViewabilityPairs, nextStickyHeaderY, isSeparatorGapInRange, listEffectSignature, attachStickyScroll, forwardScrollEvent, resolveAccessibilityProps, resolveScrollForwarding, selectScrollIntrinsics, createInitialListState, readLayoutLength, readLayoutOffset, readLayoutNumber, readScrollOffset, reduceList, resolveItemKey, } from '@symbiote-native/components';
 import { AnimatedValue, dlog, event as animatedEvent, getNativeTag, isNativeAnimatedAvailable, isSymbioteNode, whenCommitted, resolveClassName, } from '@symbiote-native/engine';
 import { createElement, insert, insertNode, spread } from '../../renderer.js';
 import { withStableKeys } from '../../utils/stable-keys.js';
@@ -190,8 +190,8 @@ export function createVirtualizedList() {
                 maxToRenderPerBatch: props.maxToRenderPerBatch ?? DEFAULT_MAX_TO_RENDER_PER_BATCH,
                 updateCellsBatchingPeriod: props.updateCellsBatchingPeriod ??
                     DEFAULT_UPDATE_CELLS_BATCHING_PERIOD,
-                onEndReachedThreshold: props.onEndReachedThreshold ?? DEFAULT_END_REACHED_THRESHOLD,
-                onStartReachedThreshold: props.onStartReachedThreshold ?? DEFAULT_START_REACHED_THRESHOLD,
+                onEndReachedThreshold: props.onEndReachedThreshold,
+                onStartReachedThreshold: props.onStartReachedThreshold,
                 maintainVisibleContentPosition: props.maintainVisibleContentPosition,
                 initialScrollIndex: props.initialScrollIndex,
                 onEndReachedActive: props.onEndReached !== undefined,
@@ -242,8 +242,12 @@ export function createVirtualizedList() {
                         // lastViewable is folded back only when the fire actually LANDS, so a debounce superseded
                         // mid-flight still diffs against the last committed set.
                         const fire = () => {
-                            for (const pair of pairs)
-                                pair.onViewableItemsChanged(info);
+                            for (const pair of pairs) {
+                                pair.onViewableItemsChanged({
+                                    ...info,
+                                    viewabilityConfig: pair.viewabilityConfig,
+                                });
+                            }
                             dispatch({ kind: 'viewable-fired', map });
                         };
                         if (viewableTimer !== null) {

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
@@ -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/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/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;
@@ -47,4 +29,29 @@ export declare const Animated: {
     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/renderer.js

@@ -17,13 +17,13 @@
 // babel.transformSync over representative JSX (elements, dynamic text, <Show>, <For>, spread,
 // ref) rather than read off the docs.
 import { createRenderer } from 'solid-js/universal';
-import { appendChild, createAnchor, createElement as createEngineElement, createRawText, dlog, insertBefore, removeChild as removeEngineChild, routeProp, setNodePressed, setProp as setEngineProp, setText as setEngineText, toPublicInstance, RAW_TEXT_COMPONENT, SymbioteSurface, } from '@symbiote-native/engine';
+import { appendChild, createAnchor, createElement as createEngineElement, createRawText, dlog, firstChildOf, insertBefore, isRawTextNode, isTextContainer, nextSiblingOf, parentOf, removeChild as removeEngineChild, routeProp, setNodePressed, setProp as setEngineProp, setText as setEngineText, textOf, toPublicInstance, SymbioteSurface, propOf, } from '@symbiote-native/engine';
 import { descriptorFor, TEXT_INPUT_MULTILINE_TAG, } from '@symbiote-native/components';
 function isSurface(node) {
     return node instanceof SymbioteSurface;
 }
 function isRawText(node) {
-    return !isSurface(node) && node.component === RAW_TEXT_COMPONENT;
+    return !isSurface(node) && isRawTextNode(node);
 }
 // One active surface per process. This is FORCED here, not chosen: the compiled-JSX contract above
 // means every mutation arrives through module-level functions with no surface argument, so there is
@@ -50,11 +50,6 @@ function requestCommit() {
     }
     activeSurface.requestCommit();
 }
-function siblingsOf(node) {
-    if (node.parent !== undefined)
-        return node.parent.children;
-    return activeSurface?.children ?? [];
-}
 // Hoisted out of nodeOps and exported because descriptor-to-solid.ts needs the same text-update
 // path for a Descriptor's string child, and createRenderer() only hands back the 11 names the JSX
 // compiler imports — replaceText is not among them. Going through here rather than calling the
@@ -84,10 +79,7 @@ function asText(value) {
 // has to DETACH its anchor host from the portal target on cleanup. Going through here rather than
 // calling the engine's removeChild directly is what keeps the mutation paired with requestCommit(),
 // and keeps the surface-vs-node branch in one place.
-// The REFUSED path's half of `:active`, and the reason a refusal costs the component instance
-// rather than the pressed styling. A `<Pressable>` the lowering left as a component still owns its
-// own press machine, and one call here puts the node into its pressed state so `.btn:active`
-// applies exactly as it would on a lowered tag.
+// The `:active` half: one call here puts the node into its pressed state so `.btn:active` applies.
 //
 // Exported paired with requestCommit() for the same reason removeNode below is: the press arrives
 // from a NATIVE EVENT, outside any renderer mutation, so nothing else schedules a commit. React's
@@ -110,41 +102,23 @@ export function removeNode(parent, node) {
         removeEngineChild(parent, node);
     requestCommit();
 }
-const TEXT_FOLDS = new Map([
-    ['ellipsizeMode', value => value ?? 'tail'],
-    ['allowFontScaling', value => value !== false],
-]);
-function seedTextDefaults(node) {
-    for (const [key, fold] of TEXT_FOLDS)
-        setEngineProp(node, key, fold(undefined));
-}
-// Seeding at CREATE is not enough, and the gap is device-only. A framework that clears a prop it
-// set earlier hands us an explicit `undefined` at PATCH time, and the default has to come BACK
-// rather than stay cleared — RN treats a missing prop and an explicit undefined alike, and only a
-// literal `false` opts out of allowFontScaling. Two Map lookups on text nodes only, and none at
-// all on a View, so it stays off the hot path.
-function foldTextValue(node, key, value) {
-    if (!node.isText)
-        return value;
-    const fold = TEXT_FOLDS.get(key);
-    return fold === undefined ? value : fold(value);
-}
-// The alias fold, at the RENDERER — the only place it can live now that an app writes the tag
-// itself. A bare `<view id="x">` has no wrapper to inherit the fold from, and `id` is a key Fabric
-// does not know, so it committed nothing while the component committed `nativeID`. Measured by
-// mounting both forms and diffing committed key NAMES; totals were identical and said nothing.
+// RN's two Text defaults left this renderer on 2026-09-18, and the per-key FOLD went with them. It
+// was the last and subtlest of the three shapes this file tried: a create-time SEED (gone a month
+// earlier, 6 000 wasted crossings per 1 000-row create), then a substitute-on-`undefined`, then a
+// fold per key — because `?? 'tail'` has to catch a null too, and substituting only on `undefined`
+// meant `<text ellipsizeMode={null}>` committed null, device-only and silent.
 //
-// One string comparison rather than a Map lookup, because this sits on the per-prop write path —
-// 32 001 prop writes on a benchmark create, where a Map.get is the kind of cost the engine spent
-// this month removing. That is only safe while every primitive shares ONE alias pair, which is a
-// property of the shared spec and not of this file, so `renderer-alias-fold.test.ts` re-derives
-// both constants from `HOST_PRIMITIVES` and fails the moment a second pair appears.
-const ALIAS_FROM = 'id';
-const ALIAS_TO = 'nativeID';
+// All three were answering a question the layer below now answers for everyone: the rule reads the
+// AUTHORED bag at payload time (`foldTextDefaults`, `SymbioteFabricProps.cpp`), where a null, an
+// explicit `undefined` and an absent prop are all simply "not a value the author chose". The
+// null case that cost this file two revisions is `ellipsize->isNull()` there, in one place, for
+// every adapter.
+// The `id` -> `nativeID` fold and its `aliasedNodes` WeakSet left this file on 2026-09-18. The
+// memory was the right shape and the wrong LAYER: `routeProp` carries it now, so all five adapters
+// resolve the precedence identically instead of three of them doing it three ways.
 // `multiline` selects between TWO Fabric views, so the TAG decides and no prop write moves a node
-// between them. Two of the three paths that can build the node resolve it earlier — the wrapper
-// CONSUMES the prop to pick its intrinsic, a lowering transform reads a literal at compile time —
-// and an author writing the tag by hand has neither, which leaves two silent divergences.
+// between them. An author writing `<text-input multiline>` instead of `<text-input-multiline>` gets
+// the single-line view with a prop no ViewConfig on it declares — two silent divergences.
 //
 // The shared behavior (`core/components/src/behaviors/text-input.ts`) already makes the PAYLOAD
 // follow the tag. The complaint has to live here instead of there: `foldPayload` runs inside the
@@ -152,32 +126,12 @@ const ALIAS_TO = 'nativeID';
 // call site — measured, a test awaiting the mount sees `nothing committed` rather than the error.
 const MULTILINE_PROP = 'multiline';
 function assertMultilineMatchesTag(node, value) {
-    if ((value === true) === (node.props[MULTILINE_PROP] === true))
+    if ((value === true) === (propOf(node, MULTILINE_PROP) === true))
         return;
     throw new Error(`multiline={${String(value)}} contradicts the tag: <text-input> and ` +
         `<text-input-multiline> are different Fabric views and no prop write moves a node ` +
         `between them. Pick the tag (a runtime choice needs a <Show> around both).`);
 }
-// RN gives `id` UNCONDITIONAL priority when both are set (View.js:77-79,
-// `processedProps.nativeID = id`), and `foldHostBag` reproduces that by deleting the source key out
-// of a whole bag. This renderer never sees a bag — it folds one key at a time — so precedence would
-// otherwise come out as source order, and `<view id nativeID>` would keep the stale legacy value
-// while `<view nativeID id>` would not. The wrapper hid that; a bare tag does not.
-//
-// So the node remembers that its nativeID came from an `id`, and a later raw `nativeID` write loses
-// to it. Off the hot path in every ordinary case: nothing is touched unless the prop being written
-// is one of these two names.
-const aliasedNodes = new WeakSet();
-function foldAliasKey(node, name, value) {
-    if (name === ALIAS_FROM) {
-        if (value === undefined)
-            aliasedNodes.delete(node);
-        else
-            aliasedNodes.add(node);
-        return ALIAS_TO;
-    }
-    return name;
-}
 const nodeOps = {
     createElement(tag) {
         const descriptor = descriptorFor(tag);
@@ -187,8 +141,6 @@ const nodeOps = {
         // nothing, and the press machine silently never attaches. Registering under the Fabric name
         // instead would be worse: every plain `View` would get a press machine.
         const node = createEngineElement(descriptor.component, descriptor.isText, tag);
-        if (descriptor.isText)
-            seedTextDefaults(node);
         // Only the multiline tag is seeded: writing `multiline: false` on the single-line one would add
         // a key the wrapper's payload does not carry, i.e. a divergence in the other direction.
         if (tag === TEXT_INPUT_MULTILINE_TAG)
@@ -230,13 +182,11 @@ const nodeOps = {
             return;
         if (name === MULTILINE_PROP)
             assertMultilineMatchesTag(node, value);
-        if (name === ALIAS_TO && aliasedNodes.has(node))
-            return;
         // routeProp makes the prop-vs-event decision from the node's ViewConfig (onPress on a View
         // becomes a listener; onTintColor on a Switch stays a prop), and centralizes the class+style
-        // merge. Shared with React and Vue — never re-implement an `onX` check here
-        // (symbiote-engine-core §2).
-        routeProp(node, foldAliasKey(node, name, value), foldTextValue(node, name, value));
+        // merge and the `id` -> `nativeID` rename. Shared with React and Vue — never re-implement an
+        // `onX` check here (symbiote-engine-core §2).
+        routeProp(node, name, value);
         requestCommit();
     },
     insertNode(parent, node, anchor) {
@@ -246,12 +196,12 @@ const nodeOps = {
         if (isSurface(node))
             return;
         const before = anchor !== undefined && !isSurface(anchor) ? anchor : undefined;
-        if (isRawText(node) && (isSurface(parent) || !parent.isText)) {
+        if (isRawText(node) && (isSurface(parent) || !isTextContainer(parent))) {
             // Fabric has no bare-text host: RCTRawText is only valid as a <Text> child. Reached by a
             // dynamic expression that resolves to a string outside a <Text>, e.g.
             // `<symbiote-view>{label()}</symbiote-view>`. Failing loudly at mount beats building an
             // invalid tree that crashes deeper in native with a far less legible error.
-            throw new Error(`Text string "${String(node.props.text)}" must be rendered inside a <Text>`);
+            throw new Error(`Text string "${textOf(node) ?? ''}" must be rendered inside a <Text>`);
         }
         if (isSurface(parent)) {
             if (before !== undefined)
@@ -281,10 +231,10 @@ const nodeOps = {
     getParentNode(node) {
         if (isSurface(node))
             return undefined;
-        const parent = node.parent ?? activeSurface;
+        const parent = parentOf(node) ?? activeSurface;
         if (parent === undefined || isSurface(parent))
             return parent;
-        const grandparent = parent.parent;
+        const grandparent = parentOf(parent);
         if (grandparent !== undefined && grandparent.childHost === parent) {
             return grandparent;
         }
@@ -307,14 +257,14 @@ const nodeOps = {
     getFirstChild(node) {
         if (isSurface(node))
             return node.children[0];
-        return (node.childHost ?? node).children[0];
+        return firstChildOf(node.childHost ?? node);
     },
     getNextSibling(node) {
         if (isSurface(node))
             return undefined;
-        const siblings = siblingsOf(node);
-        const index = siblings.indexOf(node);
-        return index >= 0 ? siblings[index + 1] : undefined;
+        // The surface is handed over because a TOP-LEVEL node has no parent to read a sibling list
+        // from — the surface owns that list. The engine returns undefined rather than guessing.
+        return nextSiblingOf(node, activeSurface);
     },
 };
 // The compiled-JSX contract. See the module header: these names are imported by generated code,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/solid",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "SymbioteNative's Solid adapter — a solid-js/universal createRenderer driving real native iOS/Android views through the same engine as every other adapter.",
   "keywords": [
     "react-native",
@@ -62,19 +62,19 @@
   "dependencies": {
     "babel-preset-solid": "^1.9.12",
     "typescript": "~6.0.0",
-    "@symbiote-native/components": "2.0.0",
+    "@symbiote-native/components": "3.0.0",
     "@symbiote-native/css-parser": "0.5.0"
   },
   "peerDependencies": {
     "solid-js": ">=1.9.0",
     "react-native": ">=0.86",
-    "@symbiote-native/engine": "^0.5.0"
+    "@symbiote-native/engine": "^1.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "solid-js": "^1.9.14",
-    "@symbiote-native/engine": "0.5.0",
-    "@symbiote-native/test-utils": "0.3.0"
+    "@symbiote-native/engine": "1.0.0",
+    "@symbiote-native/test-utils": "0.3.1"
   },
   "scripts": {
     "typecheck": "tsc --build",