@symbiote-native/svelte 0.2.1 → 1.0.0

package/build/components/scroll-view/index.svelte

@@ -85,7 +85,8 @@
   }: IScrollViewProps = $props();
 
   $effect(() => {
-    if (stickyHeaderIndices === undefined || stickyHeaderIndices.length === 0) return;
+    if (stickyHeaderIndices === undefined || stickyHeaderIndices.length === 0)
+      return;
     dlog(
       'ScrollView.stickyHeaderIndices is not auto-honored on Svelte (no index-wrap mechanism — ' +
         'see scroll-view-props.ts KNOWN GAP); compose ScrollViewStickyHeader manually instead',
@@ -103,7 +104,11 @@
   // Plain exported functions on the instance script are what a parent's `bind:this={ref}` sees —
   // the Svelte mechanism for exposing an imperative handle, the twin of React's
   // useImperativeHandle / Vue's expose().
-  export function scrollTo(options?: { x?: number; y?: number; animated?: boolean }): void {
+  export function scrollTo(options?: {
+    x?: number;
+    y?: number;
+    animated?: boolean;
+  }): void {
     handle.scrollTo(options);
   }
   export function scrollToEnd(options?: { animated?: boolean }): void {
@@ -117,7 +122,9 @@
   }
 
   const isHorizontal = $derived(horizontal === true);
-  const hasStickyHeaders = $derived(stickyHeaderIndices !== undefined && stickyHeaderIndices.length > 0);
+  const hasStickyHeaders = $derived(
+    stickyHeaderIndices !== undefined && stickyHeaderIndices.length > 0,
+  );
   const shouldWrapRefreshControl = $derived(
     PLATFORM.refreshControlMode === 'wrap' && refreshControl !== undefined,
   );
@@ -131,7 +138,9 @@
   // style and collapse it to nothing — e.g. App.svelte's `class="screen"` (flex:1) on the
   // top-level ScrollView, which left the wrapper with no height for its content to grow into.
   const layoutSplit = $derived(
-    shouldWrapRefreshControl ? splitLayoutProps([resolveSvelteClass(className), style]) : undefined,
+    shouldWrapRefreshControl
+      ? splitLayoutProps([resolveSvelteClass(className), style])
+      : undefined,
   );
 
   // A single AnimatedValue tracks the scroll offset (RN's _scrollAnimatedValue), allocated once
@@ -161,7 +170,9 @@
   // it solely `if (isFabric)`). Forcing the JS path to keep that listener alive only gives up the
   // native driver, putting the pin on the JS thread — drift on iOS, outright failure on Android
   // (commit debounce 15ms vs iOS's 64ms — render-scroll-sticky.ts).
-  const nativeStickyAvailable = $derived(hasStickyHeaders && isNativeAnimatedAvailable());
+  const nativeStickyAvailable = $derived(
+    hasStickyHeaders && isNativeAnimatedAvailable(),
+  );
 
   // Native sticky-scroll attach (RN attachNativeEvent / _updateAnimatedNodeAttachment) — NOT used
   // for sticky headers (see the comment above); kept for other native-event-attach consumers.
@@ -178,7 +189,9 @@
       : contentContainerStyle,
   );
 
-  const intrinsics = $derived(selectScrollIntrinsics(isHorizontal, resolvedContentContainerStyle));
+  const intrinsics = $derived(
+    selectScrollIntrinsics(isHorizontal, resolvedContentContainerStyle),
+  );
 
   const forwarding = $derived(
     resolveScrollForwarding({
@@ -186,7 +199,8 @@
       nativeStickyAvailable,
       invertStickyHeaders,
       scrollEventThrottle,
-      maintainVisibleContentPosition: passthrough.maintainVisibleContentPosition,
+      maintainVisibleContentPosition:
+        passthrough.maintainVisibleContentPosition,
       snapToAlignment: passthrough.snapToAlignment,
     }),
   );
@@ -220,7 +234,10 @@
       [{ nativeEvent: { contentOffset: { y: scrollAnimatedValue } } }],
       onScroll === undefined
         ? undefined
-        : { listener: (...args: unknown[]) => forwardScrollEvent(onScroll, args) },
+        : {
+            listener: (...args: unknown[]) =>
+              forwardScrollEvent(onScroll, args),
+          },
     );
   });
 
@@ -243,7 +260,9 @@
       // layoutSplit already folded className's resolved value into inner/outer above — forwarding
       // the raw class here too would re-apply its LAYOUT half onto the inner scroll view a second
       // time (on top of the wrapper).
