@symbiote-native/svelte 0.1.0

package/build/dom-shim/shim-node.js

@@ -0,0 +1,207 @@
+// The retained shim tree Svelte's compiled output believes is the DOM. Every shim node
+// (Element / Text / Comment / DocumentFragment) extends this. See the svelte-adapter-dom-shim
+// skill (§2, §3, §9) for the measured Svelte-internal contract this satisfies.
+//
+// The engine binding is LAZY (§9): `from_tree` builds each template graph once and
+// `cloneNode(true)`s it per instance, so a template's prototype nodes are never inserted
+// into a live tree. Creating an ISymbioteNode for those would allocate engine nodes that
+// never render. A shim node gets its ISymbioteNode only when it (or an ancestor) is
+// actually inserted under the live root — `makeLive` does that, once, recursively.
+//
+// Fields below are plain public members, not TS `private`/`protected`: this whole
+// `dom-shim/` directory is internal implementation, never reachable from the adapter's
+// public barrel (see index.ts) or from app code, so per-field access control buys nothing
+// here and would only get in the way of the module-level helpers (`detachFromParent`,
+// `normalizeInsertable`) and the root's eager bind (root-element.ts) that all need to reach
+// across sibling shim-node instances.
+import { appendChild as engineAppendChild, insertBefore as engineInsertBefore, removeChild as engineRemoveChild, } from '@symbiote-native/engine';
+let documentFactory;
+export function registerShimDocumentFactory(factory) {
+    documentFactory = factory;
+}
+function shimDocument() {
+    if (documentFactory === undefined) {
+        throw new Error('svelte dom-shim: document accessed before its module finished loading');
+    }
+    return documentFactory();
+}
+export class ShimNode {
+    parent = null;
+    children = [];
+    engineNode = undefined;
+    surface = undefined;
+    // Overridden to `true` by ShimDocumentFragment's field initializer — a plain inherited-field
+    // check, not an `instanceof`, so this module never has to import that subclass (§ above).
+    isDocumentFragment = false;
+    onMadeLive() { }
+    get parentNode() {
+        return this.parent;
+    }
+    get lastChild() {
+        return this.children[this.children.length - 1] ?? null;
+    }
+    get nodeName() {
+        return '';
+    }
+    // We never emit `<template>` — always undefined, per §3c.
+    get content() {
+        return undefined;
+    }
+    get ownerDocument() {
+        return shimDocument();
+    }
+    // Called once, when this node (or an ancestor) is first inserted under the live root.
+    // Idempotent: a node already live just hands back its existing engine node.
+    makeLive(surface) {
+        const existing = this.engineNode;
+        if (existing !== undefined)
+            return existing;
+        this.surface = surface;
+        const engineNode = this.createEngineNode();
+        this.engineNode = engineNode;
+        this.onMadeLive();
+        for (const child of this.children) {
+            engineAppendChild(engineNode, child.makeLive(surface));
+        }
+        return engineNode;
+    }
+    append(...nodes) {
+        for (const node of nodes)
+            this.appendChild(node);
+    }
+    appendChild(node) {
+        for (const single of normalizeInsertable(node))
+            this.insertOne(single, null);
+        return node;
+    }
+    insertBefore(node, ref) {
+        for (const single of normalizeInsertable(node))
+            this.insertOne(single, ref);
+        return node;
+    }
+    // Spec-compliant no-op when parentless (DOM's ChildNode.before() steps: "let parent be
+    // this's parent; if parent is null, then return" — NOT a throw). This is load-bearing, not
+    // pedantry: Svelte's own BranchManager (dom/blocks/branches.js, the machinery behind
+    // `{#each}`/`{#if}`/`{@render}` deferred/batched updates) races an offscreen fragment's
+    // placeholder anchor against the very effect that renders into it — the anchor can already
+    // be detached (via `offscreen.fragment.lastChild.remove()` during a batch commit) by the
+    // time that effect's own `anchor.before(realContent)` call fires. In a real DOM this is
+    // harmless (the spec no-op just drops the stale insertion); a throw here crashed any
+    // component populating a reactive list via a POST-MOUNT effect (proven via a minimal
+    // {#each}-over-a-SvelteMap-populated-in-$effect repro — see svelte-adapter-dom-shim skill).
+    before(node) {
+        if (this.parent === null)
+            return;
+        this.parent.insertBefore(node, this);
+    }
+    // A REAL DOM method (`Node.prototype.remove()`, not our own `removeChild`), called by
+    // Svelte's own effect-teardown and anchor-management paths (svelte's `effects.js`,
+    // `operations.js`) directly on the node being torn down, not on its parent. Missing this
+    // surfaced only at actual runtime (mount-pipeline.smoke.test.ts) — `tsc --build` has no way
+    // to catch a missing DOM method a compiled Svelte bundle calls.
+    remove() {
+        this.parent?.removeChild(this);
+    }
+    removeChild(child) {
+        const index = this.children.indexOf(child);
+        if (index >= 0)
+            this.children.splice(index, 1);
+        child.parent = null;
+        if (this.engineNode !== undefined && child.engineNode !== undefined) {
+            engineRemoveChild(this.engineNode, child.engineNode);
+            this.surface?.requestCommit();
+        }
+        return child;
+    }
+    set textContent(value) {
+        for (const child of this.children.slice())
+            this.removeChild(child);
+        if (value !== '') {
+            this.appendChild(shimDocument().createTextNode(value));
+        }
+    }
+    insertOne(node, ref) {
+        detachFromParent(node);
+        node.parent = this;
+        if (ref === null) {
+            this.children.push(node);
+        }
+        else {
+            const index = this.children.indexOf(ref);
+            this.children.splice(index < 0 ? this.children.length : index, 0, node);
+        }
+        if (this.engineNode !== undefined && this.surface !== undefined) {
+            const engineNode = node.makeLive(this.surface);
+            const refEngineNode = ref?.engineNode;
+            if (ref !== null && refEngineNode !== undefined) {
+                engineInsertBefore(this.engineNode, engineNode, refEngineNode);
+            }
+            else {
+                engineAppendChild(this.engineNode, engineNode);
+            }
+            this.surface.requestCommit();
+        }
+    }
+}
+// `Node.prototype.firstChild` / `nextSibling` MUST be real prototype getters, not
+// instance own-properties — `init_operations()` extracts their descriptors once and calls
+// `getter.call(node)` for every node afterward (svelte-adapter-dom-shim skill §3a/§3c).
+Object.defineProperty(ShimNode.prototype, 'firstChild', {
+    configurable: true,
+    get() {
+        return this.children[0] ?? null;
+    },
+});
+Object.defineProperty(ShimNode.prototype, 'nextSibling', {
+    configurable: true,
+    get() {
+        if (this.parent === null)
+            return null;
+        const siblings = this.parent.children;
+        const index = siblings.indexOf(this);
+        return index < 0 ? null : (siblings[index + 1] ?? null);
+    },
+});
+// Unlinking a node from its parent must unlink the ENGINE node too, or the shim tree and the
+// native tree disagree: the shim thinks the node is gone while Fabric keeps painting it.
+//
+// The case that makes this load-bearing is a LIVE node moved into an OFFSCREEN
+// `DocumentFragment`. In real DOM, `fragment.append(liveNode)` takes the node out of the
+// document; here the fragment has no engine node of its own, so `insertOne`'s engine half is
+// skipped entirely and this is the only chance to detach. Svelte does exactly that move in
+// three places (§17): `dom/blocks/branches.js` (an onscreen branch parked for a later batch),
+// `dom/blocks/each.js` (`destroy_effects` preserving an item a pending batch still needs), and
+// `dom/blocks/boundary.js`'s `#render` (`move_effect` while a `pending` snippet shows). Without
+// this the parked subtree stays committed underneath whatever replaced it — silent, since
+// nothing throws and a smoke that only checks "is my new content there" still passes.
+//
+// A live->live move (a keyed `{#each}` reorder) reaches this too and is unaffected in outcome:
+// the engine's own `appendChild`/`insertBefore` already detach first, so removing here just
+// makes the same unlink explicit and earlier.
+function detachFromParent(node) {
+    const parent = node.parent;
+    if (parent === null)
+        return;
+    const index = parent.children.indexOf(node);
+    if (index >= 0)
+        parent.children.splice(index, 1);
+    node.parent = null;
+    const parentEngineNode = parent.engineNode;
+    const engineNode = node.engineNode;
+    if (parentEngineNode === undefined || engineNode === undefined)
+        return;
+    engineRemoveChild(parentEngineNode, engineNode);
+    parent.surface?.requestCommit();
+}
+// A DOM fragment inserts its CHILDREN, not itself, and ends up empty — the rule every
+// mandatory block path (`{#each}`/`{#if}`/`<svelte:boundary>`, §3e) depends on.
+function normalizeInsertable(node) {
+    if (node.isDocumentFragment) {
+        const children = node.children.slice();
+        for (const child of children)
+            detachFromParent(child);
+        node.children.length = 0;
+        return children;
+    }
+    return [node];
+}

