@symbiote-native/solid 0.0.1 → 1.0.0

package/build/index.d.ts

@@ -0,0 +1,31 @@
+import './register';
+export { mount, unmount } from './render';
+export { findNodeHandle } from './host-instance';
+export type { IHostInstance } from './host-instance';
+export * from './components';
+export type { IAccessibilityProps, IAriaProps, IAccessibilityRole, IRole, IAccessibilityStateValue, IAccessibilityValue, IAccessibilityActionInfo, IResponderProps, IImageSource, IImageSourceProp, IResizeMode, IImageSize, IImageCacheStatus, IEnterKeyHint, IInputMode, ISubmitBehavior, } from '@symbiote-native/components';
+export { setImageSourceResolver } from '@symbiote-native/components';
+export { descriptorToSolid } from './descriptor-to-solid';
+export { AppRegistry, setHostRegistrar } from './modules/app-registry';
+export type { IComponentProvider, IWrapperComponentProvider, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from './modules/app-registry';
+export { StatusBar } from './modules/status-bar';
+export type { IStatusBarProps, IStatusBarStyle } from './modules/status-bar';
+export { Portal } from './create-portal';
+export type { IPortalProps, IPortalTarget } from './create-portal';
+export { createTunnel } from './create-tunnel';
+export type { ITunnel, ITunnelInProps } from './create-tunnel';
+export { createColorScheme } from './primitives/create-color-scheme';
+export { createWindowDimensions } from './primitives/create-window-dimensions';
+export { Animated, createAnimatedComponent } from './modules/animated';
+export type { IAnimatedComponentProps } from './modules/animated';
+export { Platform, StyleSheet, PixelRatio, PlatformColor, DynamicColorIOS, processColor, } from '@symbiote-native/engine';
+export { setNativeViewConfigSource, setColorProcessor, setDeviceEventSource, } from '@symbiote-native/engine';
+export { dlog, isDebug } from '@symbiote-native/engine';
+export type { IViewStyle, ITextStyle, IFlexAlign, IFlexJustify, ISymbioteEvent, ISymbioteNode, IRootTag, INativeViewConfig, INativeViewConfigSource, IColorValue, IOpaqueColorValue, IDynamicColorIOSTuple, IPixelRatioStatic, IPlatformStatic, IPlatformOSType, IPlatformConstantsIOS, IPlatformConstantsAndroid, IPlatformSelectSpec, } from '@symbiote-native/engine';
+export { Alert, Share, ActionSheetIOS, Linking, Vibration, ToastAndroid, Settings, I18nManager, Dimensions, Appearance, AppState, Keyboard, KEYBOARD_EVENT, BackHandler, PermissionsAndroid, PERMISSIONS, RESULTS, LayoutAnimation, InteractionManager, } from '@symbiote-native/engine';
+export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlertOptions, IShareContent, IShareOptions, IShareAction, IActionSheetIOSOptions, IShareActionSheetIOSOptions, IShareActionSheetError, IUrlEvent, II18nManagerConstants, IDisplayMetrics, IDisplayMetricsAndroid, IDimensionsPayload, IDimensionsSet, IDimensionsKey, IDimensionsChangeListener, IDimensionsStatic, IColorSchemeName, IColorSchemePreference, IAppStateStatus, IAppStateEvent, IKeyboardEventName, IKeyboardEvent, IKeyboardMetrics, IBackPressEventName, IBackPressHandler, IPermission, IPermissionStatus, IRationale, ILayoutAnimationType, ILayoutAnimationProperty, ILayoutAnimationConfig, ILayoutAnimationAnim, IInteractionEvent, ISimpleTask, IPromiseTask, ITask, IHandle, } from '@symbiote-native/engine';
+export { PanResponder } from '@symbiote-native/engine';
+export type { IPanResponderGestureState, IPanResponderCallbacks, IGestureResponderHandlers, IPanResponderInstance, } from '@symbiote-native/engine';
+export { AccessibilityInfo } from '@symbiote-native/engine';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from '@symbiote-native/engine';
+export { For, Index, Show, ErrorBoundary, Suspense, SuspenseList, } from 'solid-js';

package/build/index.js

