@symbiote-native/vue 0.3.8 → 0.4.0

package/build/components/switch/shared.js

@@ -1,14 +1,12 @@
-// Switch, the Vue lifecycle half. The logic (the lastNativeReport reducer, valueFromChange,
-// the snap-back decision) lives in @symbiote-native/components/state and the render in
-// @symbiote-native/components/view, both shared verbatim with the React adapter. Here Vue supplies
-// the reactivity: a ref holds what native last reported, a function ref grabs the host node,
-// and a post-flush watch snaps native back when the parent rejects a toggle. This is the Vue
-// twin of the React adapter's useReducer + useLayoutEffect + dispatchViewCommand.
+// Switch, the Vue lifecycle half. The logic (lastNativeReport reducer, valueFromChange, the
+// snap-back decision) lives in @symbiote-native/components/state and the render in
+// @symbiote-native/components/view, both shared verbatim with React. Vue supplies the
+// reactivity: a ref holds what native last reported, a function ref grabs the host node, and a
+// post-flush watch snaps native back when the parent rejects a toggle.
 //
-// Inputs arrive as attrs (untyped), so each is narrowed with a runtime guard rather than a
-// cast. onValueChange MUST be stripped from the forwarded attrs: it is not a ViewConfig event
-// (it's derived from the native onChange), so leaking it would reach Fabric as a function prop
-// and crash Android's folly::dynamic.
+// Inputs arrive as attrs (untyped), so each is narrowed with a runtime guard, never a cast.
+// onValueChange MUST be stripped from the forwarded attrs: it is not a ViewConfig event, so
+// leaking it would reach Fabric as a function prop and crash Android's folly::dynamic.
 import { defineComponent, ref, shallowRef, watch } from '@vue/runtime-core';
 import { renderSwitch, switchReducer, createInitialSwitchState, shouldSnapBack, valueFromChange, } from '@symbiote-native/components';
 import { dispatchViewCommand, isSymbioteNode, dlog, } from '@symbiote-native/engine';