package/build/dom-shim/text.d.ts

@@ -0,0 +1,14 @@
+import { type ISymbioteNode } from '@symbiote-native/engine';
+import { ShimNode } from './shim-node';
+export declare class ShimText extends ShimNode {
+    private value;
+    constructor(value: string);
+    get nodeName(): string;
+    get data(): string;
+    set data(next: string);
+    private promoteAnchorToRawText;
+    get nodeValue(): string;
+    set nodeValue(next: string);
+    cloneNode(deep?: boolean): ShimText;
+    createEngineNode(): ISymbioteNode;
+}

package/build/dom-shim/text.js

@@ -0,0 +1,97 @@
+// A text node. Svelte's own rule (not ours to relax): raw text is only valid inside an
+// `RCTText`; content outside one throws at commit time (same restriction the Vue adapter
+// enforces in insert()). See svelte-adapter-dom-shim skill §3b (createTextNode).
+//
+// An EMPTY text node is not text at all — it is one of Svelte's positional ANCHORS, and it must
+// map to an engine anchor, never to a raw text. Svelte's runtime builds every block/component
+// boundary anchor with `create_text()` i.e. `document.createTextNode('')`, while template text
+// always carries at least one character (a dynamic interpolation compiles to `' '` in the
+// from_tree template, then `set_text` overwrites it — verified against the compiled output of
+// `{#each}` + `{...}`), so "empty means anchor" is a sound discriminator, not a heuristic.
+// This mirrors what the Vue adapter's renderer has always done in `createText`
+// (`text === '' ? createAnchor() : createRawText(text)`) — the shim was simply missing it.
+//
+// It matters for three reasons, in ascending order: an anchor-as-raw-text is a REAL extra
+// Fabric shadow node per block/component instance; an empty RCTRawText actually PAINTS in
+// Fabric (the reason Vue's renderer maps it to an anchor rather than an empty text); and a raw
+// text child of a non-Text parent is the invalid "text outside <Text>" shape. Found by
+// native-node-parity.test.ts, which diffs committed native trees against the Vue adapter.
+import { appendChild as engineAppendChild, createAnchor, createRawText, insertBefore as engineInsertBefore, isAnchor, removeChild as engineRemoveChild, setText, } from '@symbiote-native/engine';
+import { ShimNode } from './shim-node.js';
+export class ShimText extends ShimNode {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    get nodeName() {
+        return '#text';
+    }
+    get data() {
+        return this.value;
+    }
+    set data(next) {
+        this.value = next;
+        const node = this.engineNode;
+        if (node === undefined)
+            return; // not live yet — createEngineNode() reads `value` when it is
+        if (!isAnchor(node)) {
+            // Deliberately NOT demoted back to an anchor when `next` is '': a node that once carried
+            // content and is now empty is genuine empty text content, which is what React renders
+            // there too. Demoting would also churn the engine tree on every edit that empties a
+            // binding. Only the promotion direction is special-cased.
+            setText(node, next);
+            this.surface?.requestCommit();
+            return;
+        }
+        if (next === '')
+            return; // an anchor that stays empty stays an anchor
+        this.promoteAnchorToRawText(node, next);
+    }
+    // A node that mounted empty (so became an anchor) has just been given real content. The engine
+    // has no anchor->text conversion — an anchor is a distinct component — so swap the node in
+    // place, keeping sibling order: remove the anchor, insert a raw text at the same position.
+    promoteAnchorToRawText(anchor, value) {
+        const rawText = createRawText(value);
+        const parent = this.parent;
+        const parentEngineNode = parent?.engineNode;
+        if (parent === null || parentEngineNode === undefined) {
+            // Live node under a parent that is not itself live — nothing is committed from here yet,
+            // so swapping the binding is enough; insertion places it when the parent goes live.
+            this.engineNode = rawText;
+            return;
+        }
+        // Anchor before the FIRST live following sibling, mirroring ShimNode.insertOne's own rule:
+        // a not-yet-live sibling contributes no engine node to order against.
+        const index = parent.children.indexOf(this);
+        let reference;
+        for (let i = index + 1; i < parent.children.length; i += 1) {
+            const candidate = parent.children[i]?.engineNode;
+            if (candidate !== undefined) {
+                reference = candidate;
+                break;
+            }
+        }
+        engineRemoveChild(parentEngineNode, anchor);
+        if (reference !== undefined)
+            engineInsertBefore(parentEngineNode, rawText, reference);
+        else
+            engineAppendChild(parentEngineNode, rawText);
+        this.engineNode = rawText;
+        this.surface?.requestCommit();
+    }
+    // Svelte reads/writes both names for a text node depending on the code path.
+    get nodeValue() {
+        return this.value;
+    }
+    set nodeValue(next) {
+        this.data = next;
+    }
+    cloneNode(deep) {
+        void deep; // DOM signature parity only — a text node has no children to deep-clone
+        return new ShimText(this.value);
+    }
+    createEngineNode() {
+        return this.value === '' ? createAnchor() : createRawText(this.value);
+    }
+}