@@ -0,0 +1,98 @@
+// @symbiote-native/solid: a Solid adapter over @symbiote-native/engine, built on Solid's own
+// universal custom-renderer API (solid-js/universal). Compiled Solid JSX drives real native
+// iOS/Android views; underneath, every call routes into the same mutation API every other adapter
+// 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.
+//
+// The two lifecycle primitives are spelled `createColorScheme` / `createWindowDimensions`, not
+// `use*`: in Solid `use*` means consuming something that already exists (useContext,
+// useTransition) while a function that creates its own state and owns a subscription is `createX`.
+// Angular spells the same pair as services for the same idiom reason — this is a naming
+// divergence <adapter_src_follows_framework_idioms> asks for, not a parity gap.
+// No JSX augmentation is imported here. The host tags live in this package's own JSX namespace at
+// ./jsx-runtime, which an app reaches by config rather than by import:
+// `"jsxImportSource": "@symbiote-native/solid"` (see that file). The earlier
+// `declare module 'solid-js'` shim is gone with it — one mechanism, not two.
+// Bare, side-effect only, and deliberately NOT `export * from './register'` — see that file.
+import './register.js';
+export { mount, unmount } from './render.js';
+export { findNodeHandle } from './host-instance.js';
+export * from './components.js';
+// The app-entry seam that hands Image RN's own source resolver; grouped with the Image types it
+// serves rather than with the engine seams below, matching React's and Svelte's barrels.
+export { setImageSourceResolver } from '@symbiote-native/components';
+// descriptorToSolid: the @symbiote-native/components Descriptor → engine-node bridge. Exported for
+// 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';
+// Safe in the barrel (unlike ./bootstrap, which imports react-native): the registry seam itself
+// only reaches the engine and solid-js.
+export { AppRegistry, setHostRegistrar } from './modules/app-registry/index.js';
+// Animated: the six animated components RN exposes, over the engine's framework-agnostic value
+// graph. Solid's JSX takes the dotted form directly — `<Animated.View/>` compiles to
+// createComponent(Animated.View, …) — so no local alias is needed, unlike Angular, whose AOT
+// compiler cannot trace a class through property access (.claude/rules/dotted-component-tags.md).
+export { StatusBar } from './modules/status-bar.js';
+// Portal: same-surface content relocation, the twin of React's createPortal and Angular's
+// PortalDirective/PortalOutletDirective. `mount` takes an already-mounted host node in THIS
+// surface (a ref off a rendered component) or the surface itself; reaching a second, separately
+// mounted surface is a different mechanism by design — see ./create-portal's header.
+export { Portal } from './create-portal/index.jsx';
+// createTunnel: cross-surface content sharing, the case Portal deliberately does not cover. A
+// shared store, never a reach into a foreign surface's tree — `Out` paints from whichever surface
+// renders it. Same name and same In/Out shape as the React, Vue, Svelte and Angular versions.
+export { createTunnel } from './create-tunnel/index.jsx';
+// Reactive wrappers over the engine's own Appearance / Dimensions event sources. The engine keeps
+// 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 { 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).
+// The app names @symbiote-native/solid and gets RN's single import root.
+// 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';
+// 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';
+// 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
+// (core/engine/src/accessibility-info/). React routes it through an adapter folder of the same
+// 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.
+export { For, Index, Show, ErrorBoundary, Suspense, SuspenseList, } from 'solid-js';

package/build/jsx-runtime.d.ts

