@symbiote-native/svelte 0.1.0

package/build/modules/animated/AnimatedScrollView.svelte

@@ -0,0 +1,92 @@
+<script lang="ts" module>
+  // Animated.ScrollView — unlike View/Text/Image, ScrollView.svelte already exposes an
+  // imperative handle (scrollTo/scrollToEnd/flashScrollIndicators/getScrollNode, the SAME
+  // IScrollViewHandle shape createAnimatedComponent's resolveHostNode expects on Vue/React) via
+  // its own top-level `export function`s. That is exactly what `bind:this` needs, so this
+  // component WRAPS the real ScrollView.svelte directly rather than hand-authoring a reduced
+  // host tag — the only way to keep ScrollView's full feature surface (sticky headers,
+  // RefreshControl, maintainVisibleContentPosition, native scroll-attach) per
+  // <adapters_reach_full_feature_parity>; a hand-authored duplicate would silently lose all of
+  // it. getScrollNode() IS this adapter's resolveHostNode() equivalent for a scroll container.
+  import type { IAnimatedComponentProps } from './animated-component-props';
+
+  export type { IAnimatedComponentProps };
+</script>
+
+<script lang="ts">
+  import {
+    createAnimatedLeafLifecycle,
+    isNativeAnimatedAvailable,
+    reduceProps,
+    readPassthroughStyle,
+  } from '@symbiote-native/engine';
+  import type { ISymbioteNode } from '@symbiote-native/engine';
+  import type { IScrollViewHandle } from '@symbiote-native/components';
+  import ScrollView from '../../components/scroll-view/index.svelte';
+  import type { IScrollViewProps } from '../../components/scroll-view/scroll-view-props';
+  import { pickAttachmentProps } from '../../runes/attachments';
+
+  let {
+    children,
+    passthroughAnimatedPropExplicitValues: passthrough,
+    ...rest
+  }: IAnimatedComponentProps = $props();
+
+  // The wrapped ScrollView's own instance — its exported functions ARE its public handle
+  // (svelte-adapter-dom-shim skill's ScrollView precedent), captured by IDENTITY via bind:this,
+  // never $state (a deep proxy would still work here since it's just function references, but
+  // $state.raw stays consistent with every other imperative-handle capture in this adapter).
+  let scrollRef = $state.raw<IScrollViewHandle | null>(null);
+
+  const wantsNative = $derived(passthrough != null && isNativeAnimatedAvailable());
+
+  // reduceProps returns Record<string, unknown> — every field is `unknown` even though it is,
+  // at runtime, exactly IScrollViewProps' shape. Bridged back without an `as` cast via the same
+  // Object.assign(Object.create(null), …) pattern AnimatedImage.svelte uses (and React's
+  // create-animated-component.tsx already establishes): Object.create(null) types as `any`, so
+  // the assignment result does too, and TS allows binding `any` into a typed variable.
+  const reduced = $derived.by(() => {
+    const resolved = reduceProps(rest);
+    const passthroughStyle = readPassthroughStyle(passthrough);
+    if (passthroughStyle !== undefined) {
+      resolved.style =
+        resolved.style === undefined ? passthroughStyle : [resolved.style, passthroughStyle];
+    }
+    const props: IScrollViewProps = Object.assign(Object.create(null), resolved);
+    return props;
+  });
+
+  const runtime = createAnimatedLeafLifecycle('AnimatedScrollView');
+
+  $effect(() => {
+    const currentRest = rest;
+    const node: ISymbioteNode | null = scrollRef?.getScrollNode() ?? null;
+    runtime.reconcile(currentRest, node, wantsNative);
+  });
+
+  $effect(() => () => runtime.teardown());
+
+  // Forward the imperative handle: a parent's `bind:this` on <Animated.ScrollView> gets the
+  // same scrollTo/scrollToEnd/flashScrollIndicators/getScrollNode surface plain ScrollView
+  // exposes — the Svelte twin of Vue's delegating Proxy `expose()`.
+  export function scrollTo(options?: { x?: number; y?: number; animated?: boolean }): void {
+    scrollRef?.scrollTo(options);
+  }
+  export function scrollToEnd(options?: { animated?: boolean }): void {
+    scrollRef?.scrollToEnd(options);
+  }
+  export function flashScrollIndicators(): void {
+    scrollRef?.flashScrollIndicators();
+  }
+  export function getScrollNode(): ISymbioteNode | null {
+    return scrollRef?.getScrollNode() ?? null;
+  }
+
+  // `reduceProps` rebuilds a plain string-keyed Record, so `{@attach}`'s symbol keys do not
+  // survive it — forward them explicitly onto the wrapped ScrollView, which owns the host node.
+  const attachments = $derived(pickAttachmentProps(rest));
+</script>
+
+<ScrollView {...reduced} {...attachments} bind:this={scrollRef}>
+  {@render children?.()}
+</ScrollView>