package/build/host-instance.d.ts

@@ -0,0 +1,5 @@
+import { type IHostInstance } from '@symbiote-native/engine';
+import type { ShimElement } from './dom-shim';
+export type { IHostInstance } from '@symbiote-native/engine';
+export declare function hostInstance(shim: ShimElement | null | undefined): IHostInstance | undefined;
+export declare function findNodeHandle(componentOrHandle: ShimElement | number | null | undefined): number | null;

package/build/host-instance.js

@@ -0,0 +1,48 @@
+// findNodeHandle, the Svelte adapter twin of adapters/react/src/host-instance.ts and
+// adapters/vue/src/host-instance/index.ts. RN's "ref/instance -> native reactTag" lookup, the
+// seam imperative-interop libraries (reanimated, gesture-handler, react-navigation) reach
+// through.
+//
+// A Svelte `bind:this={hostShim}` gives back a ShimElement (dom-shim/element.ts), not the raw
+// engine node directly — its `.engineNode` field IS the raw ISymbioteNode once the shim has
+// gone live (undefined before the first commit, same "uncommitted -> null" idempotent shape
+// RN's own findNodeHandle has). The node -> tag resolution itself belongs to the engine
+// (getNativeTag, keyed on the raw node in the commit mirror); this only adapts the
+// Svelte-shaped input (a ShimElement) onto it.
+import { getNativeTag, isSymbioteNode, toPublicInstance, dlog, } from '@symbiote-native/engine';
+// `engineNode` alone does NOT identify a ShimElement: it is declared on the shared ShimNode base
+// (dom-shim/shim-node.ts), so a ShimText / ShimComment / ShimDocumentFragment satisfies it too,
+// and none of those is a host ref an interop library can hand back. `tagName` is ShimElement's
+// own field, so checking it makes the predicate mean what its name says.
+function isShimElement(value) {
+    return typeof value === 'object' && value !== null && 'engineNode' in value && 'tagName' in value;
+}
+// The typed imperative handle (measure/measureInWindow/measureLayout/setNativeProps/focus/blur)
+// a `bind:this` host ref carries — the Svelte twin of a React `ref.current`/Vue template ref
+// already being an `IHostInstance`. `dom-shim/element.ts`'s `createEngineNode()` grafts
+// toPublicInstance onto every host node AT CREATION, so this call is idempotent (its own
+// isHostInstance guard short-circuits); this helper exists only to give app code a correctly
+// TYPED accessor off the SHIM value (`ShimElement`) instead of the bare `.engineNode` field,
+// with no `as` cast at the call site.
+export function hostInstance(shim) {
+    if (shim === null || shim === undefined)
+        return undefined;
+    const node = shim.engineNode;
+    return node !== undefined && isSymbioteNode(node) ? toPublicInstance(node) : undefined;
+}
+export function findNodeHandle(componentOrHandle) {
+    if (componentOrHandle === null || componentOrHandle === undefined)
+        return null;
+    if (typeof componentOrHandle === 'number')
+        return componentOrHandle;
+    if (!isShimElement(componentOrHandle))
+        return null;
+    const node = componentOrHandle.engineNode;
+    if (node !== undefined && isSymbioteNode(node)) {
+        const tag = getNativeTag(node) ?? null;
+        dlog(`findNodeHandle: component=${node.component} tag=${tag}`);
+        return tag;
+    }
+    dlog('findNodeHandle: hostShim not live yet (engineNode undefined)');
+    return null;
+}