-      ...(className !== undefined && layoutSplit === undefined ? { class: className } : {}),
+      ...(className !== undefined && layoutSplit === undefined
+        ? { class: className }
+        : {}),
       style: scrollStyle,
       onScroll: resolvedScrollHandler,
       onLayout: handleScrollLayout,
@@ -260,7 +279,9 @@
     style: intrinsics.contentStyle,
     collapsable: false,
     ...(forwarding.collapsableChildren ? { collapsableChildren: false } : {}),
-    ...(onContentSizeChange !== undefined ? { onLayout: handleContentLayout } : {}),
+    ...(onContentSizeChange !== undefined
+      ? { onLayout: handleContentLayout }
+      : {}),
   }));
   // See View.svelte's note on `{@attach}`.
   const syncAttachments = createAttachmentsSync();
@@ -270,29 +291,41 @@
 </script>
 
 {#snippet scrollBody()}
-  <!-- Packed edge-to-edge against the next block deliberately (svelte-adapter-dom-shim §16):
-       whitespace BETWEEN two sibling blocks survives clean_nodes as a single-space text node,
-       which here becomes a real RCTRawText child of a scroll view — an invalid Fabric child that
-       fails silently. Do not reformat this join. -->
+  <!-- The gap between these two sibling blocks survives clean_nodes as a ' ' text node, but
+       the shim drops a whitespace-only node whose parent takes no raw text, so it never
+       reaches Fabric (dom-shim/text.ts, svelte-adapter-dom-shim §16b). -->
   {#if !shouldWrapRefreshControl && refreshControl !== undefined}
     <RefreshControl {...refreshControl} />
-  {/if}{#if isHorizontal}
-    <symbiote-horizontal-scroll-content p={contentBag}>{@render children?.()}</symbiote-horizontal-scroll-content>
+  {/if}
+  {#if isHorizontal}
+    <symbiote-horizontal-scroll-content p={contentBag}>
+      {@render children?.()}
+    </symbiote-horizontal-scroll-content>
   {:else}
-    <symbiote-scroll-content p={contentBag}>{@render children?.()}</symbiote-scroll-content>
+    <symbiote-scroll-content p={contentBag}>
+      {@render children?.()}
+    </symbiote-scroll-content>
   {/if}
 {/snippet}
 
 {#if shouldWrapRefreshControl && refreshControl !== undefined}
   <RefreshControl {...refreshControl} style={layoutSplit?.outer}>
     {#if isHorizontal}
-      <symbiote-horizontal-scroll-view p={outerBag} bind:this={hostShim}>{@render scrollBody()}</symbiote-horizontal-scroll-view>
+      <symbiote-horizontal-scroll-view p={outerBag} bind:this={hostShim}>
+        {@render scrollBody()}
+      </symbiote-horizontal-scroll-view>
     {:else}
-      <symbiote-scroll-view p={outerBag} bind:this={hostShim}>{@render scrollBody()}</symbiote-scroll-view>
+      <symbiote-scroll-view p={outerBag} bind:this={hostShim}>
+        {@render scrollBody()}
+      </symbiote-scroll-view>
     {/if}
   </RefreshControl>
 {:else if isHorizontal}
-  <symbiote-horizontal-scroll-view p={outerBag} bind:this={hostShim}>{@render scrollBody()}</symbiote-horizontal-scroll-view>
+  <symbiote-horizontal-scroll-view p={outerBag} bind:this={hostShim}>
+    {@render scrollBody()}
+  </symbiote-horizontal-scroll-view>
 {:else}
-  <symbiote-scroll-view p={outerBag} bind:this={hostShim}>{@render scrollBody()}</symbiote-scroll-view>
+  <symbiote-scroll-view p={outerBag} bind:this={hostShim}>
+    {@render scrollBody()}
+  </symbiote-scroll-view>
 {/if}

package/build/components/scroll-view/sticky-header.svelte

@@ -29,7 +29,8 @@
   //
   // Native-Animated-driven, like React's ScrollViewStickyHeader.js: the pinned translateY rides
   // as the raw AnimatedInterpolation node in style.transform on a real Animated.View
-  // (AnimatedView.svelte), whose `__makeNative()` connects it straight to the native shadow tree,
+  // (createAnimatedComponent(View)), whose `__makeNative()` connects it straight to the native
+  // shadow tree,
   // so once native the pin tracks scroll on the UI thread with zero JS per frame - the
   // interpolation's own .addListener() below only drives the separate debounced
   // `passthroughAnimatedPropExplicitValues` (RN's own hit-testing sync).
@@ -51,9 +52,16 @@
   // why ScrollView/VirtualizedList force `nativeStickyAvailable = false`: the correct bootstrap
   // path, not a workaround.
   import type { IStickyHeaderComponentProps } from './sticky-header-props';
+  import View from '../View.svelte';
+  import { createAnimatedComponent } from '../../modules/animated/create-animated-component';
 
   export type { IStickyHeaderComponentProps };
 
+  // Wrapped here, not imported from modules/animated: that barrel imports ScrollView, which
+  // imports this file, so naming it would close a module cycle. Module scope, so every header
+  // instance shares one component identity.
+  const AnimatedView = createAnimatedComponent(View);
+
   // Diagnostic-only: a module-scope counter so every instance across every ScrollViewStickyHeader
   // in a device log is individually identifiable (see the mount/unmount dlog calls below).
   let stickyHeaderInstanceSeq = 0;
@@ -70,8 +78,13 @@
     type IStickyEffect,
     type IStickyReducerInputs,
   } from '@symbiote-native/components';
-  import { AnimatedValue, Platform, dlog, type AnimatedInterpolation, type ISymbioteEvent } from '@symbiote-native/engine';
-  import AnimatedView from '../../modules/animated/AnimatedView.svelte';
+  import {
+    AnimatedValue,
+    Platform,
+    dlog,
+    type AnimatedInterpolation,
+    type ISymbioteEvent,
+  } from '@symbiote-native/engine';
   import {
     SCROLL_VIEW_STICKY_CONTEXT_KEY,
     type IScrollViewStickyContext,
@@ -91,18 +104,26 @@
   // Resolve the scroll wiring from the parent ScrollView's context when not given explicitly.
   // A fresh standalone AnimatedValue is the fallback for a header used outside a ScrollView
   // (never sticks, but never crashes either).
-  const stickyContext = getContext<IScrollViewStickyContext | undefined>(SCROLL_VIEW_STICKY_CONTEXT_KEY);
+  const stickyContext = getContext<IScrollViewStickyContext | undefined>(
+    SCROLL_VIEW_STICKY_CONTEXT_KEY,
+  );
   $effect(() => {
     if (stickyContext === undefined && scrollAnimatedValueProp === undefined) {
-      dlog('ScrollViewStickyHeader used outside a ScrollView — sticky positioning is a no-op');
+      dlog(
+        'ScrollViewStickyHeader used outside a ScrollView — sticky positioning is a no-op',
+      );
     }
   });
   // svelte-ignore state_referenced_locally -- captured ONCE by identity; it does not change
   // after mount, so re-deriving it would be wrong.
   const scrollAnimatedValue =
-    scrollAnimatedValueProp ?? stickyContext?.scrollAnimatedValue ?? new AnimatedValue(0);
+    scrollAnimatedValueProp ??
+    stickyContext?.scrollAnimatedValue ??
+    new AnimatedValue(0);
   const inverted = $derived(invertedProp ?? stickyContext?.getInverted());
-  const scrollViewHeight = $derived(scrollViewHeightProp ?? stickyContext?.getViewportHeight());
+  const scrollViewHeight = $derived(
+    scrollViewHeightProp ?? stickyContext?.getViewportHeight(),
+  );
 
   // The one folded state cell (RN's scattered useState/useRef collapsed into IStickyHeaderState),
   // mutated in place by reduceSticky. Named `stickyState`, not `state`: a local binding literally
@@ -115,7 +136,10 @@
   // The interpolation node currently bound into style.transform — held by IDENTITY ($state.raw),
   // rebuilt on every 'rebuild-interpolation' effect.
   let animatedTranslateY = $state.raw<AnimatedInterpolation>(
-    scrollAnimatedValue.interpolate({ inputRange: [-1, 0], outputRange: [0, 0] }),
+    scrollAnimatedValue.interpolate({
+      inputRange: [-1, 0],
+      outputRange: [0, 0],
+    }),
   );
   let listenerId: string | undefined;
   let debounceTimer: ReturnType<typeof setTimeout> | undefined;
@@ -139,14 +163,18 @@
           // Detach the old listener, build a fresh interpolation onto the shared scroll value, and
           // wire the settled-value listener (drives ONLY the debounced hit-testing passthrough
           // below — the visible pin rides the native AnimatedProps connection in the markup).
-          if (listenerId !== undefined) animatedTranslateY.removeListener(listenerId);
+          if (listenerId !== undefined)
+            animatedTranslateY.removeListener(listenerId);
           const next = scrollAnimatedValue.interpolate({
             inputRange: effect.inputRange,
             outputRange: effect.outputRange,
           });
-          listenerId = next.addListener(({ value }: { value: number | string }): void => {
-            if (typeof value === 'number') dispatch({ kind: 'animated-tick', value });
-          });
+          listenerId = next.addListener(
+            ({ value }: { value: number | string }): void => {
+              if (typeof value === 'number')
+                dispatch({ kind: 'animated-tick', value });
+            },
+          );
           animatedTranslateY = next;
           break;
         }
@@ -160,7 +188,9 @@
         case 'apply-passthrough':
           // The actual committed translateY — a freeze at a huge/wrong number here is the
           // visible-disappearance symptom to watch for.
-          dlog(`ScrollViewStickyHeader[y=${stickyState.layoutY}] apply-passthrough translateY=${effect.translateY}`);
+          dlog(
+            `ScrollViewStickyHeader[y=${stickyState.layoutY}] apply-passthrough translateY=${effect.translateY}`,
+          );
           version += 1;
           break;
         case 'record-header-y':
@@ -192,8 +222,11 @@
   // Detach the listener + clear the debounce on unmount.
   $effect(() => {
     return (): void => {
-      dlog(`ScrollViewStickyHeader#${instanceId}[y=${stickyState.layoutY}] unmount`);
-      if (listenerId !== undefined) animatedTranslateY.removeListener(listenerId);
+      dlog(
+        `ScrollViewStickyHeader#${instanceId}[y=${stickyState.layoutY}] unmount`,
+      );
+      if (listenerId !== undefined)
+        animatedTranslateY.removeListener(listenerId);
       if (debounceTimer !== undefined) clearTimeout(debounceTimer);
     };
   });
@@ -213,7 +246,7 @@
 
   // The EXPLICIT debounced translateY overrides the committed transform for hit-testing, while
   // `animatedTranslateY` (in the markup below) does the smooth native-driven pin — per RN
-  // ScrollViewStickyHeader.js, and AnimatedView.svelte's own passthroughAnimatedPropExplicitValues
+  // ScrollViewStickyHeader.js, and createAnimatedComponent's own passthroughAnimatedPropExplicitValues
   // contract (readPassthroughStyle).
   const passthroughAnimatedPropExplicitValues = $derived.by(() => {
     void version;

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

@@ -6,7 +6,11 @@
   // (a Svelte `bind:this` on THIS component resolves to whatever THIS component exports, so the
   // wrapper must re-declare + delegate rather than re-exporting the child's exports directly) —
   // the Svelte twin of the React/Vue SectionList.
-  import type { ISectionListProps, ISectionListHandle, ISection } from './section-list-props';
+  import type {
+    ISectionListProps,
+    ISectionListHandle,
+    ISection,
+  } from './section-list-props';
 
   export type { ISectionListProps, ISectionListHandle, ISection };
 </script>
@@ -77,6 +81,7 @@
   footer={props.footer}
   empty={props.empty}
   keyExtractor={props.keyExtractor}
+  getItemLayout={props.getItemLayout}
   stickySectionHeadersEnabled={props.stickySectionHeadersEnabled}
   inverted={props.inverted}
   extraData={props.extraData}

package/build/components/switch/index.svelte

@@ -3,7 +3,7 @@
   // render-only). Reuses the shared logic verbatim (switchReducer / valueFromChange /
   // shouldSnapBack, exactly like React's useReducer + Vue's ref-based reducer wiring) and
   // calls renderSwitch() itself for the prop assembly — its Descriptor is always exactly one
-  // `symbiote-switch` node with zero children (core/components/src/view/render-switch.ts). Root
+  // `symbiote-switch-managed` node with zero children (core/components/src/view/render-switch.ts). Root
   // stays a literal tag (bind:this needs a known tag); `createDescriptorChildrenSync` is still
   // wired for its (always-empty) children, matching every other category-1 component uniformly
   // — the same reason React still routes a childless Switch through descriptorToReact rather
@@ -27,7 +27,11 @@
     valueFromChange,
     renderSwitch,
   } from '@symbiote-native/components';
-  import { dispatchViewCommand, dlog, type ISymbioteEvent } from '@symbiote-native/engine';
+  import {
+    dispatchViewCommand,
+    dlog,
+    type ISymbioteEvent,
+  } from '@symbiote-native/engine';
   import { PLATFORM } from './switch-platform';
   import { createDescriptorChildrenSync } from '../../descriptor-to-svelte';
   import { createAttachmentsSync } from '../../runes/attachments';
@@ -67,7 +71,10 @@
     // accept/reject control via the snap-back effect below — see TextInput's identical
     // mechanism (text-input/index.svelte) for why echoing unconditionally would break that.
     if (onValueChange === undefined) value = next;
-    switchState = switchReducer(switchState, { type: 'native-reported', value: next });
+    switchState = switchReducer(switchState, {
+      type: 'native-reported',
+      value: next,
+    });
   }
 
   // Snap-back: when native reported a value the parent rejected (the value prop did not
@@ -102,7 +109,11 @@
         thumbColor,
         ios_backgroundColor,
         style,
-        passthrough: { ...passthrough, class: className, onChange: handleChange },
+        passthrough: {
+          ...passthrough,
+          class: className,
+          onChange: handleChange,
+        },
       },
       PLATFORM,
     ),
@@ -120,4 +131,4 @@
   });
 </script>
 
-<symbiote-switch p={descriptor.props} bind:this={hostShim} />
+<symbiote-switch-managed p={descriptor.props} bind:this={hostShim} />

package/build/components/text-input/index.svelte

@@ -48,6 +48,10 @@
     setInputFocused,
     setInputBlurred,
     type ISymbioteEvent,
+    type ISymbioteNode,
+    type IMeasureOnSuccess,
+    type IMeasureInWindowOnSuccess,
+    type IMeasureLayoutOnSuccess,
   } from '@symbiote-native/engine';
   import { createDescriptorChildrenSync } from '../../descriptor-to-svelte';
   import { createAttachmentsSync } from '../../runes/attachments';