package/build/modules/animated/AnimatedScrollView.svelte.d.ts

@@ -0,0 +1,17 @@
+import type { IAnimatedComponentProps } from './animated-component-props';
+export type { IAnimatedComponentProps };
+import type { ISymbioteNode } from '@symbiote-native/engine';
+declare const AnimatedScrollView: import("svelte").Component<IAnimatedComponentProps, {
+    scrollTo: (options?: {
+        x?: number;
+        y?: number;
+        animated?: boolean;
+    }) => void;
+    scrollToEnd: (options?: {
+        animated?: boolean;
+    }) => void;
+    flashScrollIndicators: () => void;
+    getScrollNode: () => ISymbioteNode | null;
+}, "">;
+type AnimatedScrollView = ReturnType<typeof AnimatedScrollView>;
+export default AnimatedScrollView;

package/build/modules/animated/AnimatedText.svelte

@@ -0,0 +1,58 @@
+<script lang="ts" module>
+  // Animated.Text — see AnimatedView.svelte's header comment for the shared design rationale
+  // (hand-authored root tag, shared reconcile runtime). Text.svelte is likewise a pure
+  // pass-through bag, so hand-authoring loses no logic.
+  import type { IAnimatedComponentProps } from './animated-component-props';
+
+  export type { IAnimatedComponentProps };
+</script>
+
+<script lang="ts">
+  import {
+    createAnimatedLeafLifecycle,
+    isNativeAnimatedAvailable,
+    reduceProps,
+    readPassthroughStyle,
+  } from '@symbiote-native/engine';
+  import { createAttachmentsSync } from '../../runes/attachments';
+  import type { ShimElement } from '../../dom-shim';
+
+  let {
+    children,
+    passthroughAnimatedPropExplicitValues: passthrough,
+    ...rest
+  }: IAnimatedComponentProps = $props();
+
+  let hostShim = $state.raw<ShimElement | null>(null);
+
+  const wantsNative = $derived(passthrough != null && isNativeAnimatedAvailable());
+
+  const reduced = $derived.by(() => {
+    const out = reduceProps(rest);
+    const passthroughStyle = readPassthroughStyle(passthrough);
+    if (passthroughStyle !== undefined) {
+      out.style = out.style === undefined ? passthroughStyle : [out.style, passthroughStyle];
+    }
+    return out;
+  });
+
+  const runtime = createAnimatedLeafLifecycle('AnimatedText');
+
+  $effect(() => {
+    const currentRest = rest;
+    const node = hostShim?.engineNode ?? null;
+    runtime.reconcile(currentRest, node, wantsNative);
+  });
+
+  $effect(() => () => runtime.teardown());
+
+  // See View.svelte's note on `{@attach}`.
+  const syncAttachments = createAttachmentsSync();
+  $effect(() => {
+    syncAttachments(hostShim, rest);
+  });
+</script>
+
+<symbiote-text p={reduced} bind:this={hostShim}>
+  {@render children?.()}
+</symbiote-text>

package/build/modules/animated/AnimatedText.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { IAnimatedComponentProps } from './animated-component-props';
+export type { IAnimatedComponentProps };
+declare const AnimatedText: import("svelte").Component<IAnimatedComponentProps, {}, "">;
+type AnimatedText = ReturnType<typeof AnimatedText>;
+export default AnimatedText;

package/build/modules/animated/AnimatedView.svelte