package/build/index.d.ts

@@ -0,0 +1,28 @@
+export { mount, unmount } from './render';
+export { AppRegistry, setHostRegistrar } from './modules/app-registry';
+export type { IComponentProvider, IWrapperComponentProvider, IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from './modules/app-registry';
+export { View, Text, ActivityIndicator, Image, ImageBackground, InputAccessoryView, KeyboardAvoidingView, Switch, TextInput, Modal, SafeAreaView, RefreshControl, Pressable, TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, TouchableNativeFeedback, Button, ScrollView, ScrollViewStickyHeader, VirtualizedList, FlatList, VirtualizedSectionList, SectionList, } from './components';
+export type { IViewProps, ITextProps, IActivityIndicatorProps, IImageProps, IImageStatics, IImageBackgroundProps, IInputAccessoryViewProps, IKeyboardAvoidingViewProps, IKeyboardAvoidingBehavior, ISwitchProps, ITextInputProps, ITextInputHandle, IModalProps, ISafeAreaViewProps, IRefreshControlProps, IPressableProps, ITouchableOpacityProps, ITouchableHighlightProps, ITouchableWithoutFeedbackProps, ITouchableNativeFeedbackProps, IButtonProps, IScrollViewProps, IScrollViewHandle, IStickyHeaderComponentProps, IVirtualizedListProps, IVirtualizedListHandle, IFlatListProps, IFlatListHandle, IVirtualizedSectionListProps, ISectionListProps, ISection, } from './components';
+export type { IAccessibilityProps, IAriaProps, IAccessibilityRole, IRole, IAccessibilityStateValue, IAccessibilityValue, IAccessibilityActionInfo, IResponderProps, } from '@symbiote-native/components';
+export { setImageSourceResolver } from '@symbiote-native/components';
+export type { IImageSource, IImageSourceProp, IResizeMode, IImageSize, IImageCacheStatus, IModalAnimationType, IModalPresentationStyle, IModalOrientation, IViewToken, IViewableItemsChangedInfo, IViewabilityConfig, IViewabilityConfigCallbackPair, IPressState, ISwitchTrackColor, INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, IVirtualizedSectionListHandle, IVirtualizedSectionListHandle as ISectionListHandle, ICellLayout, ISeparatorProps, ISeparators, IModalOrientationChangeEvent, IPressableAndroidRippleConfig, IEnterKeyHint, IInputMode, ISubmitBehavior, ITextInputSelection, } from '@symbiote-native/components';
+export { Platform, StyleSheet, PlatformColor, DynamicColorIOS, processColor, setNativeViewConfigSource, setColorProcessor, setDeviceEventSource, PixelRatio, PanResponder, dlog, isDebug, } from '@symbiote-native/engine';
+export type { INativeViewConfig, INativeViewConfigSource, IPixelRatioStatic, ISymbioteEvent, ISymbioteNode, IRootTag, IPanResponderGestureState, IPanResponderCallbacks, IGestureResponderHandlers, IPanResponderInstance, IViewStyle, ITextStyle, IFlexAlign, IFlexJustify, IPlatformStatic, IPlatformOSType, IPlatformConstantsIOS, IPlatformConstantsAndroid, IPlatformSelectSpec, IColorValue, IOpaqueColorValue, IDynamicColorIOSTuple, } 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 { StatusBar } from './modules/status-bar';
+export type { IStatusBarProps, IStatusBarStyle } from './modules/status-bar';
+export { AccessibilityInfo } from './modules/accessibility-info';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from './modules/accessibility-info';
+export { findNodeHandle, hostInstance } from './host-instance';
+export type { IHostInstance } from './host-instance';
+export type { ShimElement } from './dom-shim';
+export { createTunnel, TunnelIn, TunnelOut, type ITunnel } from './create-tunnel';
+export { useWindowDimensions } from './runes/use-window-dimensions.svelte';
+export { useColorScheme } from './runes/use-color-scheme.svelte';
+export { innerWidth, innerHeight, outerWidth, outerHeight, devicePixelRatio } from './runes/window';
+export { orientation, createWidthQuery } from './runes/media-query';
+export type { IOrientation, IWidthQueryBounds } from './runes/media-query';
+export type { IReactiveValue } from './runes/dimensions-value';
+export { normalizeSvelteClass, resolveSvelteClass, type ISvelteClassValue, type IClassMap, type IClassEntry, } from './class-value';
+export { Animated } from './modules/animated';

package/build/index.js

@@ -0,0 +1,77 @@
+// @symbiote-native/svelte: a DOM-shim adapter over @symbiote-native/engine. Stock compiled
+// Svelte output believes it is talking to the real DOM (svelte-adapter-dom-shim skill);
+// underneath, every DOM call routes into the same mutation API every other adapter drives.
+// All Fabric clone-on-write lives in the engine, shared cross-adapter. App code names only
+// @symbiote-native/svelte.
+//
+// Full component parity with React/Vue/Angular landed 2026-08-11 (svelte-adapter-dom-shim
+// skill §15): every `core/components` render function has a fixed tree shape, so no
+// `descriptorToSvelte` bridge was ever needed — each component below is hand-authored Svelte
+// markup mirroring its render-*.ts, reusing only the pure state/render logic. See skill §17/§18
+// for the one open async-exception repro and the honest cross-cutting gap list.
+export { mount, unmount } from './render.js';
+export { AppRegistry, setHostRegistrar } from './modules/app-registry/index.js';
+export { View, Text, ActivityIndicator, Image, ImageBackground, InputAccessoryView, KeyboardAvoidingView, Switch, TextInput, Modal, SafeAreaView, RefreshControl, Pressable, TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, TouchableNativeFeedback, Button, ScrollView, ScrollViewStickyHeader, VirtualizedList, FlatList, VirtualizedSectionList, SectionList, } from './components/index.js';
+// Component-scoped agnostic types that live in @symbiote-native/components but weren't yet
+// threaded through this barrel (parity fix, see React's index.ts lines 55-58, 89, 245-250).
+export { setImageSourceResolver } from '@symbiote-native/components';
+// Pure, framework-agnostic runtime modules — same re-export every other adapter does per
+// CLAUDE.md's <runtime_modules_layering>. PanResponder was missing here (present on
+// React/Vue's own barrels) until 2026-08-12 — a pure engine re-export, no framework glue, so
+// adding it is a one-line parity fix, not new adapter work.
+export { Platform, StyleSheet, PlatformColor, DynamicColorIOS, processColor, setNativeViewConfigSource, setColorProcessor, setDeviceEventSource, PixelRatio, PanResponder, dlog, isDebug, } from '@symbiote-native/engine';
+// Imperative runtime modules: the SAME module every adapter shares, re-exported straight from
+// @symbiote-native/engine so app code names only @symbiote-native/svelte (RN's single import
+// root). Nothing here has a visual or a lifecycle, so there is no Svelte half 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';
+// StatusBar is the one imperative-looking module with a real declarative half: it renders
+// nothing but applies its props via an `$effect` (modules/status-bar/index.svelte).
+export { StatusBar } from './modules/status-bar/index.js';
+export { AccessibilityInfo } from './modules/accessibility-info';
+// findNodeHandle: RN's ref -> native reactTag lookup, the Svelte twin of the React/Vue
+// adapters' own (host-instance.ts / host-instance/index.ts). hostInstance: the typed
+// measure/setNativeProps/focus/blur accessor off a `bind:this` ShimElement ref (see
+// host-instance.ts's header — React/Vue get this for free off a plain ref value; Svelte's ref is
+// a ShimElement wrapper, so it needs its own typed unwrap).
+export { findNodeHandle, hostInstance } from './host-instance.js';
+// The generic Descriptor -> shim-tree bridge (svelte-adapter-dom-shim skill §19) — the Svelte
+// twin of Vue's `descriptorToVue` / React's `descriptorToReact`, which a downstream package
+// wrapping a THIRD-PARTY native view (@symbiote-native/slider, packages/slider/src/svelte) needs
+// to mount a Descriptor whose `type` is a raw, non-`symbiote-`-prefixed Fabric name (e.g.
+// 'RNCSlider'). Deliberately NOT re-exported from THIS barrel: `./index.ts` also re-exports
+// `./components`, real `.svelte` sources, so importing even one unrelated name from here forces
+// the whole `.svelte` module graph to load — fatal under vitest's plain (svelte-plugin-free)
+// transform. Import `@symbiote-native/svelte/native-view-bridge` instead — see that file's
+// header for the full reasoning and native-view-bridge.ts for what else it carries
+// (mount/unmount, for a downstream package's own tests).
+// createTunnel: the Svelte twin of adapters/vue/src/create-tunnel (see create-tunnel/tunnel.ts's
+// header for why the API shape — an explicit `tunnel` prop on TunnelIn/TunnelOut, rather than
+// `tunnel.In`/`tunnel.Out` — deliberately differs from React/Vue). NOTE: React's createPortal has
+// no Svelte (or even Vue) twin — it is react-reconciler's own Fiber-level HostPortal primitive,
+// with no equivalent in a framework with no reconciler; createTunnel is the achievable analog,
+// same scope Vue itself settled on.
+export { createTunnel, TunnelIn, TunnelOut } from './create-tunnel/index.js';
+// useWindowDimensions / useColorScheme: the Svelte twins of React's hooks / Vue's composables —
+// see runes/use-window-dimensions.svelte.ts's header for why this adapter's lifecycle-helper
+// bucket is named `runes/`, not `hooks/`/`composables/`.
+export { useWindowDimensions } from './runes/use-window-dimensions.svelte';
+export { useColorScheme } from './runes/use-color-scheme.svelte';
+// The React Native twins of `svelte/reactivity/window`, which is browser-only and would read
+// `undefined` forever here. Same names, same `.current` shape, engine Dimensions/PixelRatio
+// underneath — see runes/window.ts's header for the two deliberate differences from upstream, and
+// for why `scrollX`/`scrollY`/`screenLeft`/`screenTop` are absent rather than faked.
+export { innerWidth, innerHeight, outerWidth, outerHeight, devicePixelRatio } from './runes/window.js';
+// What replaces `MediaQuery` from `svelte/reactivity`: named exports for the media features RN can
+// actually answer, instead of a class taking a CSS query string it would mostly have to answer
+// `false` to. `(prefers-color-scheme)`'s twin is `useColorScheme()` above. See
+// runes/media-query.ts's header for the argument.
+export { orientation, createWidthQuery } from './runes/media-query.js';
+// The `class` prop's Svelte-flavoured union — a clsx map / array on top of the engine's
+// IClassNameValue — plus the normalizer, for a consumer building a class value in its own
+// helper. See class-value.ts's header for the object-is-a-style vs object-is-a-clsx-map rule.
+export { normalizeSvelteClass, resolveSvelteClass, } from './class-value.js';
+// Animated: the Svelte twin of adapters/vue/src/modules/animated (see modules/animated/index.ts's
+// header for why Animated.View/Text/Image/ScrollView are each their own hand-authored .svelte
+// file rather than a generic createAnimatedComponent() wrap — Svelte has no runtime h()/
+// createElement equivalent a factory could target).
+export { Animated } from './modules/animated/index.js';

package/build/modules/accessibility-info/index.android.d.ts

@@ -0,0 +1,2 @@
+export { AccessibilityInfo } from '@symbiote-native/engine';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from '@symbiote-native/engine';

package/build/modules/accessibility-info/index.android.js

@@ -0,0 +1,4 @@
+// AccessibilityInfo (Android) moved to @symbiote-native/engine. This thin re-export keeps
+// @symbiote-native/svelte's surface identical; Metro selects the engine's accessibility-info.android.ts
+// on an Android host.
+export { AccessibilityInfo } from '@symbiote-native/engine';

package/build/modules/accessibility-info/index.d.ts

@@ -0,0 +1 @@
+export * from './index.ios';

package/build/modules/accessibility-info/index.ios.d.ts

@@ -0,0 +1,2 @@
+export { AccessibilityInfo } from '@symbiote-native/engine';
+export type { IAccessibilityChangeEvent, IAccessibilityChangeEventName, IAccessibilityChangeEventHandler, IAccessibilityAnnouncementFinishedEvent, IAnnounceForAccessibilityOptions, IAccessibilityEventType, } from '@symbiote-native/engine';

package/build/modules/accessibility-info/index.ios.js

@@ -0,0 +1,3 @@
+// AccessibilityInfo (iOS) moved to @symbiote-native/engine. This thin re-export keeps @symbiote-native/svelte's
+// surface identical; Metro selects the engine's accessibility-info.ios.ts on an iOS host.
+export { AccessibilityInfo } from '@symbiote-native/engine';

package/build/modules/accessibility-info/index.js

@@ -0,0 +1,5 @@
+// Base / default AccessibilityInfo: re-exports the iOS build. Metro overrides this with
+// accessibility-info.ios.ts / .android.ts on a real host; under tsx / tsc / web the host
+// config resolves here. Filename is the selector, no Platform.OS read. See
+// shared.ts.
+export * from './index.ios.js';

package/build/modules/animated/AnimatedImage.svelte

@@ -0,0 +1,115 @@
+<script lang="ts" module>
+  // Animated.Image — unlike View/Text, Image.svelte does REAL prop transformation
+  // (buildImageBag: source resolution, resizeMode/tintColor read off style, width/height fold,
+  // alt->accessibility). Hand-authoring a bare pass-through bag here (like AnimatedView/Text)
+  // would silently drop all of that — the exact copy-paste-instead-of-calling bug class the
+  // svelte-adapter-dom-shim skill's §15/§19 already caught on Switch/ActivityIndicator/
+  // TextInput/ImageBackground. So this component calls buildImageBag itself (same as
+  // image/index.svelte), fed with rasterized (reduceProps'd) field values.
+  //
+  // Known, inherited (not Svelte-specific) limitation: the PER-FRAME animated path
+  // (AnimatedProps.update -> setNativeProps) pushes the raw `rest` fields directly, bypassing
+  // buildImageBag's mapping — same as Vue's/React's Animated.Image, since AnimatedProps is
+  // framework-agnostic and has no notion of a component's own prop transform. In practice this
+  // only matters if a non-`style` field (e.g. `source`) is itself animated, which is not a
+  // supported use — animating Image is expected to go through `style` (opacity/transform),
+  // which round-trips correctly since buildImageBag keeps `style` under the same key name.
+  import type { IAnimatedComponentProps } from './animated-component-props';
+
+  export type { IAnimatedComponentProps };
+</script>
+
+<script lang="ts">
+  import {
+    createAnimatedLeafLifecycle,
+    isNativeAnimatedAvailable,
+    reduceProps,
+    readPassthroughStyle,
+  } from '@symbiote-native/engine';
+  import { resolveAccessibilityProps } from '@symbiote-native/components';
+  import type { IAccessibilityProps, IAriaProps, IImageViewProps } from '@symbiote-native/components';
+  import { buildImageBag } from '../../components/image/image-logic';
+  import { createAttachmentsSync } from '../../runes/attachments';
+  import type { ShimElement } from '../../dom-shim';
+
+  let { passthroughAnimatedPropExplicitValues: passthrough, ...rest }: IAnimatedComponentProps =
+    $props();
+
+  let hostShim = $state.raw<ShimElement | null>(null);
+
+  const wantsNative = $derived(passthrough != null && isNativeAnimatedAvailable());
+
+  // Rasterize every field (style's animated entries resolved to plain numbers, any other
+  // animated field to its current value), then re-run Image's own field split + buildImageBag
+  // over the resolved values — the same shape image/index.svelte builds, just fed reduced
+  // values instead of raw $props().
+  const reduced = $derived.by(() => {
+    const resolved = reduceProps(rest);
+    const {
+      source,
+      defaultSource,
+      loadingIndicatorSource,
+      style,
+      resizeMode,
+      tintColor,
+      src,
+      srcSet,
+      alt,
+      width,
+      height,
+      crossOrigin,
+      referrerPolicy,
+      ...imagePassthrough
+    } = resolved;
+    // reduceProps returns a flat Record<string, unknown> — every field above is `unknown`
+    // even though it is, at runtime, exactly the shape IImageViewProps/IAccessibilityProps
+    // declare. Bridging that back into a typed shape without an `as` cast uses the same
+    // `Object.assign(Object.create(null), …)` pattern React's create-animated-component.tsx
+    // already establishes: Object.create(null) types as `any`, so Object.assign's result does
+    // too, and TS allows assigning `any` into a specifically-typed binding.
+    const accessibility: IAccessibilityProps & IAriaProps = Object.assign(
+      Object.create(null),
+      imagePassthrough,
+    );
+    const view: IImageViewProps = Object.assign(Object.create(null), {
+      source,
+      defaultSource,
+      loadingIndicatorSource,
+      style,
+      resizeMode,
+      tintColor,
+      src,
+      srcSet,
+      alt,
+      width,
+      height,
+      crossOrigin,
+      referrerPolicy,
+      passthrough: resolveAccessibilityProps(accessibility),
+    });
+    const bag = buildImageBag(view);
+    const passthroughStyle = readPassthroughStyle(passthrough);
+    if (passthroughStyle !== undefined) {
+      bag.style = bag.style === undefined ? passthroughStyle : [bag.style, passthroughStyle];
+    }
+    return bag;
+  });
+
+  const runtime = createAnimatedLeafLifecycle('AnimatedImage');
+
+  $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-image p={reduced} bind:this={hostShim} />

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

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