@@ -0,0 +1,26 @@
+import type { ISymbioteIntrinsic } from '@symbiote-native/components';
+import type { ISymbioteNode } from '@symbiote-native/engine';
+type ISymbioteHostAttributes = {
+    readonly children?: JSX.Element;
+    readonly [attribute: string]: unknown;
+};
+export declare namespace JSX {
+    type Element = ISymbioteNode | IArrayElement | IFunctionElement | (string & {}) | number | boolean | null | undefined;
+    interface IArrayElement extends Array<Element> {
+    }
+    interface IFunctionElement {
+        (): Element;
+    }
+    interface ElementClass {
+    }
+    interface ElementAttributesProperty {
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+    interface IntrinsicAttributes {
+    }
+    interface IntrinsicElements extends Record<ISymbioteIntrinsic, ISymbioteHostAttributes> {
+    }
+}
+export {};

package/build/jsx-runtime.js

@@ -0,0 +1,46 @@
+// The package's own JSX namespace — what an app points `jsxImportSource` at:
+//
+//   // tsconfig.json
+//   "jsx": "preserve",
+//   "jsxImportSource": "@symbiote-native/solid"
+//
+// TypeScript resolves the namespace from `<jsxImportSource>/jsx-runtime` and NOTHING ELSE. That
+// holds under `jsx: "preserve"` too, which is easy to doubt — the flag is documented as naming the
+// module the `jsx`/`jsxs` factories are imported from, and `preserve` imports nothing. Measured:
+// pointing jsxImportSource at a package that does not exist fails with
+// `TS2875: This JSX tag requires the module path '<source>/jsx-runtime' to exist`, on a config
+// whose `jsx` is `preserve`. So the entry is type-only by nature — the emitted build/jsx-runtime.js
+// is empty and never imported by anything, because babel-preset-solid rewrites JSX into calls on
+// ./renderer instead (that is the `moduleName` option, a separate mechanism from this one).
+//
+// WHY OUR OWN NAMESPACE AND NOT AN AUGMENTATION OF SOLID'S. `@lightningtv/solid` (3.2.5), the
+// most widely used universal renderer on a non-DOM host, ships exactly
+// `declare module 'solid-js' { namespace JSX { interface IntrinsicElements { … } } }` plus
+// `export type { JSX } from 'solid-js'`. That re-export is genuinely all it takes to make the
+// entry resolvable, and it is what this package's own src/jsx.ts did before this file replaced it.
+// It buys one thing: an app stops needing a `/// <reference types="@symbiote-native/solid" />` line
+// to pull the augmentation into its program. It does NOT buy the other two, and both matter more:
+//
+//   1. Augmenting MERGES into solid-js's own IntrinsicElements, which lists every HTML and SVG
+//      tag. `<div>` stays valid JSX in a React Native app and fails at runtime, not at compile
+//      time. Declaring the interface fresh here is what makes an unknown tag an error.
+//   2. solid-js's `JSX.Element` is `Node | ArrayElement | (string & {}) | number | boolean | null
+//      | undefined`, and `Node` is a DOM type. A React Native program has no DOM lib (this repo:
+//      `lib: ["ES2022"]`; the canary: RN's own config, equally DOM-less), so the name does not
+//      resolve — and `skipLibCheck: true` SUPPRESSES that error inside solid-js's .d.ts rather
+//      than surfacing it, leaving `Node` as `any`. One `any` in a union collapses the whole union,
+//      so `JSX.Element` is `any` and every JSX child position in every consuming app goes
+//      unchecked. Measured two ways: `const bogus: JSX.Element = { definitelyNotAnElement: true }`
+//      compiles, and `const node: Node = …` in a first-party file (not skipLibCheck'd) reports
+//      `TS2304: Cannot find name 'Node'`.
+//
+// The risk this trades against — recorded when the swap was deferred — is that our `Element` has
+// to line up with what solid-js's own `<Show>` / `<For>` return. It does, for a reason that only
+// holds because of point 2 above: those return solid's `JSX.Element`, which IS `any` in exactly the
+// DOM-less programs we target, so it is assignable to anything of ours. jsx-runtime.test.tsx pins
+// the runtime half (both compose through this renderer and re-render on a signal); the type half is
+// carried by examples/solid's own `tsc --noEmit`. The one configuration that would break the
+// alignment is an app that pulls in the DOM lib, giving solid's `Element` a real `Node` — recorded
+// in `.claude/rules/solid-jsx-namespace.md`.
+export {};
+/* eslint-enable @typescript-eslint/no-namespace, @typescript-eslint/no-empty-object-type */

package/build/modules/animated/create-animated-component.d.ts

@@ -0,0 +1,10 @@
+import { type Component, type Ref } from 'solid-js';
+import type { JSX } from '../../jsx-runtime';
+export interface IAnimatedComponentProps {
+    style?: unknown;
+    ref?: Ref<unknown>;
+    passthroughAnimatedPropExplicitValues?: unknown;
+    children?: JSX.Element;
+    [key: string]: unknown;
+}
+export declare function createAnimatedComponent(Base: Component<any> | string): (props: IAnimatedComponentProps) => JSX.Element;

package/build/modules/animated/create-animated-component.jsx

@@ -0,0 +1,127 @@
+// createAnimatedComponent for @symbiote-native/solid: wraps a base component so its props may
+// carry AnimatedNodes. The Solid twin of adapters/{react,vue}/src/modules/animated/
+// create-animated-component; grown from components/scroll-view/animated-host.tsx, which was the
+// same body pinned to `symbiote-view` and is absorbed by this file.
+//
+// A GENERIC WRAP IS POSSIBLE HERE, unlike Svelte. A Solid component is a plain function and
+// `createComponent(Comp, props)` is an ordinary runtime call over any component reference — the
+// same call compiled JSX itself emits. Svelte's four hand-authored .svelte files exist because a
+// compiled Svelte component is not invocable that way; Angular's six explicit @Components exist
+// because AOT-under-Metro ships no JIT. Neither constraint applies.
+//
+// The per-FRAME path never comes through here: value.setValue / animation -> flushValue ->
+// AnimatedProps.update() -> setNativeProps(node). Under the native driver not even that runs — the
+// UI thread owns the props once the leaf is connected to the view tag. This wrap only supplies the
+// DECLARATIVE bag (animated nodes replaced by their current values) so first paint and every
+// non-animated recompute carry concrete numbers.
+//
+// THE COMMIT-TIMING TRAP IS LIVE HERE. This adapter commits through `requestCommit()`, which is
+// microtask-coalesced, so a mount-time effect runs BEFORE the node has a Fabric tag and the native
+// half of the reconcile would silently no-op. `whenCommitted` is the retry seam (Angular passes the
+// same thing for the same reason). Only the NATIVE half is deferred — the leaf is always built and
+// attached to the value graph synchronously, because a deferred build sits behind a canceller the
+// next reconcile drops.
+import { createEffect, mergeProps, onCleanup, splitProps, } from 'solid-js';
+import { createAnimatedLeafLifecycle, isNativeAnimatedAvailable, isSymbioteNode, readPassthroughStyle, reduceProps, resolveHostNode, whenCommitted, } from '@symbiote-native/engine';
+import { createElement, spread } from '../../renderer.js';
+import { withStableKeys } from '../../utils/stable-keys.js';
+// RN's prop carrying already-rasterized values that OVERRIDE the animated prop in the committed
+// props, so the ShadowTree (hit-testing) stays current while the native driver animates.
+const PASSTHROUGH_PROP = 'passthroughAnimatedPropExplicitValues';
+// `Component<any>` is solid-js's own shape for "any component" (it is what ValidComponent is built
+// from). A precise generic cannot work: the bag handed to the base is assembled at RUNTIME from a
+// key set that grows, so no static prop type describes it. The RETURN type stays precise, so a
+// caller of Animated.View still gets a real prop type.
+// `Base` accepts a TAG as well as a component, and the string branch is not symmetry — it is the
+// only shape that works once a primitive becomes a public intrinsic. `<Base {...props} />` on a
+// capitalized identifier compiles to `createComponent(Base, …)`, which is `untrack(() => Comp(props))`
+// in solid-js, so a string base is a `TypeError: Comp is not a function` at first paint. There is
+// nothing to widen INTO either: `createRenderer()` from solid-js/universal returns twelve names and
+// `Dynamic` is not among them (solid-js/web's Dynamic is DOM-only), so the element has to be built
+// through this renderer's own createElement + spread — the same two calls solid's own Dynamic makes
+// on its string branch. `spread` handles `ref` and `children` itself (universal's spreadExpression
+// skips both in its prop loop and drives them separately), which is why nothing is threaded by hand.
+export function createAnimatedComponent(Base) {
+    return function AnimatedComponent(props) {
+        // The passthrough is CONSUMED (it only overrides the committed style below); `children` and
+        // `ref` are pulled out so the bag accessor depends on neither the child subtree nor the ref.
+        const [local, rest] = splitProps(props, [
+            'ref',
+            'children',
+            PASSTHROUGH_PROP,
+        ]);
+        // Held by IDENTITY in a plain variable — never a signal, never a store. The engine's commit
+        // mirror is a WeakMap keyed on the raw node, so any proxy wrapper becomes a different key and
+        // every native bind silently misses (symbiote-engine-core §3).
+        let node = null;
+        const lifecycle = createAnimatedLeafLifecycle('solid');
+        // NOT the native-driver switch. A useNativeDriver animation promotes the graph itself
+        // (animations/base.ts -> value.__startNativeAnimation -> graph.__makeNative) and the leaf
+        // follows through __addChild, with or without this. This is only RN's EAGER promotion for the
+        // sticky-header passthrough, and it still needs a real native module to mean anything.
+        const wantsNative = () => {
+            const passthrough = local[PASSTHROUGH_PROP];
+            return (passthrough !== undefined &&
+                passthrough !== null &&
+                isNativeAnimatedAvailable());
+        };
+        // withStableKeys: reduceProps' key set follows `rest`, which a caller can shrink between runs,
+        // and Solid's `spread` has no removal pass — a vanished key would keep its last value on the
+        // native view forever (.claude/rules/solid-descriptor-bridge.md §1). The host primitives widen
+        // their own bags too, but relying on that would make this wrap correct only by accident.
+        const bag = withStableKeys(() => {
+            const reduced = reduceProps({ ...rest });
+            const passthroughStyle = readPassthroughStyle(local[PASSTHROUGH_PROP]);
+            if (passthroughStyle !== undefined) {
+                reduced.style =
+                    reduced.style === undefined
+                        ? passthroughStyle
+                        : [reduced.style, passthroughStyle];
+            }
+            return reduced;
+        });
+        // Capture the base's public instance, resolve it to the underlying host node for the leaf
+        // (unwrapping a scroll handle), and forward the ORIGINAL instance to the caller, who expects
+        // the component's own handle. Ref shape rationale: utils/host-ref.ts.
+        const captureRef = (instance) => {
+            node = resolveHostNode(instance);
+            if (typeof local.ref === 'function')
+                local.ref(instance);
+        };
+        // createEffect, not createRenderEffect: the node has to exist first. The ref above fills it
+        // while the element is built, which is strictly before any effect runs.
+        createEffect(() => {
+            const current = { ...rest };
+            const wants = wantsNative();
+            const target = isSymbioteNode(node) ? node : null;
+            lifecycle.reconcile(current, target, wants, target === null ? undefined : bind => whenCommitted(target, bind));
+        });
+        onCleanup(() => {
+            lifecycle.teardown();
+        });
+        // ONE merge, never a spread followed by an explicit prop: mergeProps takes the first
+        // NON-undefined value scanning back-to-front, so a later explicit `undefined` would lose
+        // (.claude/rules/solid-descriptor-bridge.md §6). Safe here because the second source carries
+        // only `ref` and `children`, neither of which is the vanishing kind. The getter keeps children
+        // lazy so reading the bag never walks the child subtree.
+        const childProps = mergeProps(bag, {
+            ref: captureRef,
+            get children() {
+                return local.children;
+            },
+        });
+        // Narrowed HERE and not around the whole factory: `Base` is a parameter captured by this inner
+        // function, so a check outside it does not reach the JSX below.
+        if (typeof Base === 'string') {
+            const element = createElement(Base);
+            spread(element, childProps, false);
+            // createElement's return type is the renderer's node union, which includes the SURFACE — a
+            // root the renderer is handed, never something a tag produces. Narrowed rather than cast, and
+            // thrown rather than defaulted: returning null here would paint nothing and stay green.
+            if (!isSymbioteNode(element))
+                throw new Error(`createAnimatedComponent: <${Base}> did not build a host node`);
+            return element;
+        }
+        return <Base {...childProps}/>;
+    };
+}

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

@@ -0,0 +1,54 @@
+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;
+    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;
+    };
+    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;
+    View: (props: import("./create-animated-component").IAnimatedComponentProps) => import("@symbiote-native/solid/jsx-runtime").JSX.Element;
+    Text: (props: import("./create-animated-component").IAnimatedComponentProps) => import("@symbiote-native/solid/jsx-runtime").JSX.Element;
+    Image: (props: import("./create-animated-component").IAnimatedComponentProps) => import("@symbiote-native/solid/jsx-runtime").JSX.Element;
+    ScrollView: IAnimatedComponent;
+    FlatList: IAnimatedComponent;
+    SectionList: IAnimatedComponent;
+    createAnimatedComponent: typeof createAnimatedComponent;
+};