@@ -89,7 +93,9 @@
   // plain, direct property read on the raw `$props()` proxy. `source` is a closed interface (no
   // index signature), so `Object.keys` + bracket-indexing would need an `as` cast; `Object.entries`
   // falls onto TS's `entries(o: {}): [string, any][]` overload instead, which needs no cast.
-  function forwardProps(source: Omit<ITextInputProps, 'value'>): Record<string, unknown> {
+  function forwardProps(
+    source: Omit<ITextInputProps, 'value'>,
+  ): Record<string, unknown> {
     const resolved = resolveAccessibilityProps(source);
     const result: Record<string, unknown> = {};
     for (const [key, propValue] of Object.entries(resolved)) {
@@ -205,9 +211,17 @@
     if (engineNode === undefined) return;
     if (!shouldCommandText(lastNativeText, currentValue)) return;
     const selStart = rest.selection?.start ?? SELECTION_NONE;
-    const selEnd = rest.selection?.end ?? rest.selection?.start ?? SELECTION_NONE;
-    dlog(`TextInput setTextAndSelection count=${count} text=${JSON.stringify(currentValue)}`);
-    dispatchViewCommand(engineNode, 'setTextAndSelection', [count, currentValue, selStart, selEnd]);
+    const selEnd =
+      rest.selection?.end ?? rest.selection?.start ?? SELECTION_NONE;
+    dlog(
+      `TextInput setTextAndSelection count=${count} text=${JSON.stringify(currentValue)}`,
+    );
+    dispatchViewCommand(engineNode, 'setTextAndSelection', [
+      count,
+      currentValue,
+      selStart,
+      selEnd,
+    ]);
     lastNativeText = currentValue;
   });
 
@@ -217,7 +231,8 @@
   // controlled-write effect above relies on.
   $effect(() => {
     const engineNode = hostShim?.engineNode;
-    if (autoFocused || engineNode === undefined || rest.autoFocus !== true) return;
+    if (autoFocused || engineNode === undefined || rest.autoFocus !== true)
+      return;
     autoFocused = true;
     dlog('TextInput autoFocus -> focus command');
     dispatchViewCommand(engineNode, 'focus', []);
@@ -241,7 +256,12 @@
   export function clear(): void {
     const engineNode = hostShim?.engineNode;
     if (engineNode === undefined) return;
-    dispatchViewCommand(engineNode, 'setTextAndSelection', [mostRecentEventCount, '', 0, 0]);
+    dispatchViewCommand(engineNode, 'setTextAndSelection', [
+      mostRecentEventCount,
+      '',
+      0,
+      0,
+    ]);
     lastNativeText = '';
   }
 
@@ -261,6 +281,43 @@
     ]);
   }
 