@@ -0,0 +1,95 @@
+<script lang="ts" module>
+  // Animated.View: wraps @symbiote-native/engine's Animated value graph around a
+  // symbiote-view host tag. Hand-authors its own root tag rather than composing View.svelte —
+  // View.svelte exposes no host-node escape hatch (no bind:this on its own root, nothing
+  // exported), so there is nothing to capture a ref onto; the pattern instead mirrors
+  // Pressable/ScrollView, the adapter's existing precedent for a component that needs the raw
+  // ShimElement (svelte-adapter-dom-shim skill). Since View.svelte does no prop transformation
+  // of its own (it is a pure pass-through bag), hand-authoring here loses no logic — unlike
+  // AnimatedImage, which reuses Image's buildImageBag for exactly that reason.
+  //
+  // The reactive plumbing (leaf lifecycle, native-driver opt-in, native event attach) is shared
+  // with AnimatedText/AnimatedImage/AnimatedScrollView via animated-props-runtime.ts — see this
+  // module's index.ts for why that is a shared HELPER rather than one generic
+  // createAnimatedComponent(Component) the way Vue/React have: Svelte has no h()/createElement
+  // to parametrize an arbitrary base component at runtime.
+  import type { IAnimatedComponentProps } from './animated-component-props';
+
+  export type { IAnimatedComponentProps };
+</script>
+
+<script lang="ts">
+  import {
+    createAnimatedLeafLifecycle,
+    dlog,
+    isNativeAnimatedAvailable,
+    reduceProps,
+    readPassthroughStyle,
+  } from '@symbiote-native/engine';
+  import { createAttachmentsSync } from '../../runes/attachments';
+  import type { ShimElement } from '../../dom-shim';
+
+  let {
+    children,
+    passthroughAnimatedPropExplicitValues: passthrough,
+    ...rest
+  }: IAnimatedComponentProps = $props();
+
+  // $state.raw, NOT $state — same identity rule every stateful component in this adapter
+  // follows (Switch/Pressable/ScrollView): a deep $state proxy would make the engine's
+  // WeakMap-keyed node lookups miss.
+  let hostShim = $state.raw<ShimElement | null>(null);
+
+  const wantsNative = $derived(passthrough != null && isNativeAnimatedAvailable());
+
+  // Reduced (rasterized) props for the declarative bag: every animated node replaced by its
+  // current value, so the first paint (and every non-animated re-render) carries concrete
+  // values — the per-FRAME path is separate (the runtime's reconcile below), driven straight
+  // off the raw `rest` object, never through this derivation.
+  let reducedCallCount = 0;
+  const reduced = $derived.by(() => {
+    const out = reduceProps(rest);
+    const passthroughStyle = readPassthroughStyle(passthrough);
+    if (passthroughStyle !== undefined) {
+      out.style = out.style === undefined ? passthroughStyle : [out.style, passthroughStyle];
+    }
+    dlog(`AnimatedView reduced#${++reducedCallCount} wantsNative=${wantsNative}`);
+    return out;
+  });
+
+  const runtime = createAnimatedLeafLifecycle('AnimatedView');
+
+  // DIAGNOSTIC (2026-08-13, tracking the effect_update_depth_exceeded device crash): isolates
+  // whether `bind:this={hostShim}` below EVER re-fires after the initial mount. If it does — a
+  // custom-element `p` prop commit re-triggering the ref callback — that reassignment would make
+  // THIS effect's `hostShim?.engineNode` read see a "new" dependency and re-run, independent of
+  // whatever else changed, which is a plausible source of a same-flush synchronous loop that has
+  // no equivalent in React (ref callbacks)/Vue (template refs)/Angular (ViewChild). Reads ONLY
+  // hostShim, deliberately excluding `rest`, so it is unambiguous which one retriggered it.
+  let hostShimChangeCount = 0;
+  $effect(() => {
+    void hostShim;
+    dlog(`AnimatedView hostShim identity change #${++hostShimChangeCount} isNull=${hostShim === null}`);
+  });
+
+  // `rest` and `hostShim` are read unconditionally before any branch — the dependency-tracking
+  // discipline every $effect in this adapter follows (a guarded read drops that dependency from
+  // future re-runs; svelte-adapter-dom-shim skill). reconcile() itself handles a null node.
+  $effect(() => {
+    const currentRest = rest;
+    const node = hostShim?.engineNode ?? null;
+    runtime.reconcile(currentRest, node, wantsNative);
+  });
+
+  $effect(() => () => runtime.teardown());
+
+  // See View.svelte's note on `{@attach}`.
+  const syncAttachments = createAttachmentsSync();
+  $effect(() => {
+    syncAttachments(hostShim, rest);
+  });
+</script>
+
+<symbiote-view p={reduced} bind:this={hostShim}>
+  {@render children?.()}
+</symbiote-view>