package/build/modules/animated/index.js

@@ -0,0 +1,78 @@
+// The Animated namespace for @symbiote-native/solid. createAnimatedComponent applied to this
+// adapter's primitives gives the six animated components RN exposes; the value graph, easing and
+// imperative drivers come from @symbiote-native/engine (framework-agnostic), so both halves meet
+// here in one object and `Animated.timing(new Animated.Value(0), …).start()` reads as it does in
+// RN. Solid's JSX takes the dotted form directly — `<Animated.View/>` compiles to
+// createComponent(Animated.View, …), no local alias needed.
+//
+// The NATIVE DRIVER is not this module's doing and must not be re-derived here. A
+// useNativeDriver animation promotes the value graph itself (animations/base.ts ->
+// value.__startNativeAnimation -> graph.__makeNative), and the props leaf follows automatically
+// through graph.__addChild. This file only assembles the surface.
+import { AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedMock, Easing, Platform, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, } from '@symbiote-native/engine';
+import { View } from '../../components/view.jsx';
+import { Text } from '../../components/text.jsx';
+import { Image } from '../../components/image.js';
+import { ScrollView } from '../../components/scroll-view';
+import { FlatList } from '../../components/flat-list/index.jsx';
+import { SectionList } from '../../components/section-list/index.jsx';
+import { createAnimatedComponent } from './create-animated-component.jsx';
+export { createAnimatedComponent } from './create-animated-component.jsx';
+// The pure graph leaves live in the engine (they extend AnimatedWithChildren, no framework);
+// re-exported so this adapter's Animated surface matches React's.
+export { AnimatedProps, AnimatedStyle, AnimatedTransform, } from '@symbiote-native/engine';
+// View/Text/Image are pure host primitives with no cycle back to here, so wrap them eagerly.
+const AnimatedView = createAnimatedComponent(View);
+const AnimatedText = createAnimatedComponent(Text);
+const AnimatedImage = createAnimatedComponent(Image);
+let animatedScrollView;
+let animatedFlatList;
+let animatedSectionList;
+// The live, JS-driven driver half. RN's AnimatedImplementation.
+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;
+export const Animated = {
+    View: AnimatedView,
+    Text: AnimatedText,
+    Image: AnimatedImage,
+    get ScrollView() {
+        animatedScrollView ??= createAnimatedComponent(ScrollView);
+        return animatedScrollView;
+    },
+    get FlatList() {
+        animatedFlatList ??= createAnimatedComponent(FlatList);
+        return animatedFlatList;
+    },
+    get SectionList() {
+        animatedSectionList ??= createAnimatedComponent(SectionList);
+        return animatedSectionList;
+    },
+    createAnimatedComponent,
+    ...drivers,
+};

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

