@symbiote-native/splash-screen 3.0.3 → 3.2.0

package/build-ngc/core/index.d.ts

@@ -2,4 +2,4 @@ export { hide, isVisible } from './hide';
 export { HideAnimationController } from './hide-animation-controller';
 export { computeHideAnimationStyles } from './compute-hide-animation-styles';
 export { getHideAnimationConstants } from './native-module';
-export type { IHideConfig, IManifest, IHideAnimationConfig, IHideAnimationContainerProps, IHideAnimationImageProps, IHideAnimationResult, IHideAnimationConstants, } from './types';
+export type { IHideConfig, IManifest, IHideAnimationConfig, IHideAnimationContainerProps, IHideAnimationFailure, IHideAnimationFailureStage, IHideAnimationImageProps, IHideAnimationResult, IHideAnimationConstants, } from './types';

package/build-ngc/core/native-module.js

@@ -7,6 +7,24 @@
 // (hide/isVisible/useHideAnimation) never exposes directly.
 import { getEnforcingNativeModule } from '@symbiote-native/engine';
 const RN_BOOT_SPLASH_MODULE_NAME = 'RNBootSplash';
+// DELIBERATELY UNGUARDED — do not wrap this in a try/catch or hand it a fallback.
+//
+// A missing RNBootSplash is a BUILD error, not a runtime condition: the module is either linked
+// into the binary or it is not, deterministically, on the very first launch. Upstream treats it
+// the same way and does not soften it either — react-native-bootsplash's whole spec file is
+// `TurboModuleRegistry.getEnforcing<Spec>("RNBootSplash")` (src/specs/NativeRNBootSplash.ts),
+// which throws at module-IMPORT time, and its useHideAnimation calls `NativeModule.getConstants()`
+// with no guard at all. `getEnforcing` exists precisely to make this loud.
+//
+// This repo has a live footgun that depends on it staying loud: `npm install` deletes the
+// `.rn-bootsplash/` folder this package's podspec vendors at pod-install time (see CLAUDE.md), so
+// a skipped `pod install` yields exactly this missing module. Degrading to light-mode defaults
+// would turn that into "the splash looks fine, just never dark" and it would ship.
+//
+// Note the failure is currently invisible under @symbiote-native/react specifically: mount()
+// (adapters/react/src/render.ts) wires the reconciler's uncaught-error callbacks to `noop`, so the
+// throw never reaches the app. That is a defect in THAT adapter, tracked separately — it is not a
+// reason to stop throwing here.
 export function getHideAnimationConstants() {
     return getEnforcingNativeModule(RN_BOOT_SPLASH_MODULE_NAME).getConstants();
 }

package/build-ngc/core/native-module.js.map

@@ -1 +1 @@
-{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,gFAAgF;AAChF,wFAAwF;AACxF,qFAAqF;AACrF,yFAAyF;AACzF,oFAAoF;AACpF,4DAA4D;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAGnE,MAAM,0BAA0B,GAAG,cAAc,CAAC;AAMlD,MAAM,UAAU,yBAAyB;IACvC,OAAO,wBAAwB,CAAoB,0BAA0B,CAAC,CAAC,YAAY,EAAE,CAAC;AAChG,CAAC"}
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,gFAAgF;AAChF,wFAAwF;AACxF,qFAAqF;AACrF,yFAAyF;AACzF,oFAAoF;AACpF,4DAA4D;AAC5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAGnE,MAAM,0BAA0B,GAAG,cAAc,CAAC;AAMlD,kFAAkF;AAClF,EAAE;AACF,gGAAgG;AAChG,gGAAgG;AAChG,4FAA4F;AAC5F,8FAA8F;AAC9F,mGAAmG;AACnG,2EAA2E;AAC3E,EAAE;AACF,0FAA0F;AAC1F,kGAAkG;AAClG,+FAA+F;AAC/F,mFAAmF;AACnF,EAAE;AACF,6FAA6F;AAC7F,mGAAmG;AACnG,kGAAkG;AAClG,gCAAgC;AAChC,MAAM,UAAU,yBAAyB;IACvC,OAAO,wBAAwB,CAC7B,0BAA0B,CAC3B,CAAC,YAAY,EAAE,CAAC;AACnB,CAAC"}

package/build-ngc/core/types.d.ts

@@ -16,6 +16,11 @@ export type IManifest = {
         height: number;
     };
 };