+  // The four host-ref methods, FORWARDED to the engine node rather than reimplemented.
+  //
+  // Without them a TextInput ref was poorer than any other host ref in the adapter: every other
+  // primitive hands back a node carrying measure/measureInWindow/measureLayout/setNativeProps, and
+  // this wrapper closed the node behind five methods of its own. The lowered path lost the opposite
+  // four, so the two paths were not "one narrowing the other" but two different surfaces.
+  // `ITextInputHandle` is the union of both halves, and `text-input.smoke.test.ts` derives what this
+  // component must expose from `buildTextInputHandle` — so a method added to core fails here rather
+  // than going missing on whichever path an app happened to take.
+  //
+  // Not typed as `satisfies ITextInputHandle`: these are instance-script exports, so the component's
+  // imperative surface is structurally invisible to the compiler — which is exactly why the test is
+  // the guard here and the type is the guard on React, Angular and Solid.
+  export function measure(callback: IMeasureOnSuccess): void {
+    hostShim?.engineNode?.measure(callback);
+  }
+
+  export function measureInWindow(callback: IMeasureInWindowOnSuccess): void {
+    hostShim?.engineNode?.measureInWindow(callback);
+  }
+
+  export function measureLayout(
+    relativeToNativeNode: ISymbioteNode | number,
+    onSuccess: IMeasureLayoutOnSuccess,
+    onFail?: () => void,
+  ): void {
+    hostShim?.engineNode?.measureLayout(
+      relativeToNativeNode,
+      onSuccess,
+      onFail,
+    );
+  }
+
+  export function setNativeProps(nativeProps: Record<string, unknown>): void {
+    hostShim?.engineNode?.setNativeProps(nativeProps);
+  }
+
   const descriptor = $derived(
     renderTextInput({
       multiline: isMultiline,
@@ -293,8 +350,23 @@
   });
 </script>
 
+<!--
+  The `-managed` tags, matching `renderTextInput`'s intrinsics. They resolve to the SAME native view
+  as the plain ones; the separate spelling is what keeps the host behavior off this node. The machine
+  is registered against `symbiote-text-input` / `…-multiline`, which only the LOWERING transform
+  emits, and this wrapper runs the same lifecycle itself (focus/blur mirror, event counter,
+  controlled write, autoFocus) — so sharing a tag would give one node two owners.
+
+  Written literally rather than as `<svelte:element this={descriptor.type}>` for the reason the
+  header records, which means this pair does NOT follow `render-text-input.ts` on its own: if those
+  intrinsics are renamed again, this file has to move with them. `text-input-tag.test.ts` is what
+  makes that a failing test instead of a silent double-owner.
+-->
 {#if isMultiline}
-  <symbiote-text-input-multiline p={descriptor.props} bind:this={hostShim} />
+  <symbiote-text-input-multiline-managed
+    p={descriptor.props}
+    bind:this={hostShim}
+  />
 {:else}
-  <symbiote-text-input p={descriptor.props} bind:this={hostShim} />
+  <symbiote-text-input-managed p={descriptor.props} bind:this={hostShim} />
 {/if}

package/build/components/text-input/index.svelte.d.ts

@@ -1,12 +1,17 @@
 import type { ITextInputProps } from './text-input-props';
 export type { ITextInputProps };
 export type { ITextInputHandle } from '@symbiote-native/components';
+import { type ISymbioteNode, type IMeasureOnSuccess, type IMeasureInWindowOnSuccess, type IMeasureLayoutOnSuccess } from '@symbiote-native/engine';
 declare const Index: import("svelte").Component<ITextInputProps, {
     focus: () => void;
     blur: () => void;
     clear: () => void;
     isFocused: () => boolean;
     setSelection: (start: number, end: number) => void;
+    measure: (callback: IMeasureOnSuccess) => void;
+    measureInWindow: (callback: IMeasureInWindowOnSuccess) => void;
+    measureLayout: (relativeToNativeNode: ISymbioteNode | number, onSuccess: IMeasureLayoutOnSuccess, onFail?: () => void) => void;
+    setNativeProps: (nativeProps: Record<string, unknown>) => void;
 }, "value">;
 type Index = ReturnType<typeof Index>;
 export default Index;