@@ -0,0 +1,7 @@
+import type { Component } from 'solid-js';
+import { 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';

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

@@ -0,0 +1,37 @@
+// AppRegistry: the JS entry point RN apps already use:
+//   AppRegistry.registerComponent(appKey, () => App)
+// The registry bookkeeping (sections, host-registrar bridge, headless tasks) is
+// framework-agnostic and lives in @symbiote-native/engine's createAppRegistry, the same one every
+// other adapter uses; this file supplies only the one Solid-specific seam.
+//
+// Unlike the Svelte adapter, `IWrapperComponentProvider` is fully supported here and needs no
+// 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 { createComponent } from '../../renderer.js';
+import { mount } from '../../render.js';
+function runnableFor(componentProvider, getWrapperComponentProvider) {
+    return appParameters => {
+        dlog(`AppRegistry: mounting on rootTag ${String(appParameters.rootTag)}`);
+        const RootComponent = componentProvider();
+        const renderRoot = () => createComponent(RootComponent, appParameters.initialProps ?? {});
+        // Read live, so setWrapperComponentProvider affects every runnable's next run rather than only
+        // ones registered afterwards — same contract as Vue's.
+        const wrapperComponentProvider = getWrapperComponentProvider();
+        const mounted = wrapperComponentProvider === undefined
+            ? renderRoot
+            : () => createComponent(wrapperComponentProvider(appParameters), {
+                // A getter, not a value: children must stay lazy so the root is created inside the
+                // wrapper's own reactive owner (its context providers, error boundaries and cleanups
+                // then actually cover the root). Evaluating it eagerly here would build the root
+                // outside that owner and quietly break every one of those.
+                get children() {
+                    return renderRoot();
+                },
+            });
+        mount(appParameters.rootTag, mounted);
+    };
+}
+const { AppRegistry, setHostRegistrar } = createAppRegistry(runnableFor);
+export { AppRegistry, setHostRegistrar };

package/build/modules/status-bar.d.ts

@@ -0,0 +1,7 @@
+import { type IStatusBarProps } from '@symbiote-native/engine';
+export type { IStatusBarProps, IStatusBarStyle, IStatusBarAnimation, } from '@symbiote-native/engine';
+declare function StatusBarComponent(props: IStatusBarProps): null;
+declare const StatusBarWithStatics: typeof StatusBarComponent & import("@symbiote-native/engine").IStatusBarImperative;
+export declare const StatusBar: typeof StatusBarWithStatics & {
+    readonly currentHeight?: number;
+};

package/build/modules/status-bar.js

@@ -0,0 +1,45 @@
+// 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.
+function StatusBarComponent(props) {
+    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({
+            barStyle: props.barStyle,
+            hidden: props.hidden,
+            animated: props.animated,
+            networkActivityIndicatorVisible: props.networkActivityIndicatorVisible,
+            backgroundColor: props.backgroundColor,
+            translucent: props.translucent,
+        });
+    });
+    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.
+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.
+export const StatusBar = StatusBarWithStatics;

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

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