+export type IHideAnimationFailureStage = 'hide' | 'animate';
+export type IHideAnimationFailure = {
+    stage: IHideAnimationFailureStage;
+    error: unknown;
+};
 export type IHideAnimationConfig = {
     manifest: IManifest;
     ready?: boolean;
@@ -24,6 +29,7 @@ export type IHideAnimationConfig = {
     brand?: IImageSourceProp;
     darkBrand?: IImageSourceProp;
     animate: () => void;
+    onError?: (failure: IHideAnimationFailure) => void;
     statusBarTranslucent?: boolean;
     navigationBarTranslucent?: boolean;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@symbiote-native/splash-screen",
-  "version": "3.0.3",
-  "description": "Third-party splash-screen native module wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters.",
+  "version": "3.2.0",
+  "description": "Third-party splash-screen native module wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -33,6 +33,14 @@
       "types": "./build/react/index.d.ts",
       "default": "./build/react/index.js"
     },
+    "./svelte": {
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
+    },
+    "./solid": {
+      "types": "./build/solid/index.d.ts",
+      "default": "./build/solid/index.js"
+    },
     "./angular": {
       "types": "./build-ngc/angular/index.d.ts",
       "react-native": "./build-ngc/angular/index.js",
@@ -65,18 +73,22 @@
   "dependencies": {
     "react-native-bootsplash": "7.3.2",
     "react-native-is-edge-to-edge": "^1.3.1",
-    "@symbiote-native/components": "0.3.0"
+    "@symbiote-native/components": "0.5.0"
   },
   "peerDependencies": {
+    "@symbiote-native/angular": ">=0.6.2",
     "@symbiote-native/engine": ">=0.1.7",
+    "@symbiote-native/react": ">=0.2.8",
+    "@symbiote-native/solid": ">=0.0.1",
+    "@symbiote-native/svelte": ">=0.1.0",
+    "@symbiote-native/vue": ">=0.3.8",
     "@angular/core": ">=20",
     "@vue/runtime-core": "^3.5.13",
     "react": ">=19.0.0",
     "react-native": ">=0.86",
-    "vue": ">=3.5.0",
-    "@symbiote-native/angular": "0.6.2",
-    "@symbiote-native/react": "0.2.8",
-    "@symbiote-native/vue": "0.3.8"
+    "solid-js": ">=1.9.0",
+    "svelte": ">=5.0.0",
+    "vue": ">=3.5.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -85,6 +97,12 @@
     "@symbiote-native/react": {
       "optional": true
     },
+    "@symbiote-native/solid": {
+      "optional": true
+    },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
     "@symbiote-native/vue": {
       "optional": true
     },
@@ -97,24 +115,34 @@
     "react": {
       "optional": true
     },
+    "solid-js": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
     "vue": {
       "optional": true
     }
   },
   "devDependencies": {
-    "@angular/compiler": "^22",
-    "@angular/compiler-cli": "^22",
-    "@angular/core": "^22",
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
     "@types/node": "^26.0.0",
     "@types/react": "^19.2.0",
     "@vue/runtime-core": "^3.5.13",
     "react": "19.2.3",
+    "solid-js": "^1.9.14",
+    "svelte": "^5.56.0",
     "typescript": "~6.0.0",
-    "@symbiote-native/angular": "0.6.2",
-    "@symbiote-native/engine": "0.1.7",
-    "@symbiote-native/react": "0.2.8",
-    "@symbiote-native/test-utils": "0.1.6",
-    "@symbiote-native/vue": "0.3.8"
+    "@symbiote-native/angular": "0.8.0",
+    "@symbiote-native/engine": "0.3.0",
+    "@symbiote-native/react": "0.4.0",
+    "@symbiote-native/solid": "0.1.0",
+    "@symbiote-native/svelte": "0.3.0",
+    "@symbiote-native/test-utils": "0.2.0",
+    "@symbiote-native/vue": "0.5.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/index.ts

@@ -3,4 +3,11 @@
 // machine, style computation, and native-constants read all live in core, shared with React/Vue.
 export { hide, isVisible } from '../core';
 export { HideAnimationService } from './services/hide-animation.service';
-export type { IHideAnimationConfig, IHideAnimationResult, IManifest, IHideConfig } from '../core';
+export type {
+  IHideAnimationConfig,
+  IHideAnimationFailure,
+  IHideAnimationFailureStage,
+  IHideAnimationResult,
+  IManifest,
+  IHideConfig,
+} from '../core';

package/src/angular/services/hide-animation.service/index.ts

@@ -1,35 +1,44 @@
-import { computed, effect, inject, Injectable, Injector, type Signal } from '@angular/core';
+import {
+  computed,
+  effect,
+  inject,
+  Injectable,
+  Injector,
+  type Signal,
+} from '@angular/core';
 import {
   computeHideAnimationStyles,
-  getHideAnimationConstants,
   HideAnimationController,
   type IHideAnimationConfig,
   type IHideAnimationResult,
 } from '../../../core';
 
 // Angular twin of React's `useHideAnimation` hook and Vue's `useHideAnimation` composable.
-// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
-// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
-// inside an injection context) with a GETTER, so it can keep reading the caller's own signals —
-// the same reason Vue's composable also takes a getter rather than a value: there is no
-// re-render/re-setup cycle here to hang a fresh read off of.
+// Angular has no per-instance hook, so `connect()` stands in for it: call it ONCE (typically
+// from a component's field initializer, inside an injection context) with a GETTER so it can
+// keep reading the caller's own signals — same reason Vue's composable takes a getter too.
 //
 //   readonly hideAnimation = inject(HideAnimationService).connect(() => this.config());
 //   // template: [style]="hideAnimation().container.style", (layout)="..." etc.
 @Injectable({ providedIn: 'root' })
 export class HideAnimationService {
-  // Captured in the constructor (itself always run inside an injection context by Angular's
-  // own DI) so `connect()` can create an `effect()` even when called from plain field-initializer
-  // code that is not, on its own, an active injection context — mirrors create-tunnel.ts's
-  // `TunnelOut`, which passes its own captured `Injector` to `effect()` for the same reason.
+  // Captured in the constructor (always run inside an injection context by Angular's own DI)
+  // so `connect()` can create an `effect()` even when called from field-initializer code that
+  // isn't itself an active injection context — mirrors create-tunnel.ts's `TunnelOut`.
   private readonly injector = inject(Injector);
 
+  // The controller reads the native constants in its constructor, so a missing RNBootSplash
+  // throws out of connect() and aborts the host component's construction — deliberately: that
+  // is a build error, and a splash quietly stuck in light mode would ship unnoticed.
   connect(getConfig: () => IHideAnimationConfig): Signal<IHideAnimationResult> {
     const controller = new HideAnimationController(getConfig());
-    const constants = getHideAnimationConstants();
 
-    effect(() => controller.updateConfig(getConfig()), { injector: this.injector });
+    effect(() => controller.updateConfig(getConfig()), {
+      injector: this.injector,
+    });
 
-    return computed(() => computeHideAnimationStyles(getConfig(), constants, controller));
+    return computed(() =>
+      computeHideAnimationStyles(getConfig(), controller.constants, controller),
+    );
   }
 }

package/src/core/hide-animation-controller.ts

@@ -1,5 +1,11 @@
+import { dlog } from '@symbiote-native/engine';
 import { hide } from './hide';
-import type { IHideAnimationConfig } from './types';
+import { getHideAnimationConstants } from './native-module';
+import type {
+  IHideAnimationConfig,
+  IHideAnimationConstants,
+  IHideAnimationFailure,
+} from './types';
 
 type IReadinessState = {
   layoutReady: boolean;
@@ -7,6 +13,7 @@ type IReadinessState = {
   brandReady: boolean;
   userReady: boolean;
   animate: () => void;
+  onError: ((failure: IHideAnimationFailure) => void) | undefined;
   animateHasBeenCalled: boolean;
 };
 
@@ -16,9 +23,28 @@ type IReadinessState = {
 // brandReady are captured ONCE at construction (mirrors the original's useRef factory,
 // evaluated only on first render) — a config that later drops its logo/brand source does
 // NOT retroactively flip readiness back on, only updateConfig's animate/userReady do.
+//
+// DELIBERATE DIVERGENCE from upstream, one place only: upstream swallows a rejected hide() with a
+// bare `.catch(() => {})`, which strands the app under a splash it can no longer dismiss (see
+// maybeRunAnimate). We fail open and report instead. Everything else, the unguarded constants read
+// included, stays a faithful port.
 export class HideAnimationController {
+  // Read once here rather than once per adapter: the values never change over a splash's lifetime.
+  // Unguarded on purpose — a missing RNBootSplash is a build error that must stay loud, see
+  // native-module.ts for the full reasoning before wrapping this in anything.
+  readonly constants: IHideAnimationConstants;
+
   private readonly readiness: IReadinessState;
 
+  // dlog is DEBUG-gated, so it is the developer's seam, not the report: config.onError is the
+  // channel the app actually hears about this on.
+  private readonly reportFailure = (failure: IHideAnimationFailure): void => {
+    dlog(
+      `splash-screen: hide animation degraded at "${failure.stage}": ${String(failure.error)}`,
+    );
+    this.readiness.onError?.(failure);
+  };
+
   constructor(config: IHideAnimationConfig) {
     this.readiness = {
       layoutReady: false,
@@ -26,12 +52,15 @@ export class HideAnimationController {
       brandReady: config.manifest.brand == null || config.brand == null,
       userReady: config.ready ?? true,
       animate: config.animate,
+      onError: config.onError,
       animateHasBeenCalled: false,
     };
+    this.constants = getHideAnimationConstants();
   }
 
   updateConfig(config: IHideAnimationConfig): void {
     this.readiness.animate = config.animate;
+    this.readiness.onError = config.onError;
     this.readiness.userReady = config.ready ?? true;
     this.maybeRunAnimate();
   }
@@ -62,9 +91,22 @@ export class HideAnimationController {
       !state.animateHasBeenCalled
     ) {
       state.animateHasBeenCalled = true;
+      // Fail open. animateHasBeenCalled is already true by the time hide() settles, so the gate
+      // is shut for good: on a rejection there is no readiness callback left that could retry,
+      // and skipping animate() means the caller's splash overlay never fades out — the app sits
+      // under it forever. Running animate() anyway costs at worst a fade over a native splash
+      // that is still up; not running it costs the whole app.
       hide({ fade: false })
-        .then(() => state.animate())
-        .catch(() => {});
+        .catch((error: unknown) => {
+          this.reportFailure({ stage: 'hide', error });
+        })
+        .then(() => {
+          state.animate();
+        })
+        .catch((error: unknown) => {
+          // The caller's own animation throwing must not become an unhandled rejection either.
+          this.reportFailure({ stage: 'animate', error });
+        });
     }
   }
 }

package/src/core/index.ts

@@ -7,6 +7,8 @@ export type {
   IManifest,
   IHideAnimationConfig,
   IHideAnimationContainerProps,
+  IHideAnimationFailure,
+  IHideAnimationFailureStage,
   IHideAnimationImageProps,
   IHideAnimationResult,
   IHideAnimationConstants,

package/src/core/native-module.ts

@@ -14,6 +14,26 @@ type IRNBootSplashSpec = {
   getConstants(): IHideAnimationConstants;
 };
 
+// DELIBERATELY UNGUARDED — do not wrap this in a try/catch or hand it a fallback.
+//
+// A missing RNBootSplash is a BUILD error, not a runtime condition: the module is either linked
+// into the binary or it is not, deterministically, on the very first launch. Upstream treats it
+// the same way and does not soften it either — react-native-bootsplash's whole spec file is
+// `TurboModuleRegistry.getEnforcing<Spec>("RNBootSplash")` (src/specs/NativeRNBootSplash.ts),
+// which throws at module-IMPORT time, and its useHideAnimation calls `NativeModule.getConstants()`
+// with no guard at all. `getEnforcing` exists precisely to make this loud.
+//
+// This repo has a live footgun that depends on it staying loud: `npm install` deletes the
+// `.rn-bootsplash/` folder this package's podspec vendors at pod-install time (see CLAUDE.md), so
+// a skipped `pod install` yields exactly this missing module. Degrading to light-mode defaults
+// would turn that into "the splash looks fine, just never dark" and it would ship.
+//
+// Note the failure is currently invisible under @symbiote-native/react specifically: mount()
+// (adapters/react/src/render.ts) wires the reconciler's uncaught-error callbacks to `noop`, so the
+// throw never reaches the app. That is a defect in THAT adapter, tracked separately — it is not a
+// reason to stop throwing here.
 export function getHideAnimationConstants(): IHideAnimationConstants {
-  return getEnforcingNativeModule<IRNBootSplashSpec>(RN_BOOT_SPLASH_MODULE_NAME).getConstants();
+  return getEnforcingNativeModule<IRNBootSplashSpec>(
+    RN_BOOT_SPLASH_MODULE_NAME,
+  ).getConstants();
 }

package/src/core/types.ts

@@ -1,4 +1,7 @@
-import type { IImageSourceProp, IResizeMode } from '@symbiote-native/components';
+import type {
+  IImageSourceProp,
+  IResizeMode,
+} from '@symbiote-native/components';
 import type { IStyleProp, IViewStyle } from '@symbiote-native/engine';
 
 export type IHideConfig = {
@@ -19,6 +22,21 @@ export type IManifest = {
   };
 };
 
+// The two RECOVERABLE points in the hide sequence, both of them runtime failures of a native
+// module that does exist:
+//   hide    - the native hide() call rejected.
+//   animate - the caller's own fade-out threw.
+// Neither is allowed to strand the app under a splash it can no longer dismiss, so each is
+// reported and the sequence carries on. A `hide` failure means the native splash may still be up
+// underneath the caller's fade-out. A MISSING native module is deliberately not on this list —
+// that is a build error and it throws (see native-module.ts).
+export type IHideAnimationFailureStage = 'hide' | 'animate';
+
+export type IHideAnimationFailure = {
+  stage: IHideAnimationFailureStage;
+  error: unknown;
+};
+
 export type IHideAnimationConfig = {
   manifest: IManifest;
   ready?: boolean;
@@ -30,6 +48,10 @@ export type IHideAnimationConfig = {
 
   animate: () => void;
 
+  // The caller's only way to tell a nominal hide from a degraded one: `animate()` now runs in
+  // both cases, so its firing no longer proves the native side succeeded.
+  onError?: (failure: IHideAnimationFailure) => void;
+
   statusBarTranslucent?: boolean;
   navigationBarTranslucent?: boolean;
 };

package/src/react/hooks/use-hide-animation/index.ts

@@ -1,40 +1,35 @@
-// React lifecycle wiring over the framework-agnostic HideAnimationController + style
-// computation (core/) — mirrors the lifecycle-bucket naming convention of
-// adapters/react/src/hooks. Faithful port of react-native-bootsplash's own useHideAnimation:
-// the controller is constructed lazily ONCE (a useRef factory, never reconstructed across
-// re-renders), native constants are read once via useState's lazy initializer (they never
-// change), and an effect with NO dependency array re-syncs the controller's config after
-// EVERY render — intentional, since `ready` flipping true only gets picked up this way.
+// Port of react-native-bootsplash's own useHideAnimation over the framework-agnostic
+// HideAnimationController + style computation in core/. The controller is built lazily ONCE
+// via a useRef factory (never reconstructed across re-renders); the effect below has NO
+// dependency array and re-syncs the controller's config after EVERY render on purpose, since
+// `ready` flipping true is only picked up that way. The native constants ride along on that same
+// once-built controller, so there is no separate useState to hold them.
 //
-// No useMemo around the style computation: upstream lists ~15 individual primitive fields
-// (manifest.logo.width, backgroundColor, ...) as its memo's deps specifically so Object.is
-// compares by VALUE, not by the `config`/`manifest` object's reference — callers construct
-// that object fresh on every render (the normal way to call this hook), so keying a memo off
-// the whole object would recompute every render anyway while looking like it memoizes.
-// Reproducing the fine-grained list isn't worth it for a splash screen shown for a couple of
-// renders at boot; computing plainly is honest about the actual cost and simpler to read.
-import { useEffect, useRef, useState } from 'react';
+// No useMemo around the style computation: upstream memoizes on ~15 individual primitive
+// fields so Object.is compares by value rather than by the config/manifest object's
+// reference (callers construct that object fresh every render, so keying off the whole
+// object would recompute anyway). Not worth reproducing for a splash screen shown a couple
+// of renders at boot — computing plainly is simpler and equally cheap.
+import { useEffect, useRef } from 'react';
 import {
   computeHideAnimationStyles,
-  getHideAnimationConstants,
   HideAnimationController,
   type IHideAnimationConfig,
-  type IHideAnimationConstants,
   type IHideAnimationResult,
 } from '../../../core';
 
-export function useHideAnimation(config: IHideAnimationConfig): IHideAnimationResult {
+export function useHideAnimation(
+  config: IHideAnimationConfig,
+): IHideAnimationResult {
   const controllerRef = useRef<HideAnimationController | null>(null);
   if (controllerRef.current == null) {
     controllerRef.current = new HideAnimationController(config);
   }
   const controller = controllerRef.current;
 
-  const [constants] = useState<IHideAnimationConstants>(() => getHideAnimationConstants());
-
   useEffect(() => {
     controller.updateConfig(config);
   });
 
-  return computeHideAnimationStyles(config, constants, controller);
+  return computeHideAnimationStyles(config, controller.constants, controller);
 }

package/src/react/index.ts

@@ -6,4 +6,11 @@
 
 export { hide, isVisible } from '../core';
 export { useHideAnimation } from './hooks/use-hide-animation';
-export type { IHideAnimationConfig, IHideAnimationResult, IManifest, IHideConfig } from '../core';
+export type {
+  IHideAnimationConfig,
+  IHideAnimationFailure,
+  IHideAnimationFailureStage,
+  IHideAnimationResult,
+  IManifest,
+  IHideConfig,
+} from '../core';

package/src/solid/index.ts

@@ -0,0 +1,17 @@
+// @symbiote-native/splash-screen/solid: the Solid entry over the framework-agnostic core.
+// hide/isVisible carry zero lifecycle and are re-exported verbatim; createHideAnimation wraps
+// HideAnimationController + computeHideAnimationStyles with Solid's own reactivity
+// (primitives/create-hide-animation.ts) — mirrors the lifecycle-bucket naming convention of
+// adapters/solid/src/primitives (never `hooks`/`composables`/`runes`, those are React's, Vue's
+// and Svelte's terms).
+
+export { hide, isVisible } from '../core';
+export { createHideAnimation } from './primitives/create-hide-animation';
+export type {
+  IHideAnimationConfig,
+  IHideAnimationFailure,
+  IHideAnimationFailureStage,
+  IHideAnimationResult,
+  IManifest,
+  IHideConfig,
+} from '../core';

package/src/solid/primitives/create-hide-animation.ts

@@ -0,0 +1,37 @@
+// Solid lifecycle wiring over the framework-agnostic HideAnimationController + style computation
+// (core/) — the Solid twin of React's useHideAnimation hook, Vue's composable and Svelte's rune.
+//
+// `primitives/` and `create*`, never `hooks/`+`use*`: Solid's ecosystem calls a composable
+// reactive function a PRIMITIVE and reserves `use*` for consuming something that already exists.
+// Full rationale in adapters/solid/src/primitives/create-color-scheme.ts.
+//
+// Takes a config ACCESSOR, not a plain value, and returns one: a Solid component body runs ONCE
+// (like Vue's setup, unlike a React hook re-running every render), so a plain config would freeze
+// at its boot value and `ready` flipping true would never be seen. The effect below re-syncs the
+// controller on every signal the accessor reads, mirroring Vue's watchEffect.
+//
+// The controller stays a plain local, never a signal: only its methods are called. It also carries
+// the native constants, read once in its constructor — so a missing RNBootSplash throws straight
+// out of the primitive body, on purpose.
+
+import { createEffect, createMemo, type Accessor } from 'solid-js';
+import {
+  computeHideAnimationStyles,
+  HideAnimationController,
+  type IHideAnimationConfig,
+  type IHideAnimationResult,
+} from '../../core';
+
+export function createHideAnimation(
+  config: Accessor<IHideAnimationConfig>,
+): Accessor<IHideAnimationResult> {
+  const controller = new HideAnimationController(config());
+
+  createEffect(() => {
+    controller.updateConfig(config());
+  });
+
+  return createMemo(() =>
+    computeHideAnimationStyles(config(), controller.constants, controller),
+  );
+}

package/src/svelte/index.ts

@@ -0,0 +1,16 @@
+// @symbiote-native/splash-screen/svelte: the Svelte entry over the framework-agnostic core.
+// hide/isVisible carry zero lifecycle and are re-exported verbatim; useHideAnimation wraps
+// HideAnimationController + computeHideAnimationStyles with Svelte's own runes
+// (runes/use-hide-animation.svelte.ts) — mirrors the lifecycle-bucket naming convention of
+// adapters/svelte/src/runes (never `hooks`/`composables`, those are React's/Vue's terms).
+
+export { hide, isVisible } from '../core';
+export { useHideAnimation } from './runes/use-hide-animation.svelte';
+export type {
+  IHideAnimationConfig,
+  IHideAnimationFailure,
+  IHideAnimationFailureStage,
+  IHideAnimationResult,
+  IManifest,
+  IHideConfig,
+} from '../core';

package/src/svelte/runes/use-hide-animation.svelte.ts

@@ -0,0 +1,41 @@
+// Svelte lifecycle wiring over the framework-agnostic HideAnimationController + style
+// computation (core/). A Svelte component's `<script>` body runs ONCE (like Vue's setup,
+// unlike a React hook re-running every render), so this takes a config GETTER, not a plain
+// value — the boxed-getter convention from use-color-scheme.svelte.ts. The controller stays
+// a plain local, not `$state`: only its methods are called, nothing needs Svelte to react to
+// the reference itself. `$effect` re-syncs the controller's config on every reactive read
+// inside `getConfig()`, mirroring Vue's `watchEffect`. The controller also carries the native
+// constants, read once in its constructor — so a missing RNBootSplash throws straight out of the
+// component's script body, on purpose.
+import {
+  computeHideAnimationStyles,
+  HideAnimationController,
+  type IHideAnimationConfig,
+  type IHideAnimationResult,
+} from '../../core';
+
+export function useHideAnimation(getConfig: () => IHideAnimationConfig): {
+  readonly current: IHideAnimationResult;
+} {
+  const controller = new HideAnimationController(getConfig());
+
+  let result = $state<IHideAnimationResult>(
+    computeHideAnimationStyles(getConfig(), controller.constants, controller),
+  );
+
+  $effect(() => {
+    const config = getConfig();
+    controller.updateConfig(config);
+    result = computeHideAnimationStyles(
+      config,
+      controller.constants,
+      controller,
+    );
+  });
+
+  return {
+    get current(): IHideAnimationResult {
+      return result;
+    },
+  };
+}

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,6 @@
+// Pulls in svelte's ambient global declarations ($state/$effect/...) for this package's tsc
+// program. adapters/svelte gets these for free because render.ts does a real value import from
+// 'svelte' (any file in a program importing a module loads its ambient globals for the whole
+// program); this package has no such import, so a triple-slash reference does the same job
+// explicitly rather than relying on an incidental side-effect.
+/// <reference types="svelte" />