@@ -24,7 +22,6 @@ function asString(value) {
 function isBoolean(value) {
     return typeof value === 'boolean';
 }
-// trackColor arrives untyped; keep only the string false/true entries the render fn reads.
 function normalizeTrackColor(value) {
     if (!isRecord(value))
         return undefined;
@@ -36,12 +33,11 @@ function normalizeTrackColor(value) {
     return trackColor;
 }
 // The render fn's style param is a plain object; array/registered styles degrade to undefined
-// (the engine flattens those on its own). Same narrowing the Vue ActivityIndicator uses.
+// (the engine flattens those on its own).
 function isViewStyleObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-// The prop/handler keys the lifecycle consumes itself; everything else (accessibility,
-// testID, …) forwards onto the host node. onValueChange is pure JS and must never reach Fabric.
+// Everything else forwards onto the host node. onValueChange is pure JS and must never reach Fabric.
 const HANDLED_ATTRS = [
     'value',
     'modelValue',
@@ -62,22 +58,15 @@ function forwardAttrs(attrs) {
 }
 export function createSwitch(platform) {
     return defineComponent((_props, { attrs: rawAttrs, emit }) => {
-        // shallowRef, NOT ref: the engine node must be held by IDENTITY. A plain ref() runs the
-        // assigned object through Vue's toReactive(), so reading nodeRef.value back yields a
-        // reactive Proxy, a different object than the raw node. The engine's mirror is a WeakMap
-        // keyed on the raw node, so every imperative command (dispatchViewCommand / measure /
-        // setNativeProps) would miss on the Proxy and silently no-op. shallowRef stores the raw
-        // node untouched. General rule for this adapter: host nodes live in shallowRef / markRaw.
+        // shallowRef, NOT ref: a plain ref() would hand back a reactive Proxy the engine's WeakMap
+        // mirror doesn't recognize, so every imperative command would silently no-op. General rule
+        // for this adapter: host nodes live in shallowRef / markRaw.
         const nodeRef = shallowRef(null);
         const state = ref(createInitialSwitchState());
-        // The host node our Vue renderer creates IS an engine SymbioteNode; Vue hands it to this
-        // function ref on mount. A stable function ref (defined once) isn't re-invoked per patch.
         const setNodeRef = (el) => {
             nodeRef.value = isSymbioteNode(el) ? el : null;
         };
         const handleChange = (event) => {
-            // Vue-facing event is emitted here; the host still receives this internal onChange
-            // handler so the controlled snap-back state stays synchronized with native.
             const next = valueFromChange(event);
             dlog(`Switch onChange value=${String(next)} eventCount=${String(event.nativeEvent.eventCount)}`);
             if (next === undefined)
@@ -86,11 +75,10 @@ export function createSwitch(platform) {
             emitModelUpdate(emit, next);
             state.value = switchReducer(state.value, { type: 'native-reported', value: next });
         };
-        // Snap-back: when native reported a value the parent rejected (the value prop did not
-        // change), command the JS value back down: the controlled-Switch correction RN does via
-        // SwitchCommands.setValue. The decision is shared with React (shouldSnapBack); only the
-        // command name is platform-imperative. flush:'post' so the engine has committed the node
-        // before the command reads its Fabric handle.
+        // Snap-back: when native reported a value the parent rejected, command the JS value back
+        // down (the controlled-Switch correction RN does via SwitchCommands.setValue). The
+        // decision is shared with React (shouldSnapBack); only the command name is platform-
+        // imperative. flush:'post' so the node is committed before the command reads its Fabric handle.
         watch(() => ({
             fabricValue: resolveModelValue(rawAttrs, isBoolean) === true,
             switchState: state.value,

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

@@ -1,17 +1,13 @@
-// TextInput, the Vue lifecycle half. The folds/maps (value->text, the W3C/alias resolution)
-// and the controlled-write predicate live in @symbiote-native/components/state, the render (intrinsic
-// + native-prop mapping) in @symbiote-native/components/view, both shared verbatim with the React
-// adapter. Here Vue supplies only the reactivity: a shallowRef holds the host node, a ref holds
-// the acknowledged event count (so the exposed handle echoes the latest), setup-scope `let`s
-// hold the last native text + focus flag, a post-flush watch runs the controlled-write command,
-// and expose() wires the imperative handle. The Vue twin of the React useState/useRef +
-// useLayoutEffect + useImperativeHandle.
+// TextInput, the Vue lifecycle half. The folds/maps (value->text, W3C/alias resolution) and the
+// controlled-write predicate live in @symbiote-native/components/state, the render in
+// @symbiote-native/components/view, both shared verbatim with React. Vue supplies only the
+// reactivity: a shallowRef holds the host node, a ref holds the acknowledged event count, setup-
+// scope `let`s hold the last native text + focus flag, a post-flush watch runs the
+// controlled-write command, and expose() wires the imperative handle.
 //
-// Inputs arrive as attrs (untyped), so each is narrowed with a runtime guard rather than a cast.
-// onValueChange MUST be stripped from the forwarded attrs: it is not a ViewConfig event (it's
-// derived from the native onChange), so leaking it would reach Fabric as a function prop and
-// crash Android's folly::dynamic. The imperative module (blurTextInput / setInput*) is imported
-// from @symbiote-native/engine, the same framework-agnostic singleton both adapters share.
+// Inputs arrive as attrs (untyped), so each is narrowed with a runtime guard, never a cast.
+// onValueChange MUST be stripped from the forwarded attrs: it is not a ViewConfig event, so
+// leaking it would reach Fabric as a function prop and crash Android's folly::dynamic.
 import { defineComponent, onBeforeUnmount, ref, shallowRef, watch } from '@vue/runtime-core';
 import { resolveAccessibilityProps, resolveTextInputProps, renderTextInput, foldText, textFromChange, eventCountFromChange, shouldCommandText, INITIAL_EVENT_COUNT, SELECTION_NONE, } from '@symbiote-native/components';
 import { dispatchViewCommand, isSymbioteNode, dlog, blurTextInput, setInputFocused, setInputBlurred, whenCommitted, } from '@symbiote-native/engine';
@@ -30,7 +26,6 @@ function isString(value) {
 function asBoolean(value) {
     return typeof value === 'boolean' ? value : undefined;
 }
-// selection arrives untyped; keep only the numeric start/end the render fn + controlled write read.
 function normalizeSelection(value) {
     if (!isRecord(value))
         return undefined;
@@ -41,9 +36,7 @@ function normalizeSelection(value) {
         selection.end = value.end;
     return selection;
 }
-// The prop/handler keys the lifecycle consumes itself (mirrors the React adapter's destructure);
-// everything else (placeholder, secureTextEntry, the remaining native events, accessibility,
-// testID, style…) forwards onto the host node. onFocus/onBlur are re-supplied as our wrapped
+// Everything else forwards onto the host node. onFocus/onBlur are re-supplied as our wrapped
 // handlers; onValueChange is pure JS and must never reach Fabric.
 const HANDLED_ATTRS = [
     'value',
@@ -80,38 +73,30 @@ function forwardAttrs(attrs) {
     return result;
 }
 export const TextInput = defineComponent((_props, { attrs: rawAttrs, emit, expose }) => {
-    // shallowRef, NOT ref: the engine node must be held by IDENTITY. A plain ref() runs the node
-    // through Vue's toReactive(), handing back a reactive Proxy, a different object than the raw
-    // node the engine's WeakMap mirror is keyed on, so every imperative command
-    // (dispatchViewCommand / focus / blur / setTextAndSelection) would miss and silently no-op.
-    // Same rule applies to the Switch / ScrollView host node.
+    // shallowRef, NOT ref: a plain ref() would hand back a reactive Proxy the engine's WeakMap
+    // mirror doesn't recognize, so every imperative command would silently no-op. Same rule as
+    // the Switch / ScrollView host node.
     const nodeRef = shallowRef(null);
     const setNodeRef = (el) => {
         nodeRef.value = isSymbioteNode(el) ? el : null;
     };
-    // The count native last acknowledged. A ref so the render echoes it back as
-    // mostRecentEventCount and the exposed handle reads the latest; the controlled write commands
-    // it so native's eventLag lands on 0.
+    // The count native last acknowledged. A ref so render echoes it as mostRecentEventCount; the
+    // controlled write commands it so native's eventLag lands on 0.
     const mostRecentEventCount = ref(INITIAL_EVENT_COUNT);
-    // The last text native holds, as far as JS knows. Seeded from the mount-time value (the `text`
-    // prop already carries it down via createNode, so the FIRST controlled value is not a
-    // divergence and must NOT re-command). A setup-scope `let`: no render needed when it changes.
+    // Seeded from the mount-time value (the `text` prop already carries it down via createNode,
+    // so the FIRST controlled value is not a divergence and must NOT re-command).
     let lastNativeText = foldText(resolveModelValue(rawAttrs, isString), asString(rawAttrs.defaultValue));
-    // JS-side focus state, mirrored from the focus/blur events for isFocused(): native exposes no
-    // synchronous focus getter (RN's TextInputState holds the same).
+    // Mirrored from focus/blur events for isFocused(): native exposes no synchronous focus getter.
     let focused = false;
-    // autoFocus fires once when the node first commits; guard so a later node identity change does
-    // not re-focus.
+    // Guard so a later node identity change does not re-focus.
     let autoFocused = false;
     const handleChange = (event) => {
-        // Event seam: the controlled handshake hinges on the change payload carrying `text`
-        // (+ `eventCount`). iOS and Android Fabric can key these differently, so log the actual shape.
+        // iOS and Android Fabric can key the change payload differently, so log the actual shape.
         dlog(`TextInput change keys=[${Object.keys(event.nativeEvent).join(',')}] ` +
             `text=${JSON.stringify(event.nativeEvent.text)} count=${JSON.stringify(event.nativeEvent.eventCount)}`);
         const text = textFromChange(event);
         if (text !== undefined) {
-            // Record the text first, then the count, so the count never runs ahead of the text it
-            // stands for.
+            // Record the text first, so the count never runs ahead of the text it stands for.
             lastNativeText = text;
             emit('valueChange', text, event);
             emitModelUpdate(emit, text);
@@ -136,10 +121,8 @@ export const TextInput = defineComponent((_props, { attrs: rawAttrs, emit, expos
         emit('blur', event);
     };
     // Controlled write: when JS-side `value` diverges from what native reported, command the new
-    // text down with the acknowledged count; a plain prop re-push would race the user's
-    // keystrokes. Watching `value` covers every divergence (the parent only rewrites `value` after
-    // a change). flush:'post' so the engine has committed the node before the command reads its
-    // Fabric handle; the predicate makes it a no-op on mount (value === the seed).
+    // text down with the acknowledged count - a plain prop re-push would race the user's
+    // keystrokes. flush:'post' so the node is committed before the command reads its Fabric handle.
     watch(() => resolveModelValue(rawAttrs, isString), value => {
         const node = nodeRef.value;
         if (node === null)
@@ -158,11 +141,10 @@ export const TextInput = defineComponent((_props, { attrs: rawAttrs, emit, expos
         ]);
         lastNativeText = value;
     }, { flush: 'post' });
-    // autoFocus is driven in JS, not as a native prop: once the node first commits, command `focus`
-    // down once (RN does the same via TextInputState.focusInput). The watch fires when nodeRef is
-    // set (mount), but under Vue's async-batched commit the node has no Fabric tag yet at post-flush,
-    // so the focus command would be skipped with no retry. whenCommitted defers it to the commit that
-    // assigns the tag. Cancelled on unmount so an un-committed pending focus can't leak.
+    // autoFocus is driven in JS: once the node first commits, command `focus` down once. Under
+    // Vue's async-batched commit the node has no Fabric tag yet at post-flush, so
+    // whenCommitted defers it to the commit that assigns the tag. Cancelled on unmount so an
+    // un-committed pending focus can't leak.
     let cancelAutoFocus;
     watch(nodeRef, node => {
         if (autoFocused || node === null || rawAttrs.autoFocus !== true)
@@ -172,10 +154,8 @@ export const TextInput = defineComponent((_props, { attrs: rawAttrs, emit, expos
         cancelAutoFocus = whenCommitted(node, () => dispatchViewCommand(node, 'focus', []));
     }, { flush: 'post' });
     onBeforeUnmount(() => cancelAutoFocus?.());
-    // The imperative API RN exposes on the ref. The methods read nodeRef.value / the count LIVE,
-    // so no stale capture: the Vue twin of React's useImperativeHandle. focus/blur drive native
-    // view commands; clear and setSelection reuse setTextAndSelection (the same stale-safe path as
-    // a controlled write) echoing the acknowledged event count.
+    // Methods read nodeRef.value / the count LIVE, so no stale capture. clear/setSelection reuse
+    // setTextAndSelection, the same path as a controlled write.
     expose({
         focus: () => {
             const node = nodeRef.value;

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

@@ -477,8 +477,9 @@ export const VirtualizedList = defineComponent((props, { attrs, expose, emit, sl
                     ? INVERTED_X_STYLE
                     : INVERTED_Y_STYLE
                 : undefined;
-            for (let cellPos = 0; cellPos < plan.cells.length; cellPos += 1) {
-                const cell = plan.cells[cellPos];
+            // Wraps one cell identically whether it's the force-mounted sticky cell ahead of the
+            // window or an in-window cell from the loop below — same measuring View, same key shape.
+            const pushCell = (cell) => {
                 const item = p.getItem(p.data, cell.index);
                 const content = p.renderItem?.({
                     item,
@@ -490,8 +491,24 @@ export const VirtualizedList = defineComponent((props, { attrs, expose, emit, sl
                     onLayout: makeCellMeasure(cell.index),
                     style: cellInverted,
                 }, [content]));
+            };
+            // The nearest sticky section header below the window (RN _ensureClosestStickyHeader):
+            // force-mounted so it never gets destroyed/recreated while pinned off-window. Rendered
+            // ahead of the main window loop, with its own gap spacer to the window's first cell.
+            if (plan.forcedStickyCell !== undefined) {
+                pushCell(plan.forcedStickyCell);
+                if (plan.gapExtent > EMPTY_OFFSET) {
+                    children.push(h('symbiote-view', {
+                        key: 'spacer-gap',
+                        style: p.horizontal ? { width: plan.gapExtent } : { height: plan.gapExtent },
+                    }));
+                }
+            }
+            for (let cellPos = 0; cellPos < plan.cells.length; cellPos += 1) {
+                const cell = plan.cells[cellPos];
+                pushCell(cell);
                 if (cell.index < m.last) {
-                    const separator = renderSeparatorElement(p.itemSeparatorComponent, item, p.getItem(p.data, cell.index + 1), separatorOverrides.get(cell.index));
+                    const separator = renderSeparatorElement(p.itemSeparatorComponent, p.getItem(p.data, cell.index), p.getItem(p.data, cell.index + 1), separatorOverrides.get(cell.index));
                     if (separator !== undefined) {
                         children.push(h('symbiote-view', { key: `sep-${cell.key}` }, [separator]));
                     }

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

@@ -1,32 +1,26 @@
 // VirtualizedSectionList, the Vue wrapper that flattens sections 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 is fed to VirtualizedList as one list,
-// so headers/items/footers are all windowed by the same machinery. The flattening, entry keying,
-// separator-item unwrap, and scrollToLocation mapping are shared from @symbiote-native/components; this
-// file wires Vue lifecycle (typed-prop inputs + handle re-expose + the per-entry render dispatch).
-// The Vue twin of the React adapter's VirtualizedSectionList.
+// over VirtualizedList: each section contributes a header row, its item rows, then a footer row
+// (RN counts 2 per section), and the flattened tagged sequence is windowed by the same
+// machinery as one list. Flattening, entry keying, separator-item unwrap, and scrollToLocation
+// mapping are shared from @symbiote-native/components; this file wires Vue lifecycle
+// (typed-prop inputs + handle re-expose + per-entry render dispatch).
 //
-// Typed-emits generic component (mirrors FlatList / VirtualizedList): a GENERIC setup function
-// `<ItemT,>(props: IVirtualizedSectionListProps<ItemT>, ctx: ICtx<IVirtualizedSectionListEmits>)`
-// so the section inputs (sections/renderItem/renderSectionHeader/…) infer ItemT at the call site.
-// For that, those inputs are read from typed `props` (declared in the runtime `props` array); the
-// VirtualizedList passthrough tail (refreshing/style/raw scroll/…) rides through `$attrs` onto the
-// inner list. The three adapter-synthesized events (endReached/startReached/refresh — the exact set
-// React's section list exposes) stay GATED on listener presence: each emit bridge is wired ONLY
-// when the consumer listens (read off the instance vnode props), so the inner VirtualizedList keeps
-// building RefreshControl / computing edge-reached strictly on demand.
+// Typed-emits generic component (mirrors FlatList/VirtualizedList): a GENERIC setup function so
+// section inputs infer ItemT at the call site. Those inputs are read from typed `props`
+// (declared in the runtime `props` array); the VirtualizedList passthrough tail rides through
+// $attrs onto the inner list. The three adapter-synthesized events (endReached/startReached/
+// refresh) stay GATED on listener presence so the inner VirtualizedList keeps building
+// RefreshControl / computing edge-reached strictly on demand.
 import { defineComponent, getCurrentInstance, h, shallowRef, } from '@vue/runtime-core';
 import { flattenSections, resolveStickySectionHeaders, scrollLocationToFlatIndex, sectionEntryKey, unwrapEntryItem, } from '@symbiote-native/components';
 import { Platform, dlog, } from '@symbiote-native/engine';
 import { VirtualizedList } from '../virtualized-list/index.js';
 import { normalizeVueAttrs } from '../../utils/normalize-attrs.js';
-// VirtualizedList is a generic component (generic construct signature), which h()'s overloads can't
-// resolve. Drive it through a loose functional-component handle (generic-component h() limitation).
+// VirtualizedList's generic construct signature can't be resolved by h()'s overloads, so drive
+// it through a loose functional-component handle instead.
 const VirtualizedListHost = VirtualizedList;
-// The typed inputs VSL reads off `props`; everything else (the VirtualizedList passthrough tail and
-// raw scroll) falls through $attrs onto the inner list. Listed for the runtime `props` declaration
-// (keyof can't derive it: the index signature widens keyof to `string`). The three emit events are
-// deliberately absent (declared as emits below).
+// Listed for the runtime `props` declaration (keyof can't derive it: the index signature widens
+// keyof to `string`). The three emit events are deliberately absent (declared as emits below).
 const PROP_KEYS = ['sections', 'keyExtractor', 'stickySectionHeadersEnabled'];
 const EMIT_KEYS = ['endReached', 'startReached', 'refresh'];
 function isRecord(value) {
@@ -68,10 +62,8 @@ export const VirtualizedSectionList = defineComponent((props, { attrs, expose, e
     // headerIndices change each render (sections may change); the delegate reads them lazily.
     let headerIndices = [];
     expose(buildSectionDelegate(() => inner.value, () => headerIndices));
-    // The three section-list events are emits, so Vue strips their onX listeners from $attrs. Detect
-    // listener presence off the instance's own vnode props (what the parent passed), exactly like
-    // FlatList/VirtualizedList, so an emit bridge is wired ONLY when the consumer actually listens
-    // (preserving the inner list's RefreshControl / edge-reached gating).
+    // Emits are stripped from $attrs by Vue; detect listener presence off the instance's own
+    // vnode props instead, so an emit bridge is wired ONLY when the consumer actually listens.
     const instance = getCurrentInstance();
     const listens = (onName) => {
         const vnodeProps = instance?.vnode.props;

package/build/components.js

@@ -11,8 +11,6 @@
 import { h } from '@vue/runtime-core';
 import { normalizeVueAttrs } from './utils/normalize-attrs.js';
 function hostComponent(intrinsic, name) {
-    // A functional component's ctx is Omit<SetupContext, 'expose'> (no instance to expose); let the
-    // FunctionalComponent target infer the param types rather than annotate SetupContext.
     // normalizeVueAttrs folds kebab template props (:accessibility-label) to the RN camelCase contract.
     const component = (_props, { slots, attrs }) => h(intrinsic, normalizeVueAttrs(attrs), slots.default !== undefined ? slots.default() : undefined);
     component.displayName = name;
@@ -22,5 +20,5 @@ function hostComponent(intrinsic, name) {
 export const View = hostComponent('symbiote-view', 'View');
 export const Text = hostComponent('symbiote-text', 'Text');
 // Image is NOT a bare host primitive: it needs the shared fold (source/src/srcSet resolution,
-// width/height → style, alt → accessibility) + the Image statics, so it lives in ./image as a
+// width/height -> style, alt -> accessibility) + the Image statics, so it lives in ./image as a
 // functional component over renderImage. View/Text stay bare; they forward attrs verbatim.

package/build/host-instance/index.js

@@ -8,10 +8,8 @@
 // engine so React and Vue share one definition.
 //
 // The node -> tag resolution itself belongs to the engine (getNativeTag, keyed on the raw
-// node in the commit mirror); this only adapts the Vue-shaped inputs onto it. Accepts, in
-// RN's idempotent spirit: a bare number (passes through), an engine host node (a ref's
-// .value), a Vue Ref carrying either (unwrapped), or null / undefined (-> null). An
-// uncommitted or unknown input has no tag yet and surfaces as null.
+// node in the commit mirror); this only unwraps the Vue-shaped inputs (a Ref or a bare node)
+// onto it. An uncommitted or unknown input has no tag yet and surfaces as null.
 import { isRef, toRaw } from '@vue/runtime-core';
 import { getNativeTag, isSymbioteNode, dlog } from '@symbiote-native/engine';
 export function findNodeHandle(componentOrHandle) {

package/build/index.d.ts

@@ -58,8 +58,9 @@ export type { IAlertType, IAlertButtonStyle, IAlertButton, IAlertButtons, IAlert
 export { Platform, StyleSheet, processColor, setColorProcessor, dlog, isDebug, } from '@symbiote-native/engine';
 export type { ISymbioteEvent, ISymbioteNode, IRootTag } from '@symbiote-native/engine';
 export type { IViewStyle, ITextStyle, IFlexAlign, IFlexJustify, IPlatformStatic, IPlatformOSType, IPlatformConstantsIOS, IPlatformConstantsAndroid, IPlatformSelectSpec, } from '@symbiote-native/engine';
-export { setNativeViewConfigSource } from '@symbiote-native/engine';
+export { setNativeViewConfigSource, setDeviceEventSource } from '@symbiote-native/engine';
 export type { INativeViewConfig, INativeViewConfigSource } from '@symbiote-native/engine';
+export type { IEnterKeyHint, IInputMode, ISubmitBehavior, ITextInputSelection, IImageStatics, } from '@symbiote-native/components';
 export { PixelRatio, PanResponder, PlatformColor, DynamicColorIOS, InteractionManager, } from '@symbiote-native/engine';
 export type { IPixelRatioStatic } from '@symbiote-native/engine';
 export type { IPanResponderGestureState, IPanResponderCallbacks, IGestureResponderHandlers, IPanResponderInstance, } from '@symbiote-native/engine';

package/build/index.js

@@ -2,78 +2,43 @@
 // each RendererOptions call onto the engine's mutation API; all Fabric clone-on-write
 // lives in the engine, shared with every other adapter. App code names only @symbiote-native/vue.
 export { mount, unmount } from './render.js';
-// createTunnel: cross-surface content sharing (Teleport stays same-surface-only by design —
-// see create-tunnel.ts for why).
+// Teleport stays same-surface-only by design - see create-tunnel.ts for why.
 export { createTunnel } from './create-tunnel/index.js';
 export { View, Text } from './components.js';
-// findNodeHandle: RN's ref -> native reactTag lookup, the Vue twin of the React adapter's
-// host-instance resolution. IHostInstance is the raw engine node (Vue host refs fall
-// through to it; imperative methods live on each component's expose() handle).
+// IHostInstance is the raw engine node (Vue host refs fall through to it; imperative methods
+// live on each component's expose() handle).
 export { findNodeHandle } from './host-instance/index.js';
-// Image. Full parity with React: source/src/srcSet resolution, the width/height → style fold,
-// alt → accessibility, and the Image statics (getSize / prefetch / queryCache / …) are shared
-// verbatim from @symbiote-native/components via renderImage; Vue supplies only the functional bridge.
 export { Image, setImageSourceResolver } from './components/image.js';
-// First component off the shared @symbiote-native/components layer: render-only, drives the
-// agnostic renderActivityIndicator through descriptorToVue. Proof the layer is reusable:
-// the render fn is shared verbatim with React; Vue supplies only the bridge.
 export { ActivityIndicator } from './components/activity-indicator';
-// First component to bring the state half into Vue (the lastNativeReport reducer + the
-// snap-back watch); render shared verbatim with React, Vue supplies the reactive lifecycle.
 export { Switch } from './components/switch';
-// ScrollView. Full parity: vertical + horizontal, every pass-through prop, the
-// synthesized onContentSizeChange, the imperative handle via expose() + shallowRef, RefreshControl
-// (iOS sibling / Android wrap), and sticky headers (the scroll AnimatedValue,
-// the headerLayoutYs cross-talk, and the per-header Animated.View wrap). The pure math (intrinsics,
-// decelerationRate, content-size dedupe, the handle, the sticky interpolation) is shared verbatim
-// with React from @symbiote-native/components.
 export { ScrollView } from './components/scroll-view';
-// Pressable family. Full parity with React (the 3-layer split): the press state machine + render
-// decisions are shared in @symbiote-native/components; Vue supplies the reactivity + descriptor bridge.
 export { Pressable } from './components/pressable.js';
 export { TouchableOpacity, TouchableHighlight, TouchableWithoutFeedback, } from './components/touchable.js';
 export { TouchableNativeFeedback } from './components/touchable-native-feedback.js';
 export { Button } from './components/button.js';
-// TextInput. Full parity with React (the 3-layer split): the value/selection folds + the
-// controlled-write predicate live in @symbiote-native/components; Vue supplies the reactivity
-// (shallowRef host node, post-flush watch) + the imperative handle via expose().
 export { TextInput } from './components/text-input/index.js';
-// VirtualizedList family. Full parity with React: the windowing math (visible range, cell
-// keys, viewability token diffing, edge-reached, the list plan) is shared in
-// @symbiote-native/components; Vue supplies the reactive lifecycle + the per-cell element.
 export { VirtualizedList } from './components/virtualized-list/index.js';
 export { FlatList } from './components/flat-list/index.js';
 export { VirtualizedSectionList } from './components/virtualized-section-list/index.js';
 export { SectionList } from './components/section-list/index.js';
-// SafeAreaView + RefreshControl, wired into ScrollView with the iOS-sibling /
-// Android-wrap platform split. RefreshControl hosts the wrapped scroll view via its default slot.
+// RefreshControl hosts the wrapped scroll view via its default slot.
 export { SafeAreaView } from './components/safe-area-view.js';
 export { RefreshControl } from './components/refresh-control.js';
 export { descriptorToVue } from './descriptor-to-vue.js';
-// normalizeVueAttrs: the kebab→camel attr fold every component applies at entry. Exported so an
-// external wrapper package (e.g. @symbiote-native/slider/vue over a third-party native view) can fold
-// its incoming attrs through the SAME transform rather than reimplementing it.
+// Exported so an external wrapper package (e.g. @symbiote-native/slider/vue over a third-party
+// native view) can fold its incoming attrs/v-model through the SAME transform rather than
+// reimplementing it.
 export { normalizeVueAttrs } from './utils/normalize-attrs.js';
-// resolveModelValue/emitModelUpdate: the v-model helper every
-// controlled-value component uses. Exported for the same external-package reason as
-// normalizeVueAttrs above (e.g. @symbiote-native/slider/vue).
 export { resolveModelValue, emitModelUpdate } from './utils/model-binding.js';
 export { createSymbioteRenderer } from './renderer/index.js';
-// Animated: Animated.View/Text/Image + the lazy Animated.ScrollView over the
-// Vue primitives, with the value graph / easing / drivers spread from @symbiote-native/engine. The wrap
-// mechanism (createAnimatedComponent) is the Vue twin of React's; the pure leaves live in the
-// engine.
 export { Animated, createAnimatedComponent } from './modules/animated/index.js';
-// Visual components off the shared @symbiote-native/components layer (wave: simple-visual).
 export { ImageBackground } from './components/image-background.js';
 export { InputAccessoryView } from './components/input-accessory-view.js';
 export { Modal } from './components/modal/index.js';
-// KeyboardAvoidingView: full parity via the shared inset math; Vue owns the Keyboard subscription.
 export { KeyboardAvoidingView } from './components/keyboard-avoiding-view.js';
-// StatusBar: declarative component + the shared imperative API.
 export { StatusBar } from './modules/status-bar.js';
-// AppRegistry: RN's app entry point over `mount`. setHostRegistrar wires RN's own
-// registrar so the native Fabric host finds our runnable by app key.
+// RN's app entry point over `mount`. setHostRegistrar wires RN's own registrar so the native
+// Fabric host finds our runnable by app key.
 export { AppRegistry, setHostRegistrar } from './modules/app-registry/index.js';
 // Vue composables over the core device-state modules.
 export { useColorScheme } from './composables/use-color-scheme.js';
@@ -84,7 +49,8 @@ export { Alert, Share, ActionSheetIOS, Linking, Vibration, ToastAndroid, Setting
 export { Platform, StyleSheet, processColor, setColorProcessor, dlog, isDebug, } from '@symbiote-native/engine';
 // Wired once by the app entry on a real host (like setColorProcessor): hands the engine
 // RN's ViewConfig registry so third-party Fabric views auto-derive their metadata.
-export { setNativeViewConfigSource } from '@symbiote-native/engine';
+// setDeviceEventSource is the third seam of the same set and travels with them.
+export { setNativeViewConfigSource, setDeviceEventSource } from '@symbiote-native/engine';
 // Pure utilities that moved to the engine (single source, both adapters re-export):
 // PixelRatio + PanResponder, plus the color builders and the interaction scheduler.
 export { PixelRatio, PanResponder, PlatformColor, DynamicColorIOS, InteractionManager, } from '@symbiote-native/engine';