package/build/primitives/create-color-scheme.js

@@ -0,0 +1,33 @@
+// createColorScheme — the Solid twin of React's `useColorScheme` hook, Vue's composable, Svelte's
+// rune and Angular's ColorSchemeService, over the framework-agnostic Appearance module
+// (@symbiote-native/engine). The engine owns the native subscription; this file owns only the
+// reactive lifecycle.
+//
+// `primitives/` and `create*`, not `hooks/` and `use*`: Solid's ecosystem calls a composable
+// reactive function a PRIMITIVE (solid-primitives), and reserves `use*` for consuming something
+// that already exists — `useContext`, `useTransition`, and solid-primitives' shared/singleton
+// variants. A primitive that creates its own state and owns a subscription is `createX`.
+// (CLAUDE.md <adapter_src_follows_framework_idioms>: the lifecycle bucket takes the framework's
+// own term, so a Solid `hooks/` folder would be as wrong as a Vue one.)
+//
+// Returns an ACCESSOR, never a snapshot: a Solid component body runs once, so a returned value
+// would freeze at the scheme the app booted with.
+//
+// Outside a component or `createRoot`, `onCleanup` has no owner to attach to — Solid warns
+// ("cleanups created outside a `createRoot` or `render` will never be run") and the Appearance
+// listener lives for the process. The accessor still tracks correctly; only the teardown is lost.
+import { createSignal, onCleanup } from 'solid-js';
+import { Appearance, } from '@symbiote-native/engine';
+export function createColorScheme() {
+    const [colorScheme, setColorScheme] = createSignal(Appearance.getColorScheme());
+    // No post-subscribe re-read, unlike React/Vue/Svelte: those subscribe from an effect, a tick
+    // after the seed read, so a change can slip between the two. Here both statements run in one
+    // synchronous tick and nothing can interleave.
+    const subscription = Appearance.addChangeListener(preferences => {
+        setColorScheme(preferences.colorScheme);
+    });
+    onCleanup(() => {
+        subscription.remove();
+    });
+    return colorScheme;
+}

package/build/primitives/create-window-dimensions.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from 'solid-js';
+import { type IDisplayMetrics } from '@symbiote-native/engine';
+export declare function createWindowDimensions(): Accessor<IDisplayMetrics>;