@symbiote-native/svelte 0.1.0

package/build/components/virtualized-list/index.svelte.d.ts

@@ -0,0 +1,79 @@
+import type { IVirtualizedListProps, IVirtualizedListHandle } from './virtualized-list-props';
+export type { IVirtualizedListProps, IVirtualizedListHandle };
+import { type IScrollViewHandle } from '@symbiote-native/components';
+import { type ISymbioteNode } from '@symbiote-native/engine';
+import { type IVirtualizedListProps as IProps } from './virtualized-list-props';
+declare function $$render<ItemT>(): {
+    props: IProps<ItemT>;
+    exports: {
+        scrollToOffset: (params: {
+            offset: number;
+            animated?: boolean;
+        }) => void;
+        scrollToIndex: (params: {
+            index: number;
+            animated?: boolean;
+            viewOffset?: number;
+            viewPosition?: number;
+        }) => void;
+        scrollToItem: (params: {
+            item: unknown;
+            animated?: boolean;
+            viewPosition?: number;
+        }) => void;
+        scrollToEnd: (params?: {
+            animated?: boolean;
+        }) => void;
+        flashScrollIndicators: () => void;
+        getNativeScrollRef: () => IScrollViewHandle | null;
+        getScrollableNode: () => IScrollViewHandle | null;
+        getScrollResponder: () => IScrollViewHandle | null;
+        getScrollNode: () => ISymbioteNode | null;
+        recordInteraction: () => void;
+    };
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<ItemT> {
+    props(): ReturnType<typeof $$render<ItemT>>['props'];
+    events(): ReturnType<typeof $$render<ItemT>>['events'];
+    slots(): ReturnType<typeof $$render<ItemT>>['slots'];
+    bindings(): "";
+    exports(): {
+        scrollToOffset: (params: {
+            offset: number;
+            animated?: boolean;
+        }) => void;
+        scrollToIndex: (params: {
+            index: number;
+            animated?: boolean;
+            viewOffset?: number;
+            viewPosition?: number;
+        }) => void;
+        scrollToItem: (params: {
+            item: unknown;
+            animated?: boolean;
+            viewPosition?: number;
+        }) => void;
+        scrollToEnd: (params?: {
+            animated?: boolean;
+        } | undefined) => void;
+        flashScrollIndicators: () => void;
+        getNativeScrollRef: () => IScrollViewHandle | null;
+        getScrollableNode: () => IScrollViewHandle | null;
+        getScrollResponder: () => IScrollViewHandle | null;
+        getScrollNode: () => ISymbioteNode | null;
+        recordInteraction: () => void;
+    };
+}
+interface $$IsomorphicComponent {
+    new <ItemT>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<ItemT>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<ItemT>['props']>, ReturnType<__sveltets_Render<ItemT>['events']>, ReturnType<__sveltets_Render<ItemT>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<ItemT>['bindings']>;
+    } & ReturnType<__sveltets_Render<ItemT>['exports']>;
+    <ItemT>(internal: unknown, props: ReturnType<__sveltets_Render<ItemT>['props']> & {}): ReturnType<__sveltets_Render<ItemT>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Index: $$IsomorphicComponent;
+type Index<ItemT> = InstanceType<typeof Index<ItemT>>;
+export default Index;

package/build/components/virtualized-list/virtualized-list-props.d.ts

@@ -0,0 +1,70 @@
+import type { Snippet } from 'svelte';
+import type { IStyleProp, ISymbioteEvent, ISymbioteNode, IViewStyle } from '@symbiote-native/engine';
+import { type IAccessibilityProps, type IAriaProps, type ISeparatorProps, type ISeparators, type IViewabilityConfig, type IViewabilityConfigCallbackPair, type IViewableItemsChangedInfo, type IVirtualizedListHandle } from '@symbiote-native/components';
+import type { ISvelteClassValue } from '../../class-value';
+export type { IVirtualizedListHandle };
+export interface IVirtualizedListProps<ItemT> extends IAccessibilityProps, IAriaProps {
+    data: unknown;
+    getItem: (data: unknown, index: number) => ItemT;
+    getItemCount: (data: unknown) => number;
+    item: Snippet<[{
+        item: ItemT;
+        index: number;
+        separators: ISeparators;
+    }]>;
+    separator?: Snippet<[ISeparatorProps<ItemT>]>;
+    header?: Snippet;
+    footer?: Snippet;
+    empty?: Snippet;
+    keyExtractor?: (item: ItemT, index: number) => string;
+    getItemLayout?: (data: unknown, index: number) => {
+        length: number;
+        offset: number;
+        index: number;
+    };
+    horizontal?: boolean;
+    inverted?: boolean;
+    extraData?: unknown;
+    onEndReached?: (info: {
+        distanceFromEnd: number;
+    }) => void;
+    onEndReachedThreshold?: number;
+    onStartReached?: (info: {
+        distanceFromStart: number;
+    }) => void;
+    onStartReachedThreshold?: number;
+    onRefresh?: () => void;
+    refreshing?: boolean | null;
+    progressViewOffset?: number;
+    onViewableItemsChanged?: (info: IViewableItemsChangedInfo<ItemT>) => void;
+    viewabilityConfig?: IViewabilityConfig;
+    viewabilityConfigCallbackPairs?: IViewabilityConfigCallbackPair<ItemT>[];
+    onScrollToIndexFailed?: (info: {
+        index: number;
+        highestMeasuredFrameIndex: number;
+        averageItemLength: number;
+    }) => void;
+    initialNumToRender?: number;
+    initialScrollIndex?: number;
+    maxToRenderPerBatch?: number;
+    updateCellsBatchingPeriod?: number;
+    windowSize?: number;
+    stickyHeaderIndices?: number[];
+    maintainVisibleContentPosition?: {
+        minIndexForVisible: number;
+        autoscrollToTopThreshold?: number;
+    };
+    onScroll?: (event: ISymbioteEvent) => void;
+    onScrollBeginDrag?: (event: ISymbioteEvent) => void;
+    onScrollEndDrag?: (event: ISymbioteEvent) => void;
+    onMomentumScrollBegin?: (event: ISymbioteEvent) => void;
+    onMomentumScrollEnd?: (event: ISymbioteEvent) => void;
+    scrollEventThrottle?: number;
+    keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
+    keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+    style?: IStyleProp<IViewStyle>;
+    contentContainerStyle?: IStyleProp<IViewStyle>;
+    class?: ISvelteClassValue;
+}
+export type { ISeparators, ISeparatorProps, ISymbioteEvent, ISymbioteNode };
+export declare function pickAccessibilityProps<T extends IAccessibilityProps & IAriaProps>(props: T): IAccessibilityProps;

package/build/components/virtualized-list/virtualized-list-props.js

@@ -0,0 +1,73 @@
+import { resolveAccessibilityProps, } from '@symbiote-native/components';
+// Every IAccessibilityProps field, named explicitly (the object-bag convention this adapter's
+// custom-element host tags require — svelte-adapter-dom-shim skill §3g(c) — forbids a raw
+// `...rest` spread landing on a symbiote-* tag, so this mirrors React's `...accessibilityRest`
+// field-by-field instead of reusing its spread). Shared by every list component (VirtualizedList's
+// own host-bag construction AND FlatList's/VirtualizedSectionList's/SectionList's component-to-
+// component forwarding down to VirtualizedList) so the field list lives in exactly one place.
+// resolveAccessibilityProps folds aria-*/role into their accessibility* twins first (idempotent —
+// calling it twice, once per forwarding hop, is a documented no-op once the aria keys are gone).
+export function pickAccessibilityProps(props) {
+    const resolved = resolveAccessibilityProps(props);
+    const picked = {};
+    if (resolved.testID !== undefined)
+        picked.testID = resolved.testID;
+    if (resolved.nativeID !== undefined)
+        picked.nativeID = resolved.nativeID;
+    if (resolved.accessible !== undefined)
+        picked.accessible = resolved.accessible;
+    if (resolved.accessibilityLabel !== undefined)
+        picked.accessibilityLabel = resolved.accessibilityLabel;
+    if (resolved.accessibilityHint !== undefined)
+        picked.accessibilityHint = resolved.accessibilityHint;
+    if (resolved.accessibilityRole !== undefined)
+        picked.accessibilityRole = resolved.accessibilityRole;
+    if (resolved.accessibilityState !== undefined)
+        picked.accessibilityState = resolved.accessibilityState;
+    if (resolved.accessibilityValue !== undefined)
+        picked.accessibilityValue = resolved.accessibilityValue;
+    if (resolved.accessibilityActions !== undefined)
+        picked.accessibilityActions = resolved.accessibilityActions;
+    if (resolved.accessibilityLabelledBy !== undefined) {
+        picked.accessibilityLabelledBy = resolved.accessibilityLabelledBy;
+    }
+    if (resolved.importantForAccessibility !== undefined) {
+        picked.importantForAccessibility = resolved.importantForAccessibility;
+    }
+    if (resolved.accessibilityLiveRegion !== undefined) {
+        picked.accessibilityLiveRegion = resolved.accessibilityLiveRegion;
+    }
+    if (resolved.screenReaderFocusable !== undefined) {
+        picked.screenReaderFocusable = resolved.screenReaderFocusable;
+    }
+    if (resolved.accessibilityViewIsModal !== undefined) {
+        picked.accessibilityViewIsModal = resolved.accessibilityViewIsModal;
+    }
+    if (resolved.accessibilityElementsHidden !== undefined) {
+        picked.accessibilityElementsHidden = resolved.accessibilityElementsHidden;
+    }
+    if (resolved.accessibilityIgnoresInvertColors !== undefined) {
+        picked.accessibilityIgnoresInvertColors = resolved.accessibilityIgnoresInvertColors;
+    }
+    if (resolved.accessibilityLanguage !== undefined) {
+        picked.accessibilityLanguage = resolved.accessibilityLanguage;
+    }
+    if (resolved.accessibilityRespondsToUserInteraction !== undefined) {
+        picked.accessibilityRespondsToUserInteraction = resolved.accessibilityRespondsToUserInteraction;
+    }
+    if (resolved.accessibilityShowsLargeContentViewer !== undefined) {
+        picked.accessibilityShowsLargeContentViewer = resolved.accessibilityShowsLargeContentViewer;
+    }
+    if (resolved.accessibilityLargeContentTitle !== undefined) {
+        picked.accessibilityLargeContentTitle = resolved.accessibilityLargeContentTitle;
+    }
+    if (resolved.onAccessibilityAction !== undefined)
+        picked.onAccessibilityAction = resolved.onAccessibilityAction;
+    if (resolved.onAccessibilityTap !== undefined)
+        picked.onAccessibilityTap = resolved.onAccessibilityTap;
+    if (resolved.onMagicTap !== undefined)
+        picked.onMagicTap = resolved.onMagicTap;
+    if (resolved.onAccessibilityEscape !== undefined)
+        picked.onAccessibilityEscape = resolved.onAccessibilityEscape;
+    return picked;
+}

package/build/components/virtualized-section-list/index.svelte

@@ -0,0 +1,206 @@
+<script lang="ts" module>
+  // VirtualizedSectionList: sections flattened into one virtualized stream over VirtualizedList.
+  // Each section contributes a header row, its item rows, then a footer row (RN counts 2 per
+  // section); the flattened tagged sequence feeds VirtualizedList as one list, so headers, items,
+  // and footers are all windowed by the same machinery. The flattening, entry keying,
+  // separator-item unwrap, and scrollToLocation mapping are shared verbatim from
+  // @symbiote-native/components; this file wires only Svelte's lifecycle (typed prop inputs +
+  // handle delegation + the per-entry render dispatch) — the Svelte twin of the React/Vue
+  // VirtualizedSectionList.
+  import type {
+    IVirtualizedSectionListProps,
+    IVirtualizedSectionListHandle,
+    ISection,
+  } from './virtualized-section-list-props';
+
+  export type { IVirtualizedSectionListProps, IVirtualizedSectionListHandle, ISection };
+</script>
+
+<script lang="ts" generics="ItemT">
+  import {
+    flattenSections,
+    resolveStickySectionHeaders,
+    scrollLocationToFlatIndex,
+    sectionEntryKey,
+    unwrapEntryItem,
+    type ISectionEntry,
+    type ISeparatorProps,
+    type ISeparators,
+  } from '@symbiote-native/components';
+  import { Platform, dlog, type ISymbioteNode } from '@symbiote-native/engine';
+  import VirtualizedList from '../virtualized-list/index.svelte';
+  import { pickAccessibilityProps } from '../virtualized-list/virtualized-list-props';
+  import type { IVirtualizedListHandle, IScrollViewHandle } from '../virtualized-list/virtualized-list-props';
+  import type { IVirtualizedSectionListProps as IProps } from './virtualized-section-list-props';
+  import { pickAttachmentProps } from '../../runes/attachments';
+
+  let props: IProps<ItemT> = $props();
+
+  let inner = $state.raw<IVirtualizedListHandle | null>(null);
+
+  // Forwarded as a component-prop spread onto the inner VirtualizedList (a compiled Svelte
+  // component, not a symbiote-* host tag — see flat-list/index.svelte's identical comment).
+  const accessibilityProps = $derived(pickAccessibilityProps(props));
+
+  const flattened = $derived.by(() =>
+    flattenSections(props.sections, props.sectionSeparator !== undefined),
+  );
+  const entries = $derived(flattened.entries);
+  const headerIndices = $derived(flattened.headerIndices);
+
+  // RN sticks section headers by default only on iOS; Android does not unless asked.
+  const stickyHeaderIndices = $derived(
+    resolveStickySectionHeaders(props.stickySectionHeadersEnabled, headerIndices, Platform.OS),
+  );
+  // DIAGNOSTIC (2026-08-13, tracking why stickyHeaderIndices comes back undefined on Android
+  // despite the demo passing the bare `stickySectionHeadersEnabled` shorthand): the previous
+  // logging only showed the RESULT (VirtualizedList's own dlog), never the INPUTS this $derived
+  // actually read — isolated verification proved bare-shorthand forwarding through this exact
+  // two-hop generic-component chain works correctly in a standalone repro, so this must show
+  // what differs in the real component tree.
+  $effect(() => {
+    dlog(
+      `VirtualizedSectionList sticky-inputs enabled=${String(props.stickySectionHeadersEnabled)} ` +
+        `platformOS=${Platform.OS} headerIndices=${JSON.stringify(headerIndices)} ` +
+        `resolved=${JSON.stringify(stickyHeaderIndices)}`,
+    );
+  });
+
+  $effect(() => {
+    dlog(
+      `VirtualizedSectionList: ${props.sections.length} sections flattened to ${entries.length} entries`,
+    );
+  });
+
+  function getEntry(_source: unknown, index: number): ISectionEntry<ItemT> {
+    return entries[index];
+  }
+  function getEntryCount(): number {
+    return entries.length;
+  }
+  function entryKeyExtractor(entry: ISectionEntry<ItemT>, index: number): string {
+    return sectionEntryKey(entry, index, props.keyExtractor);
+  }
+
+  function entrySeparatorProps(entryProps: ISeparatorProps<ISectionEntry<ItemT>>): ISeparatorProps<ItemT> {
+    return {
+      ...entryProps,
+      leadingItem: unwrapEntryItem(entryProps.leadingItem),
+      trailingItem: unwrapEntryItem(entryProps.trailingItem),
+    };
+  }
+
+  // ---- imperative handle: scrollToLocation resolves (sectionIndex, itemIndex) to the flattened
+  // entry index and forwards to the inner VirtualizedList; everything else routes straight
+  // through, the Svelte twin of the shared IScrollRoutingHandle tail. ----
+  export function scrollToLocation(params: {
+    sectionIndex: number;
+    itemIndex: number;
+    viewOffset?: number;
+    viewPosition?: number;
+    animated?: boolean;
+  }): void {
+    const flatIndex = scrollLocationToFlatIndex(headerIndices, params.sectionIndex, params.itemIndex);
+    if (flatIndex === undefined) {
+      dlog(`VirtualizedSectionList scrollToLocation: section ${params.sectionIndex} out of range`);
+      return;
+    }
+    dlog(
+      `VirtualizedSectionList scrollToLocation section=${params.sectionIndex} item=${params.itemIndex} -> flat ${flatIndex}`,
+    );
+    inner?.scrollToIndex({
+      index: flatIndex,
+      viewOffset: params.viewOffset,
+      viewPosition: params.viewPosition,
+      animated: params.animated,
+    });
+  }
+  export function flashScrollIndicators(): void {
+    inner?.flashScrollIndicators();
+  }
+  export function getNativeScrollRef(): IScrollViewHandle | null {
+    return inner?.getNativeScrollRef() ?? null;
+  }
+  export function getScrollableNode(): IScrollViewHandle | null {
+    return inner?.getScrollableNode() ?? null;
+  }
+  export function getScrollResponder(): IScrollViewHandle | null {
+    return inner?.getScrollResponder() ?? null;
+  }
+  export function getScrollNode(): ISymbioteNode | null {
+    return inner?.getScrollNode() ?? null;
+  }
+  export function recordInteraction(): void {
+    inner?.recordInteraction();
+  }
+
+  // `{@attach}` arrives as a symbol-keyed prop, which naming individual props below drops.
+  // Re-spread just those onto the inner list, which owns the real host node.
+  const attachments = $derived(pickAttachmentProps(props));
+</script>
+
+{#snippet entryItem({
+  item: entry,
+  index,
+  separators,
+}: {
+  item: ISectionEntry<ItemT>;
+  index: number;
+  separators: ISeparators;
+})}
+  {#if entry.kind === 'header'}
+    {@render props.sectionHeader?.({ section: entry.section })}
+  {:else if entry.kind === 'footer'}
+    {@render props.sectionFooter?.({ section: entry.section })}
+  {:else if entry.kind === 'section-separator'}
+    {@render props.sectionSeparator?.()}
+  {:else}
+    {@render props.item({ item: entry.item, index: entry.itemIndex, section: entry.section, separators })}
+  {/if}
+{/snippet}
+
+{#snippet entrySeparator(entryProps: ISeparatorProps<ISectionEntry<ItemT>>)}
+  {@render props.separator?.(entrySeparatorProps(entryProps))}
+{/snippet}
+
+<VirtualizedList
+  bind:this={inner}
+  {...accessibilityProps}
+  {...attachments}
+  data={entries}
+  getItem={getEntry}
+  getItemCount={getEntryCount}
+  item={entryItem}
+  separator={props.separator ? entrySeparator : undefined}
+  header={props.header}
+  footer={props.footer}
+  empty={props.empty}
+  keyExtractor={entryKeyExtractor}
+  stickyHeaderIndices={stickyHeaderIndices}
+  inverted={props.inverted}
+  extraData={props.extraData}
+  onEndReached={props.onEndReached}
+  onEndReachedThreshold={props.onEndReachedThreshold}
+  onStartReached={props.onStartReached}
+  onStartReachedThreshold={props.onStartReachedThreshold}
+  onRefresh={props.onRefresh}
+  refreshing={props.refreshing}
+  progressViewOffset={props.progressViewOffset}
+  initialNumToRender={props.initialNumToRender}
+  initialScrollIndex={props.initialScrollIndex}
+  maxToRenderPerBatch={props.maxToRenderPerBatch}
+  updateCellsBatchingPeriod={props.updateCellsBatchingPeriod}
+  windowSize={props.windowSize}
+  maintainVisibleContentPosition={props.maintainVisibleContentPosition}
+  onScroll={props.onScroll}
+  onScrollBeginDrag={props.onScrollBeginDrag}
+  onScrollEndDrag={props.onScrollEndDrag}
+  onMomentumScrollBegin={props.onMomentumScrollBegin}
+  onMomentumScrollEnd={props.onMomentumScrollEnd}
+  scrollEventThrottle={props.scrollEventThrottle}
+  keyboardShouldPersistTaps={props.keyboardShouldPersistTaps}
+  keyboardDismissMode={props.keyboardDismissMode}
+  style={props.style}
+  contentContainerStyle={props.contentContainerStyle}
+  class={props.class}
+/>

package/build/components/virtualized-section-list/index.svelte.d.ts

@@ -0,0 +1,57 @@
+import type { IVirtualizedSectionListProps, IVirtualizedSectionListHandle, ISection } from './virtualized-section-list-props';
+export type { IVirtualizedSectionListProps, IVirtualizedSectionListHandle, ISection };
+import { type ISymbioteNode } from '@symbiote-native/engine';
+import type { IScrollViewHandle } from '../virtualized-list/virtualized-list-props';
+import type { IVirtualizedSectionListProps as IProps } from './virtualized-section-list-props';
+declare function $$render<ItemT>(): {
+    props: IProps<ItemT>;
+    exports: {
+        scrollToLocation: (params: {
+            sectionIndex: number;
+            itemIndex: number;
+            viewOffset?: number;
+            viewPosition?: number;
+            animated?: boolean;
+        }) => void;
+        flashScrollIndicators: () => void;
+        getNativeScrollRef: () => IScrollViewHandle | null;
+        getScrollableNode: () => IScrollViewHandle | null;
+        getScrollResponder: () => IScrollViewHandle | null;
+        getScrollNode: () => ISymbioteNode | null;
+        recordInteraction: () => void;
+    };
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<ItemT> {
+    props(): ReturnType<typeof $$render<ItemT>>['props'];
+    events(): ReturnType<typeof $$render<ItemT>>['events'];
+    slots(): ReturnType<typeof $$render<ItemT>>['slots'];
+    bindings(): "";
+    exports(): {
+        scrollToLocation: (params: {
+            sectionIndex: number;
+            itemIndex: number;
+            viewOffset?: number;
+            viewPosition?: number;
+            animated?: boolean;
+        }) => void;
+        flashScrollIndicators: () => void;
+        getNativeScrollRef: () => IScrollViewHandle | null;
+        getScrollableNode: () => IScrollViewHandle | null;
+        getScrollResponder: () => IScrollViewHandle | null;
+        getScrollNode: () => ISymbioteNode | null;
+        recordInteraction: () => void;
+    };
+}
+interface $$IsomorphicComponent {
+    new <ItemT>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<ItemT>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<ItemT>['props']>, ReturnType<__sveltets_Render<ItemT>['events']>, ReturnType<__sveltets_Render<ItemT>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<ItemT>['bindings']>;
+    } & ReturnType<__sveltets_Render<ItemT>['exports']>;
+    <ItemT>(internal: unknown, props: ReturnType<__sveltets_Render<ItemT>['props']> & {}): ReturnType<__sveltets_Render<ItemT>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const Index: $$IsomorphicComponent;
+type Index<ItemT> = InstanceType<typeof Index<ItemT>>;
+export default Index;

package/build/components/virtualized-section-list/virtualized-section-list-props.d.ts

@@ -0,0 +1,62 @@
+import type { Snippet } from 'svelte';
+import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+import type { IAccessibilityProps, IAriaProps, ISection, ISeparatorProps, ISeparators, IVirtualizedSectionListHandle } from '@symbiote-native/components';
+import type { ISvelteClassValue } from '../../class-value';
+export type { ISection, IVirtualizedSectionListHandle };
+export interface IVirtualizedSectionListProps<ItemT> extends IAccessibilityProps, IAriaProps {
+    sections: ReadonlyArray<ISection<ItemT>>;
+    item: Snippet<[
+        {
+            item: ItemT;
+            index: number;
+            section: ISection<ItemT>;
+            separators: ISeparators;
+        }
+    ]>;
+    sectionHeader?: Snippet<[{
+        section: ISection<ItemT>;
+    }]>;
+    sectionFooter?: Snippet<[{
+        section: ISection<ItemT>;
+    }]>;
+    sectionSeparator?: Snippet;
+    separator?: Snippet<[ISeparatorProps<ItemT>]>;
+    header?: Snippet;
+    footer?: Snippet;
+    empty?: Snippet;
+    keyExtractor?: (item: ItemT, index: number) => string;
+    stickySectionHeadersEnabled?: boolean;
+    extraData?: unknown;
+    onEndReached?: (info: {
+        distanceFromEnd: number;
+    }) => void;
+    onEndReachedThreshold?: number;
+    onStartReached?: (info: {
+        distanceFromStart: number;
+    }) => void;
+    onStartReachedThreshold?: number;
+    onRefresh?: () => void;
+    refreshing?: boolean | null;
+    progressViewOffset?: number;
+    initialNumToRender?: number;
+    initialScrollIndex?: number;
+    maxToRenderPerBatch?: number;
+    updateCellsBatchingPeriod?: number;
+    windowSize?: number;
+    inverted?: boolean;
+    maintainVisibleContentPosition?: {
+        minIndexForVisible: number;
+        autoscrollToTopThreshold?: number;
+    };
+    onScroll?: (event: ISymbioteEvent) => void;
+    onScrollBeginDrag?: (event: ISymbioteEvent) => void;
+    onScrollEndDrag?: (event: ISymbioteEvent) => void;
+    onMomentumScrollBegin?: (event: ISymbioteEvent) => void;
+    onMomentumScrollEnd?: (event: ISymbioteEvent) => void;
+    scrollEventThrottle?: number;
+    keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
+    keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+    style?: IStyleProp<IViewStyle>;
+    contentContainerStyle?: IStyleProp<IViewStyle>;
+    class?: ISvelteClassValue;
+}

package/build/components/virtualized-section-list/virtualized-section-list-props.js

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

package/build/create-tunnel/index.d.ts

@@ -0,0 +1,3 @@
+export { createTunnel, type ITunnel } from './tunnel';
+export { default as TunnelIn } from './tunnel-in.svelte';
+export { default as TunnelOut } from './tunnel-out.svelte';

package/build/create-tunnel/index.js

@@ -0,0 +1,3 @@
+export { createTunnel } from './tunnel.js';
+export { default as TunnelIn } from './tunnel-in.svelte';
+export { default as TunnelOut } from './tunnel-out.svelte';

package/build/create-tunnel/tunnel-in.svelte

@@ -0,0 +1,24 @@
+<script lang="ts">
+  // Registers the default `children` snippet under `tunnel` — mount this anywhere, any surface.
+  // See tunnel.ts's header for why `tunnel` is an explicit prop rather than an `<In>` closured
+  // per createTunnel() call the way React/Vue's is.
+  import type { Snippet } from 'svelte';
+  import type { ITunnel } from './tunnel';
+
+  let { tunnel, children }: { tunnel: ITunnel; children: Snippet } = $props();
+
+  // Reserved once at component init (stable for this instance's whole lifetime), not inside the
+  // effect — an effect re-running (e.g. because `children` changed) must update the SAME
+  // registry slot, never mint a new id and leave the old one orphaned.
+  const id = tunnel.reserveId();
+
+  $effect(() => {
+    // Reads `children` — re-runs (updating the same slot) if the caller passes a new snippet
+    // reference; the common case (a stable inline snippet whose CLOSED-OVER values change) needs
+    // no re-run at all, since re-rendering happens naturally where TunnelOut renders it.
+    tunnel.items.set(id, children);
+    return () => {
+      tunnel.items.delete(id);
+    };
+  });
+</script>

package/build/create-tunnel/tunnel-in.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import type { ITunnel } from './tunnel';
+type $$ComponentProps = {
+    tunnel: ITunnel;
+    children: Snippet;
+};
+declare const TunnelIn: import("svelte").Component<$$ComponentProps, {}, "">;
+type TunnelIn = ReturnType<typeof TunnelIn>;
+export default TunnelIn;

package/build/create-tunnel/tunnel-out.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+  // Renders everything currently tunneled in, in registration order. Mount this in the
+  // component that should actually paint the content. `tunnel.items` is a SvelteMap
+  // (svelte/reactivity) — iterating it here inside the template is a tracked read, so this
+  // re-renders whenever TunnelIn adds/updates/removes an entry, on whichever surface THIS
+  // component happens to be mounted on.
+  import type { ITunnel } from './tunnel';
+
+  let { tunnel }: { tunnel: ITunnel } = $props();
+</script>
+
+{#each tunnel.items as [id, snippet] (id)}
+  {@render snippet()}
+{/each}

package/build/create-tunnel/tunnel-out.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { ITunnel } from './tunnel';
+type $$ComponentProps = {
+    tunnel: ITunnel;
+};
+declare const TunnelOut: import("svelte").Component<$$ComponentProps, {}, "">;
+type TunnelOut = ReturnType<typeof TunnelOut>;
+export default TunnelOut;

package/build/create-tunnel/tunnel.d.ts

@@ -0,0 +1,9 @@
+import type { Snippet } from 'svelte';
+import { SvelteMap } from 'svelte/reactivity';
+export interface ITunnel {
+    /** The shared registry TunnelIn writes into and TunnelOut reads from. */
+    readonly items: SvelteMap<number, Snippet>;
+    /** A fresh, stable id for one TunnelIn instance to key its registry entry by. */
+    reserveId(): number;
+}
+export declare function createTunnel(): ITunnel;

package/build/create-tunnel/tunnel.js

@@ -0,0 +1,9 @@
+import { SvelteMap } from 'svelte/reactivity';
+export function createTunnel() {
+    const items = new SvelteMap();
+    let nextId = 0;
+    return {
+        items,
+        reserveId: () => nextId++,
+    };
+}

package/build/descriptor-to-svelte.d.ts

@@ -0,0 +1,7 @@
+import type { IDescriptorChild } from '@symbiote-native/components';
+import type { ShimElement } from './dom-shim';
+export type IDescriptorChildrenMount = {
+    update(children: IDescriptorChild[]): void;
+};
+export declare function mountDescriptorChildren(parent: ShimElement, children: IDescriptorChild[]): IDescriptorChildrenMount;
+export declare function createDescriptorChildrenSync(): (hostShim: ShimElement | null, children: IDescriptorChild[]) => void;