package/build/modules/animated/AnimatedView.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { IAnimatedComponentProps } from './animated-component-props';
+export type { IAnimatedComponentProps };
+declare const AnimatedView: import("svelte").Component<IAnimatedComponentProps, {}, "">;
+type AnimatedView = ReturnType<typeof AnimatedView>;
+export default AnimatedView;

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

@@ -0,0 +1,7 @@
+import type { Snippet } from 'svelte';
+export interface IAnimatedComponentProps {
+    style?: unknown;
+    children?: Snippet;
+    passthroughAnimatedPropExplicitValues?: unknown;
+    [key: string]: unknown;
+}

package/build/modules/animated/animated-component-props.js

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

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

@@ -0,0 +1,58 @@
+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';
+export type { IAnimatedComponentProps } from './animated-component-props';
+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: import("svelte").Component<import("./animated-component-props").IAnimatedComponentProps, {}, "">;
+    Text: import("svelte").Component<import("./animated-component-props").IAnimatedComponentProps, {}, "">;
+    Image: import("svelte").Component<import("./animated-component-props").IAnimatedComponentProps, {}, "">;
+    ScrollView: import("svelte").Component<import("./animated-component-props").IAnimatedComponentProps, {
+        scrollTo: (options?: {
+            x?: number;
+            y?: number;
+            animated?: boolean;
+        }) => void;
+        scrollToEnd: (options?: {
+            animated?: boolean;
+        }) => void;
+        flashScrollIndicators: () => void;
+        getScrollNode: () => import("@symbiote-native/engine").ISymbioteNode | null;
+    }, "">;
+};

package/build/modules/animated/index.js

@@ -0,0 +1,69 @@
+// The Animated namespace for @symbiote-native/svelte: the Svelte twin of
+// adapters/vue/src/modules/animated/index.ts (the primary reference — Svelte 5's runes are much
+// closer to Vue's reactivity model than to React's hooks). The value graph, easing,
+// interpolation and drivers come from @symbiote-native/engine (framework-agnostic, JS-driven),
+// spread in verbatim.
+//
+// Unlike Vue/React, there is NO generic `createAnimatedComponent(Component)` here. Vue wraps an
+// arbitrary base component via `h(Component, reducedProps)`; React via `createElement(Component,
+// childProps)` — both are ordinary runtime function calls that work on any component reference.
+// Svelte has no equivalent: a compiled Svelte component is not a plain function you can invoke
+// generically with a fresh prop bag and get back something you can further compose — wrapping
+// one means literally writing `<Component {...props} bind:this={ref}>` inside another `.svelte`
+// file. So each of the four components below (View/Text/Image/ScrollView) is its own hand-
+// authored `.svelte` file sharing only the non-visual reconcile logic
+// (animated-props-runtime.ts). `Animated.createAnimatedComponent` is a genuine, documented scope
+// boundary, not an oversight — see this module's own report for the full reasoning. A consumer
+// wanting to animate their OWN custom component should follow the same four-file pattern (rebuild
+// an AnimatedProps leaf from its props, reconcile on every render into the component's own host
+// node/handle, expose that host node via bind:this) rather than reach for a generic wrapper that
+// does not exist on this adapter.
+//
+// Animated.FlatList / Animated.SectionList are also NOT implemented in this pass. Vue omits them
+// because it has no FlatList/SectionList base component at all; Svelte DOES have both, so this is
+// a narrower, more honest gap than Vue's — flagged as follow-up work, not silently dropped (see
+// the module's own report). Wrapping them would follow the exact same
+// wrap-the-real-component-via-its-exported-handle shape as AnimatedScrollView, once each exposes
+// (or is confirmed to need) an equivalent handle.
+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 AnimatedViewComponent from './AnimatedView.svelte';
+import AnimatedTextComponent from './AnimatedText.svelte';
+import AnimatedImageComponent from './AnimatedImage.svelte';
+import AnimatedScrollViewComponent from './AnimatedScrollView.svelte';
+// The live, JS-driven driver namespace (real frames). 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): the mock keeps the same surface but jumps each animation to its
+// final value synchronously, no frames. The animated COMPONENTS (View/Text/Image/ScrollView) are
+// live in both branches; only the drivers/value/operators/events half is swapped, exactly like
+// RN spreading `...Animated` (impl or mock) over the same component references.
+const drivers = Platform.isDisableAnimations ? AnimatedMock : liveDrivers;
+export const Animated = {
+    View: AnimatedViewComponent,
+    Text: AnimatedTextComponent,
+    Image: AnimatedImageComponent,
+    ScrollView: AnimatedScrollViewComponent,
+    ...drivers,
+};

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

