@symbiote-native/solid 3.1.0 → 3.3.0

package/build/index.js

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

package/build/jsx-runtime.d.ts

@@ -4,6 +4,7 @@ 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 { ICheckboxProps } from './components/checkbox-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';
@@ -26,6 +27,7 @@ interface ICrossedPrimitiveProps {
     text: ITextProps;
     pressable: IPressableProps;
     button: IButtonProps;
+    checkbox: ICheckboxProps;
     image: IImageProps;
     'image-background': IImageBackgroundProps;
     'input-accessory-view': IInputAccessoryViewProps;

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

@@ -1,56 +1,69 @@
-import { AnimatedValue, AnimatedValueXY, AnimatedColor, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent } from '@symbiote-native/engine';
 import { createAnimatedComponent } from './create-animated-component';
 export { createAnimatedComponent } from './create-animated-component';
 export type { IAnimatedComponentProps } from './create-animated-component';
 export { AnimatedProps, AnimatedStyle, AnimatedTransform, } from '@symbiote-native/engine';
 type IAnimatedComponent = ReturnType<typeof createAnimatedComponent>;
 export declare const Animated: {
-    Value: typeof AnimatedValue;
-    ValueXY: typeof AnimatedValueXY;
-    Color: typeof AnimatedColor;
+    timing: {
+        (value: import("@symbiote-native/engine").AnimatedValue, config: import("@symbiote-native/engine").ITimingConfig): import("@symbiote-native/engine").ICompositeAnimation;
+        (value: import("@symbiote-native/engine").IVectorValue, config: import("@symbiote-native/engine").IVectorTimingConfig): import("@symbiote-native/engine").ICompositeAnimation;
+    };
+    spring: {
+        (value: import("@symbiote-native/engine").AnimatedValue, config: import("@symbiote-native/engine").ISpringConfig): import("@symbiote-native/engine").ICompositeAnimation;
+        (value: import("@symbiote-native/engine").IVectorValue, config: import("@symbiote-native/engine").IVectorSpringConfig): import("@symbiote-native/engine").ICompositeAnimation;
+    };
+    decay: (_value: import("@symbiote-native/engine").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;
+    Value: typeof import("@symbiote-native/engine").AnimatedValue;
+    ValueXY: typeof import("@symbiote-native/engine").AnimatedValueXY;
+    Color: typeof import("@symbiote-native/engine").AnimatedColor;
+    Interpolation: typeof import("@symbiote-native/engine").AnimatedInterpolation;
+    Node: typeof import("@symbiote-native/engine").AnimatedNode;
     Easing: import("@symbiote-native/engine").IEasing;
-    timing: typeof timing;
-    spring: typeof spring;
-    decay: typeof decay;
-    parallel: typeof parallel;
-    sequence: typeof sequence;
-    stagger: typeof stagger;
-    loop: typeof loop;
-    delay: typeof delay;
-    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;
+    add: typeof import("@symbiote-native/engine").add;
+    subtract: typeof import("@symbiote-native/engine").subtract;
+    multiply: typeof import("@symbiote-native/engine").multiply;
+    divide: typeof import("@symbiote-native/engine").divide;
+    modulo: typeof import("@symbiote-native/engine").modulo;
+    diffClamp: typeof import("@symbiote-native/engine").diffClamp;
+    event: typeof import("@symbiote-native/engine").event;
+    attachNativeEvent: typeof import("@symbiote-native/engine").attachNativeEvent;
+    forkEvent: typeof import("@symbiote-native/engine").forkEvent;
+    unforkEvent: typeof import("@symbiote-native/engine").unforkEvent;
+    Event: typeof import("@symbiote-native/engine").AnimatedEvent;
     FlatList: IAnimatedComponent;
     SectionList: IAnimatedComponent;
     createAnimatedComponent: typeof createAnimatedComponent;
 } | {
-    Value: typeof AnimatedValue;
-    ValueXY: typeof AnimatedValueXY;
-    Color: typeof AnimatedColor;
+    Value: typeof import("@symbiote-native/engine").AnimatedValue;
+    ValueXY: typeof import("@symbiote-native/engine").AnimatedValueXY;
+    Color: typeof import("@symbiote-native/engine").AnimatedColor;
+    Interpolation: typeof import("@symbiote-native/engine").AnimatedInterpolation;
+    Node: typeof import("@symbiote-native/engine").AnimatedNode;
     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;
+    timing: typeof import("@symbiote-native/engine").timing;
+    spring: typeof import("@symbiote-native/engine").spring;
+    decay: typeof import("@symbiote-native/engine").decay;
+    parallel: typeof import("@symbiote-native/engine").parallel;
+    sequence: typeof import("@symbiote-native/engine").sequence;
+    stagger: typeof import("@symbiote-native/engine").stagger;
+    loop: typeof import("@symbiote-native/engine").loop;
+    delay: typeof import("@symbiote-native/engine").delay;
+    add: typeof import("@symbiote-native/engine").add;
+    subtract: typeof import("@symbiote-native/engine").subtract;
+    multiply: typeof import("@symbiote-native/engine").multiply;
+    divide: typeof import("@symbiote-native/engine").divide;
+    modulo: typeof import("@symbiote-native/engine").modulo;
+    diffClamp: typeof import("@symbiote-native/engine").diffClamp;
+    event: typeof import("@symbiote-native/engine").event;
+    attachNativeEvent: typeof import("@symbiote-native/engine").attachNativeEvent;
+    forkEvent: typeof import("@symbiote-native/engine").forkEvent;
+    unforkEvent: typeof import("@symbiote-native/engine").unforkEvent;
+    Event: typeof import("@symbiote-native/engine").AnimatedEvent;
     FlatList: IAnimatedComponent;
     SectionList: IAnimatedComponent;
     createAnimatedComponent: typeof createAnimatedComponent;

package/build/modules/animated/index.js

@@ -19,7 +19,7 @@
 // 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 { AnimatedDrivers, AnimatedMock, Platform, } from '@symbiote-native/engine';
 import { FlatList } from '../../components/flat-list/index.jsx';
 import { SectionList } from '../../components/section-list/index.jsx';
 import { createAnimatedComponent } from './create-animated-component.jsx';
@@ -29,35 +29,11 @@ export { createAnimatedComponent } from './create-animated-component.jsx';
 export { AnimatedProps, AnimatedStyle, AnimatedTransform, } from '@symbiote-native/engine';
 let animatedFlatList;
 let animatedSectionList;
-// The live, JS-driven driver half. RN's AnimatedImplementation.
-const liveDrivers = {
-    Value: AnimatedValue,
-    ValueXY: AnimatedValueXY,
-    Color: AnimatedColor,
-    Easing,
-    timing,
-    spring,
-    decay,
-    parallel,
-    sequence,
-    stagger,
-    loop,
-    delay,
-    add,
-    subtract,
-    multiply,
-    divide,
-    modulo,
-    diffClamp,
-    event,
-    forkEvent,
-    unforkEvent,
-};
 // RN swaps the WHOLE driver namespace for the mock when the host reports isDisableAnimations
 // (reduced motion / test env): same surface, every animation jumping to its final value with no
 // frames. The COMPONENTS stay live in both branches — only this half is swapped, exactly as RN
 // spreads `...Animated` over the same component getters.
-const drivers = Platform.isDisableAnimations ? AnimatedMock : liveDrivers;
+const drivers = Platform.isDisableAnimations ? AnimatedMock : AnimatedDrivers;
 export const Animated = {
     get FlatList() {
         animatedFlatList ??= createAnimatedComponent(FlatList);

package/build/modules/app-registry/index.d.ts

@@ -1,7 +1,7 @@
 import type { Component } from 'solid-js';
-import { type IAppParameters } from '@symbiote-native/engine';
+import { HeadlessJsTaskError, type IAppParameters } from '@symbiote-native/engine';
 export type IComponentProvider = () => Component;
 export type IWrapperComponentProvider = (appParameters: IAppParameters) => Component;
 declare const AppRegistry: import("@symbiote-native/engine").IAppRegistry<IComponentProvider, IWrapperComponentProvider>, setHostRegistrar: (registrar: import("@symbiote-native/engine").IHostRegistrar) => void;
-export { AppRegistry, setHostRegistrar };
-export type { IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from '@symbiote-native/engine';
+export { AppRegistry, HeadlessJsTaskError, setHostRegistrar };
+export type { IAppConfig, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from '@symbiote-native/engine';

package/build/modules/app-registry/index.js

@@ -8,7 +8,7 @@
 // design pass: a Solid component is an ordinary function value, so wrapping composes exactly the
 // way Vue's `h(wrapper, null, { default: renderRoot })` does — `createComponent(Wrapper, { get
 // children() {…} })`, which is also the literal shape compiled JSX emits for children.
-import { createAppRegistry, dlog, } from '@symbiote-native/engine';
+import { createAppRegistry, dlog, HeadlessJsTaskError, } from '@symbiote-native/engine';
 import { createComponent } from '../../renderer.js';
 import { mount } from '../../render.js';
 function runnableFor(componentProvider, getWrapperComponentProvider) {
@@ -34,4 +34,4 @@ function runnableFor(componentProvider, getWrapperComponentProvider) {
     };
 }
 const { AppRegistry, setHostRegistrar } = createAppRegistry(runnableFor);
-export { AppRegistry, setHostRegistrar };
+export { AppRegistry, HeadlessJsTaskError, setHostRegistrar };

package/build/modules/status-bar.js

@@ -1,45 +1,32 @@
-// StatusBar — the Solid lifecycle half, and nothing else. The native StatusBarManager driving
-// (applyStatusBarProps), the imperative statics (statusBarImperative) and the Android bar-height
-// constant all live in @symbiote-native/engine, shared verbatim with React / Vue / Svelte /
-// Angular; Metro selects the engine's index.ios.ts / index.android.ts per host, so the platform
-// divergence never reaches this file. Solid supplies only the declarative shape: a component that
-// renders no Fabric view and re-applies its props from a `createEffect` on mount and on every
-// prop change.
-//
-// FLAT, not a folder: the file-layout rule gives a module its own folder only for real
-// `.ios`/`.android`/`-shared` variants. React needs two files because its useEffect dep array is
-// written by hand per platform; there is no dep array here, so one file covers both hosts —
-// the same shape Svelte's and Angular's StatusBar landed on.
-//
-// Simplification vs RN, inherited from every other adapter: RN keeps a prop-merge stack so nested
-// StatusBars compose (deepest wins); this direct-applies one component's props.
-import { createEffect } from 'solid-js';
-import { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight, } from '@symbiote-native/engine';
-// Renders null: StatusBar owns no host node, it drives a native module.
+// Solid half of StatusBar, the props stack and statics live in the engine. It renders no Fabric
+// view, applies its props to one stack entry from a `createEffect` and releases it on cleanup
+// FLAT, one file covers both hosts since there is no per-platform dependency array
+import { createEffect, onCleanup } from 'solid-js';
+import { createStatusBarEntry, statusBarImperative, statusBarCurrentHeight, } from '@symbiote-native/engine';
+// Renders null: StatusBar owns no host node, it drives a native module
 function StatusBarComponent(props) {
+    const entry = createStatusBarEntry();
     createEffect(() => {
-        // Every field is read HERE, not inside the engine, so the effect's dependency set is the whole
-        // prop surface rather than whichever subset this platform's impl happens to destructure —
-        // iOS's applyStatusBarProps never touches backgroundColor/translucent, and a props proxy read
-        // only there would silently stop re-applying after a host swap.
-        applyStatusBarProps({
+        // Every field is read here, so the effect depends on the whole prop surface
+        entry.apply({
             barStyle: props.barStyle,
             hidden: props.hidden,
             animated: props.animated,
+            showHideTransition: props.showHideTransition,
             networkActivityIndicatorVisible: props.networkActivityIndicatorVisible,
             backgroundColor: props.backgroundColor,
             translucent: props.translucent,
         });
     });
+    // Popping restores what the stack held below this entry
+    onCleanup(() => entry.release());
     return null;
 }
 const StatusBarWithStatics = Object.assign(StatusBarComponent, statusBarImperative);
-// Android exposes the bar height as a native constant; undefined on iOS / when absent. A getter,
-// not a value, so nothing touches native at import time.
+// A getter, not a value, so nothing touches native at import time
 Object.defineProperty(StatusBarWithStatics, 'currentHeight', {
     get: statusBarCurrentHeight,
     enumerable: true,
 });
-// currentHeight is optional, so the defineProperty-added accessor need not appear on the runtime
-// object's inferred type for this assignment to hold (no cast) — same shape as Svelte's.
+// `currentHeight` is optional, so the accessor need not appear on the inferred type (no cast)
 export const StatusBar = StatusBarWithStatics;

package/build/primitives/create-color-scheme.d.ts

@@ -1,3 +1,3 @@
 import { type Accessor } from 'solid-js';
 import { type IColorSchemeName } from '@symbiote-native/engine';
-export declare function createColorScheme(): Accessor<IColorSchemeName | null>;
+export declare function createColorScheme(): Accessor<IColorSchemeName | null | undefined>;

package/build/primitives/define-native-view-component.d.ts

@@ -0,0 +1,5 @@
+import type { ICreateNativeViewController } from '@symbiote-native/components';
+import type { ISymbioteNode } from '@symbiote-native/engine';
+export declare function defineNativeViewComponent<THandle, TProps extends object>(createController: ICreateNativeViewController<THandle>): (props: TProps & {
+    ref?: (handle: THandle) => void;
+}) => ISymbioteNode | null;

package/build/primitives/define-native-view-component.js

@@ -0,0 +1,22 @@
+import { onCleanup, splitProps } from 'solid-js';
+import { createHostNodeHolder } from '@symbiote-native/components';
+import { descriptorToSolid } from '../descriptor-to-solid.js';
+// A Solid component over a package's native view: the props go to the controller, its handle goes
+// to `ref`. The shape of the descriptor is decided once at mount, only values change afterwards
+export function defineNativeViewComponent(createController) {
+    return (props) => {
+        const [own, viewProps] = splitProps(props, ['ref']);
+        const host = createHostNodeHolder();
+        const controller = createController(host.getNode);
+        onCleanup(() => controller.dispose?.());
+        const render = () => {
+            const descriptor = controller.render({ ...viewProps });
+            return descriptor && host.capture(descriptor);
+        };
+        const initial = render();
+        if (!initial)
+            return null;
+        own.ref?.(controller.handle);
+        return descriptorToSolid(() => render() ?? initial);
+    };
+}

package/build/primitives/use-event.d.ts

@@ -0,0 +1,6 @@
+import type { Accessor } from 'solid-js';
+import type { IEventEmitterOf, IEventName, IEventPayload, IEventsMap } from '@symbiote-native/engine';
+/** Calls the listener for each event, the latest one, and stops when the owner is disposed */
+export declare function useEventListener<TEventsMap extends IEventsMap, TName extends IEventName<TEventsMap>>(emitter: Accessor<IEventEmitterOf<TEventsMap>>, eventName: Accessor<TName>, listener: Accessor<TEventsMap[TName]>): void;
+/** The payload of the last event, `initialValue` (or `null`) until the first one */
+export declare function useEvent<TEventsMap extends IEventsMap, TName extends IEventName<TEventsMap>>(emitter: Accessor<IEventEmitterOf<TEventsMap>>, eventName: Accessor<TName>, initialValue?: IEventPayload<TEventsMap, TName> | null): Accessor<IEventPayload<TEventsMap, TName> | null>;

package/build/primitives/use-event.js

@@ -0,0 +1,18 @@
+// Solid twins of `useEvent` and `useEventListener` of the `expo` package, for any emitter
+import { createEffect, createSignal, on, onCleanup } from 'solid-js';
+import { bindEventListener } from '@symbiote-native/engine';
+/** Calls the listener for each event, the latest one, and stops when the owner is disposed */
+export function useEventListener(emitter, eventName, listener) {
+    createEffect(on([emitter, eventName], ([source, name]) => {
+        // The listener is read at each event, a new one is not a new subscription
+        onCleanup(bindEventListener(source, name, listener));
+    }));
+}
+/** The payload of the last event, `initialValue` (or `null`) until the first one */
+export function useEvent(emitter, eventName, initialValue = null) {
+    const [event, setEvent] = createSignal(initialValue);
+    createEffect(on([emitter, eventName], ([source, name]) => {
+        onCleanup(bindEventListener(source, name, () => (next) => setEvent(() => next)));
+    }));
+    return event;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/solid",
-  "version": "3.1.0",
+  "version": "3.3.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": "3.1.4",
-    "@symbiote-native/css-parser": "0.5.3"
+    "@symbiote-native/components": "3.3.0",
+    "@symbiote-native/css-parser": "0.6.0"
   },
   "peerDependencies": {
     "solid-js": ">=1.9.0",
     "react-native": ">=0.86",
-    "@symbiote-native/engine": "^1.5.0"
+    "@symbiote-native/engine": "^1.7.0"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
     "solid-js": "^1.9.14",
-    "@symbiote-native/engine": "1.5.0",
-    "@symbiote-native/test-utils": "0.4.6"
+    "@symbiote-native/engine": "1.7.0",
+    "@symbiote-native/test-utils": "0.5.0"
   },
   "scripts": {
     "typecheck": "tsc --build",