@@ -0,0 +1,7 @@
+import type { Component } from 'svelte';
+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,28 @@
+// 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 Svelte-specific seam.
+//
+// KNOWN GAP, not silently dropped: `IWrapperComponentProvider` (wrapping the app root in a
+// context-provider-style component from native) has no implementation here yet. Vue composes
+// it with `h(wrapper, null, { default: renderRoot })` — Svelte has no equivalent JS-level
+// composition of two independently-authored components (a Svelte component is compiled
+// output, not a value you can nest via a function call the way Vue's `h()` nests vnodes).
+// Closing this needs its own design pass (a synthetic wrapper snippet, most likely) — tracked
+// in the svelte-adapter-dom-shim skill, not solved here. `setWrapperComponentProvider` is
+// re-exported (parity with the engine's API surface) but a set provider is currently ignored.
+import { mount } from '../../render.js';
+import { createAppRegistry, dlog, } from '@symbiote-native/engine';
+function runnableFor(componentProvider, getWrapperComponentProvider) {
+    return appParameters => {
+        dlog(`AppRegistry: mounting on rootTag ${String(appParameters.rootTag)}`);
+        if (getWrapperComponentProvider() !== undefined) {
+            dlog('AppRegistry: wrapperComponentProvider is set but not yet supported on Svelte — ignored');
+        }
+        const RootComponent = componentProvider();
+        mount(appParameters.rootTag, RootComponent, appParameters.initialProps);
+    };
+}
+const { AppRegistry, setHostRegistrar } = createAppRegistry(runnableFor);
+export { AppRegistry, setHostRegistrar };

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

@@ -0,0 +1,5 @@
+export type { IStatusBarProps, IStatusBarStyle } from '@symbiote-native/engine';
+declare const StatusBarWithStatics: import("svelte").Component<import("@symbiote-native/engine").IStatusBarProps, {}, ""> & import("@symbiote-native/engine").IStatusBarImperative;
+export declare const StatusBar: typeof StatusBarWithStatics & {
+    readonly currentHeight?: number;
+};

package/build/modules/status-bar/index.js

@@ -0,0 +1,21 @@
+// StatusBar statics (setHidden/setBarStyle/setNetworkActivityIndicatorVisible/
+// setBackgroundColor/setTranslucent + the Android-only currentHeight getter) attach onto the
+// component value, mirroring RN's `StatusBar.setHidden` static surface — shared verbatim via
+// @symbiote-native/engine's statusBarImperative, the same source React's and Vue's StatusBar
+// use. A `.svelte` file's own module type resolves through svelte's ambient
+// `declare module '*.svelte'` fallback (a bare value export), so the statics are attached here
+// in a plain sibling `.ts` file rather than inside `index.svelte` itself — same pattern as
+// components/image/index.ts.
+import StatusBarComponent from './index.svelte';
+import { statusBarImperative, statusBarCurrentHeight } from '@symbiote-native/engine';
+const StatusBarWithStatics = Object.assign(StatusBarComponent, statusBarImperative);
+// Android exposes the bar height as a native constant; undefined on iOS / when absent. Read
+// lazily (getter) so nothing touches native at import time; the Android engine impl resolves
+// on access.
+Object.defineProperty(StatusBarWithStatics, 'currentHeight', {
+    get: statusBarCurrentHeight,
+    enumerable: true,
+});
+// currentHeight is optional, so the defineProperty-added accessor doesn't need to appear on
+// the runtime object's inferred type for this assignment to hold (no cast).
+export const StatusBar = StatusBarWithStatics;

package/build/modules/status-bar/index.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+  // StatusBar, the Svelte lifecycle half. The native StatusBarManager driving
+  // (applyStatusBarProps), the imperative statics, and the Android bar-height constant all
+  // live in @symbiote-native/engine, shared verbatim with React/Vue; Metro selects the
+  // engine's status-bar.ios.ts / status-bar.android.ts per host, so the platform divergence
+  // never reaches this file. Svelte supplies only the declarative shape: a component that
+  // renders no Fabric view (empty template) and re-applies the props through an `$effect` on
+  // mount + every prop change — the Svelte twin of Vue's watchEffect / React's useEffect.
+  //
+  // Unlike Vue's twin (status-bar.ts), no untyped-attrs guard layer is needed: Svelte's
+  // `$props()` already destructures real typed fields straight from the compiler, so there is
+  // no kebab-case-attrs normalization step to run first.
+  import { applyStatusBarProps, type IStatusBarProps } from '@symbiote-native/engine';
+
+  let props: IStatusBarProps = $props();
+
+  $effect(() => {
+    applyStatusBarProps(props);
+  });
+</script>

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

@@ -0,0 +1,4 @@
+import { type IStatusBarProps } from '@symbiote-native/engine';
+declare const Index: import("svelte").Component<IStatusBarProps, {}, "">;
+type Index = ReturnType<typeof Index>;
+export default Index;

package/build/native-view-bridge.d.ts

@@ -0,0 +1,4 @@
+export { mount, unmount } from './render';
+export { mountDescriptorChildren, createDescriptorChildrenSync } from './descriptor-to-svelte';
+export type { IDescriptorChildrenMount } from './descriptor-to-svelte';
+export type { ShimElement } from './dom-shim';

package/build/native-view-bridge.js

@@ -0,0 +1,27 @@
+// The subset of this adapter a downstream THIRD-PARTY-native-view package
+// (@symbiote-native/slider, packages/slider/src/svelte — see symbiote-third-party-native-view
+// skill) needs, both at runtime and in its own tests. Lives OUTSIDE the main barrel
+// (./index.ts) for the same reason bootstrap.ts does: `./index.ts` re-exports `./components`,
+// whose files are real `.svelte` sources — importing it (even for a single named export)
+// forces the whole module graph to load, and Vite/vitest's plain transform (no svelte plugin is
+// registered for this repo's tests — see svelte-adapter-dom-shim skill §15, deliberately: unit
+// tests compile a `.svelte` file explicitly via `svelte/compiler` instead of a live import
+// pipeline) cannot parse `.svelte` syntax, failing with "Failed to parse source for import
+// analysis". Every export below resolves through a `.svelte`-free graph (render.ts,
+// descriptor-to-svelte.ts, dom-shim/*), confirmed by grepping each for a `.svelte` import.
+//
+// `mount`/`unmount`: the same pair every framework-agnostic third-party-view package's own test
+// needs to bootstrap a surface — the twin of adapters/svelte's OWN internal tests importing them
+// from the relative `./render` (unreachable from outside this package; a downstream package must
+// go through the export map instead).
+//
+// `mountDescriptorChildren`/`createDescriptorChildrenSync`: the generic Descriptor -> shim-tree
+// bridge (svelte-adapter-dom-shim skill §19), the Svelte twin of Vue's `descriptorToVue` /
+// React's `descriptorToReact` (both exported from their own adapter's main barrel — Svelte's
+// bridge lives here instead, precisely because its own home module is `.svelte`-free but the
+// main barrel that would otherwise re-export it is not). Needed by a third-party-view package to
+// mount a Descriptor whose `type` is a raw, non-`symbiote-`-prefixed Fabric name (e.g.
+// 'RNCSlider') that cannot be written as a literal Svelte template tag — see
+// packages/slider/src/svelte/slider/index.svelte's header for the full reasoning.
+export { mount, unmount } from './render.js';
+export { mountDescriptorChildren, createDescriptorChildrenSync } from './descriptor-to-svelte.js';

package/build/preprocessor/forbid-web-only-constructs.d.ts

@@ -0,0 +1,8 @@
+export declare function forbidWebOnlyConstructs(): {
+    markup(input: {
+        content: string;
+        filename?: string;
+    }): {
+        code: string;
+    };
+};