@symbiote-native/components 0.4.0 → 1.0.0

package/build/index.d.ts

@@ -1,10 +1,14 @@
 export { el, txt } from './descriptor';
 export type { IDescriptor, IDescriptorType, IDescriptorProps, IDescriptorChild, } from './descriptor';
+export { createDescriptorShapeGuard } from './descriptor';
+export type { IDescriptorShapeGuard } from './descriptor';
 export { resolveAccessibilityProps } from './accessibility-props';
+export { resolveTextProps } from './text-props';
+export type { IEllipsizeMode, ITextDefaultableProps } from './text-props';
 export type { IAccessibilityProps, IAriaProps, IAccessibilityRole, IRole, IAccessibilityStateValue, IAccessibilityValue, IAccessibilityActionInfo, } from './accessibility-props';
 export { descriptorFor, COMPONENT_DESCRIPTORS } from './component-names';
 export { buildDescriptors, makeDescriptorFor } from './component-names/shared';
-export type { ISymbioteIntrinsic, IComponentDescriptor } from './component-names/shared';
+export type { ISymbioteIntrinsic, IComponentDescriptor, } from './component-names/shared';
 export { renderActivityIndicator } from './view/render-activity-indicator';
 export type { IActivityIndicatorProps, IActivityIndicatorViewProps, IActivityIndicatorPlatform, IActivityIndicatorSize, } from './view/render-activity-indicator';
 export { renderSwitch } from './view/render-switch';
@@ -17,12 +21,12 @@ export type { IScrollIntrinsics, IContentSize, IScrollForwarding, IScrollForward
 export { buildScrollViewHandle, splitLayoutProps, attachStickyScroll, isSymbioteEvent, forwardScrollEvent, } from './scroll-view-commands';
 export type { IScrollViewHandle } from './scroll-view-commands';
 export { computeStickyInterpolation, nextStickyHeaderY, stickyDebounceMs, readLayoutNumber, STICKY_HEADER_Z_INDEX, } from './view/render-scroll-sticky';
-export type { IStickyHeaderProps, IStickyInterpolationParams } from './view/render-scroll-sticky';
+export type { IStickyHeaderProps, IStickyInterpolationParams, } from './view/render-scroll-sticky';
 export { reduceSticky, createInitialStickyState, stickyEffectSignature, } from './state/sticky-header-reducer';
 export type { IStickyHeaderState, IStickyReducerInputs, IStickyAction, IStickyEffect, IStickyReduceResult, } from './state/sticky-header-reducer';
 export type { IImageSource, IImageSourceProp, IResizeMode, IImageProps, IImageViewProps, } from './view/render-image';
 export { renderImage } from './view/render-image';
-export type { IImageStatics, IImageSize, IImageCacheStatus } from '@symbiote-native/engine';
+export type { IImageStatics, IImageSize, IImageCacheStatus, } from '@symbiote-native/engine';
 export { imageStatics, setImageSourceResolver } from '@symbiote-native/engine';
 export { renderImageBackground } from './view/render-image-background';
 export type { IImageBackgroundViewProps } from './view/render-image-background';
@@ -30,29 +34,38 @@ export { renderInputAccessoryView } from './view/render-input-accessory-view';
 export type { IInputAccessoryViewViewProps } from './view/render-input-accessory-view';
 export { renderModal } from './view/render-modal';
 export type { IModalViewProps, IModalAnimationType, IModalPresentationStyle, IModalOrientation, IModalOrientationChangeEvent, } from './view/render-modal';
-export { modalReducer, createInitialModalState, shouldRenderModal } from './state/modal';
+export { modalReducer, createInitialModalState, shouldRenderModal, } from './state/modal';
 export type { IModalState, IModalAction } from './state/modal';
-export { computeInset, readKeyboardFrame, readLayoutFrame, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from './view/render-keyboard-avoiding-view';
-export type { IKeyboardAvoidingBehavior, IMeasuredFrame, IKeyboardFrame, IKeyboardAvoidingLayout, IResolveKeyboardAvoidingLayoutParams, } from './view/render-keyboard-avoiding-view';
-export { createPressHandlers, createPressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable';
+export { computeInset, keyboardAvoidingEventNamesFor, readPrefersCrossFadeTransitions, readKeyboardFrame, readLayoutFrame, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from './view/render-keyboard-avoiding-view';
+export type { IComputeInsetOptions, IKeyboardAvoidingBehavior, IKeyboardAvoidingEventNames, IMeasuredFrame, IKeyboardFrame, IKeyboardAvoidingLayout, IResolveKeyboardAvoidingLayoutParams, } from './view/render-keyboard-avoiding-view';
+export { createPressHandlers, createPressRuntime, disposePressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable';
 export type { IPressState, IPressHandler, IPressHandlers, IPressHost, IPressRuntime, IPressMachineConfig, IFrameCallback, IRectOffset, IEdgeInsets, IResponderRegion, IPressableAndroidRippleConfig, IRippleBackground as IPressableRippleBackground, } from './state/pressable';
 export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, } from './view/render-pressable';
-export { computePressOutWait, createTouchableFeedbackRuntime, createTouchableFeedbackHandlers, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, RESTING_OPACITY, DEFAULT_HIGHLIGHT_CHILD_OPACITY, DEFAULT_UNDERLAY_COLOR, DEFAULT_MIN_PRESS_DURATION_MS, } from './state/touchable';
-export type { IPressTimingProps, ITouchableHandler, ITouchableFeedbackRuntime, ITouchableFeedbackConfig, ITouchableFeedbackCallbacks, ITouchableFeedbackHandlers, } from './state/touchable';
-export { highlightPressedStyle } from './view/render-touchable-highlight';
+export { computePressOutWait, createTouchableFeedbackRuntime, createTouchableFeedbackHandlers, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_ACTIVE_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, RESTING_OPACITY, DEFAULT_HIGHLIGHT_CHILD_OPACITY, DEFAULT_UNDERLAY_COLOR, TOUCHABLE_MIN_PRESS_DURATION_MS, restingOpacityFromStyle, hasTouchablePressHandler, createHighlightUnderlayRuntime, createHighlightUnderlayHandlers, } from './state/touchable';
+export type { IPressTimingProps, ITouchableHandler, ITouchableFeedbackRuntime, ITouchableFeedbackConfig, ITouchableFeedbackCallbacks, ITouchableFeedbackHandlers, ITouchablePressHandlerProps, IHighlightUnderlayRuntime, IHighlightUnderlayConfig, IHighlightUnderlayCallbacks, IHighlightUnderlayHandlers, } from './state/touchable';
+export { resolveHighlightExtraStyles } from './view/render-touchable-highlight';
+export type { ITouchableHighlightExtraStyles, ITouchableHighlightUnderlayView, } from './view/render-touchable-highlight';
 export { backgroundProps, canUseNativeForeground, selectableBackground, selectableBackgroundBorderless, rippleBackground, } from './view/render-touchable-native-feedback';
 export type { INativeFeedbackBackground, IThemeAttrBackground, IRippleBackground, } from './view/render-touchable-native-feedback';
 export { BUTTON_ACCESSIBILITY_ROLE, buttonTextStyle, resolveButtonTextStyle, } from './view/render-button';
 export type { IButtonProps } from './view/render-button';
 export { resolveTextInputProps, foldText, foldAutoComplete, foldSubmitBehavior, mapAutoComplete, textFromChange, eventCountFromChange, shouldCommandText, INITIAL_EVENT_COUNT, SELECTION_NONE, } from './state/text-input';
 export type { ITextInputProps, ITextInputHandle, ITextInputSelection, ITextInputEventHandler, ITextInputFoldInput, IFoldedTextInputProps, IInputMode, IEnterKeyHint, ISubmitBehavior, } from './state/text-input';
+export { keyboardTypeForInputMode } from './state/text-input';
 export { renderTextInput } from './view/render-text-input';
 export type { ITextInputViewProps } from './view/render-text-input';
-export { DEFAULT_WINDOW_SIZE, DEFAULT_INITIAL_NUM_TO_RENDER, DEFAULT_END_REACHED_THRESHOLD, DEFAULT_MAX_TO_RENDER_PER_BATCH, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD, DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD, DEFAULT_START_REACHED_THRESHOLD, FIRST_INDEX, EMPTY_OFFSET, NO_INDEX, NO_CONTENT_LENGTH_SENT, INVERTED_Y_STYLE, INVERTED_X_STYLE, readScrollOffset, readLayoutLength, buildOffsets, computeWindow, throttleWindow, visiblePercent, isCellViewable, offsetForIndex, averageMeasuredLength, highestMeasuredIndex, computeEndReached, computeStartReached, buildViewabilityPairs, computeViewableSet, diffViewable, maxMinimumViewTime, buildListPlan, computeMvcpAdjustment, resolveItemKey, indexOfItem, offsetForEnd, isSeparatorGapInRange, decideEdgeReached, resolveStickySectionHeaders, wrapFixedLayout, resolveAverageLength, } from './state/virtualized-list';
+export { DEFAULT_WINDOW_SIZE, DEFAULT_INITIAL_NUM_TO_RENDER, DEFAULT_END_REACHED_THRESHOLD, DEFAULT_MAX_TO_RENDER_PER_BATCH, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD, DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD, DEFAULT_START_REACHED_THRESHOLD, FIRST_INDEX, EMPTY_OFFSET, NO_INDEX, NO_CONTENT_LENGTH_SENT, INVERTED_Y_STYLE, INVERTED_X_STYLE, readScrollOffset, readLayoutLength, readLayoutOffset, buildOffsets, computeWindow, throttleWindow, visiblePercent, isCellViewable, offsetForIndex, averageMeasuredLength, averageMeasuredStride, highestMeasuredIndex, computeEndReached, computeStartReached, buildViewabilityPairs, computeViewableSet, diffViewable, maxMinimumViewTime, buildListPlan, computeMvcpAdjustment, resolveItemKey, indexOfItem, offsetForEnd, isSeparatorGapInRange, decideEdgeReached, resolveStickySectionHeaders, wrapFixedLayout, resolveAverageLength, } from './state/virtualized-list';
 export type { IMvcpAction, IMvcpAdjustmentParams, IMvcpAdjustmentResult, ICellLayout, ISeparators, ISeparatorProps, IViewToken, IViewableItemsChangedInfo, IViewabilityConfig, IViewabilityConfigCallbackPair, IVirtualizedListHandle, IViewableSetParams, IListCellPlan, IListPlan, IListPlanParams, } from './state/virtualized-list';
 export { reduceList, createInitialListState, listEffectSignature, } from './state/virtualized-list-reducer';
 export type { IListState, IListMetrics, IListReducerInputs, IListAction, IListEffect, IListReduceResult, } from './state/virtualized-list-reducer';
+export { subscribeListDiagnostics } from './state/virtualized-list-diagnostics';
+export type { IListDiagnosticFrame, IListDiagnosticMove, } from './state/virtualized-list-diagnostics';
 export { SINGLE_COLUMN, chunkIntoRows, rowKeyExtractor, expandRowToken, expandRowViewability, lastItemOfRow, firstItemOfRow, } from './state/flat-list';
 export type { IRow } from './state/flat-list';
 export { flattenSections, unwrapEntryItem, sectionEntryKey, scrollLocationToFlatIndex, } from './state/section-list';
-export type { ISection, ISectionEntry, IVirtualizedSectionListHandle } from './state/section-list';
+export type { ISection, ISectionEntry, IVirtualizedSectionListHandle, } from './state/section-list';
+export { registerPressableBehavior, PRESSABLE_TAG, } from './behaviors/pressable';
+export { foldImagePayload, IMAGE_TAG, registerImageBehavior, } from './behaviors/image';
+export { foldInputAccessoryViewPayload, INPUT_ACCESSORY_VIEW_TAG, registerInputAccessoryViewBehavior, } from './behaviors/input-accessory-view';
+export { registerTextInputBehavior, buildTextInputHandle, TEXT_INPUT_TAG, TEXT_INPUT_MULTILINE_TAG, } from './behaviors/text-input';
+export { registerSwitchBehavior, SWITCH_TAG } from './behaviors/switch';

package/build/index.js

@@ -3,10 +3,15 @@
 // wires state→render with ITS lifecycle (React hooks / Vue reactivity) and maps the
 // Descriptor onto its own element.
 export { el, txt } from './descriptor.js';
+// The shape-stability guard a fine-grained adapter's Descriptor bridge builds on. Internal to
+// adapter bridges (Svelte's and Solid's), NOT part of an app's surface — so it stays out of the
+// adapter barrels, unlike the passthrough names in tests/adapter-barrel-parity.test.ts.
+export { createDescriptorShapeGuard } from './descriptor.js';
 // Accessibility folding: the web-alias (aria-*/role) → canonical accessibility* transform
 // and its types. Framework-agnostic, so React, Vue, and the next adapter all fold
 // identically; moved here from @symbiote-native/react. RefreshControl/SafeAreaView/ScrollView consume it.
 export { resolveAccessibilityProps } from './accessibility-props.js';
+export { resolveTextProps } from './text-props.js';
 // Intrinsic (`symbiote-*`) → Fabric view-name resolution. Shared by every adapter so the
 // names CANNOT drift between them (one engine, one Fabric). The name tables are
 // Metro-split (.ios/.android, filename selects, no Platform.OS read); the base
@@ -37,19 +42,19 @@ export { renderImageBackground } from './view/render-image-background.js';
 export { renderInputAccessoryView } from './view/render-input-accessory-view.js';
 // Modal: full 3-layer split (state machine gates the iOS keep-alive frame).
 export { renderModal } from './view/render-modal.js';
-export { modalReducer, createInitialModalState, shouldRenderModal } from './state/modal.js';
+export { modalReducer, createInitialModalState, shouldRenderModal, } from './state/modal.js';
 // KeyboardAvoidingView: pure inset/behavior math; the adapter owns the Keyboard subscription.
-export { computeInset, readKeyboardFrame, readLayoutFrame, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from './view/render-keyboard-avoiding-view.js';
+export { computeInset, keyboardAvoidingEventNamesFor, readPrefersCrossFadeTransitions, readKeyboardFrame, readLayoutFrame, resolveKeyboardAvoidingLayout, DEFAULT_VERTICAL_OFFSET, } from './view/render-keyboard-avoiding-view.js';
 // Pressable: the press state machine (logic) + render decisions. The pure lifecycle (timers,
 // geometry, drift test, suppression flags) lives in state/pressable; the responder-listener +
 // accessibilityState + ripple render decisions in view/render-pressable. Every adapter supplies
 // only its reactive `pressed` cell + the View's measure handle (see the 3-layer split).
-export { createPressHandlers, createPressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable.js';
+export { createPressHandlers, createPressRuntime, disposePressRuntime, normalizeRect, maxEdge, isTouchWithinRegion, readPoint, computeRegion, rippleProps, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, DEFAULT_PRESS_RECT_OFFSETS, } from './state/pressable.js';
 export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, } from './view/render-pressable/index.js';
 // Touchable*: shared press-timing constants + the deactivation-floor math (the Animated feedback
 // itself stays per-adapter), and TouchableNativeFeedback's pure static factories + background map.
-export { computePressOutWait, createTouchableFeedbackRuntime, createTouchableFeedbackHandlers, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, RESTING_OPACITY, DEFAULT_HIGHLIGHT_CHILD_OPACITY, DEFAULT_UNDERLAY_COLOR, DEFAULT_MIN_PRESS_DURATION_MS, } from './state/touchable.js';
-export { highlightPressedStyle } from './view/render-touchable-highlight.js';
+export { computePressOutWait, createTouchableFeedbackRuntime, createTouchableFeedbackHandlers, DEFAULT_ACTIVE_OPACITY, OPACITY_ACTIVE_GRANT_DURATION_MS, OPACITY_ACTIVE_DURATION_MS, OPACITY_INACTIVE_DURATION_MS, RESTING_OPACITY, DEFAULT_HIGHLIGHT_CHILD_OPACITY, DEFAULT_UNDERLAY_COLOR, TOUCHABLE_MIN_PRESS_DURATION_MS, restingOpacityFromStyle, hasTouchablePressHandler, createHighlightUnderlayRuntime, createHighlightUnderlayHandlers, } from './state/touchable.js';
+export { resolveHighlightExtraStyles } from './view/render-touchable-highlight.js';
 export { backgroundProps, canUseNativeForeground, selectableBackground, selectableBackgroundBorderless, rippleBackground, } from './view/render-touchable-native-feedback.js';
 // Button: shared base text style, role constant, and color fold (the adapter composes its own
 // TouchableOpacity + Text).
@@ -60,15 +65,22 @@ export { BUTTON_ACCESSIBILITY_ROLE, buttonTextStyle, resolveButtonTextStyle, } f
 // resolved native props. Both shared verbatim across React and Vue; the adapter owns only the
 // hooks/reactivity + the imperative handle.
 export { resolveTextInputProps, foldText, foldAutoComplete, foldSubmitBehavior, mapAutoComplete, textFromChange, eventCountFromChange, shouldCommandText, INITIAL_EVENT_COUNT, SELECTION_NONE, } from './state/text-input.js';
+export { keyboardTypeForInputMode } from './state/text-input.js';
 export { renderTextInput } from './view/render-text-input.js';
 // VirtualizedList family: the framework-agnostic windowing engine + data shapes. Lists
 // have NO view/render-*.ts (the cell content is the framework's own children, so there is
 // no Descriptor render fn) — the shared layer for lists is this STATE/logic, reused
 // verbatim by React and Vue.
-export { DEFAULT_WINDOW_SIZE, DEFAULT_INITIAL_NUM_TO_RENDER, DEFAULT_END_REACHED_THRESHOLD, DEFAULT_MAX_TO_RENDER_PER_BATCH, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD, DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD, DEFAULT_START_REACHED_THRESHOLD, FIRST_INDEX, EMPTY_OFFSET, NO_INDEX, NO_CONTENT_LENGTH_SENT, INVERTED_Y_STYLE, INVERTED_X_STYLE, readScrollOffset, readLayoutLength, buildOffsets, computeWindow, throttleWindow, visiblePercent, isCellViewable, offsetForIndex, averageMeasuredLength, highestMeasuredIndex, computeEndReached, computeStartReached, buildViewabilityPairs, computeViewableSet, diffViewable, maxMinimumViewTime, buildListPlan, computeMvcpAdjustment, resolveItemKey, indexOfItem, offsetForEnd, isSeparatorGapInRange, decideEdgeReached, resolveStickySectionHeaders, wrapFixedLayout, resolveAverageLength, } from './state/virtualized-list.js';
+export { DEFAULT_WINDOW_SIZE, DEFAULT_INITIAL_NUM_TO_RENDER, DEFAULT_END_REACHED_THRESHOLD, DEFAULT_MAX_TO_RENDER_PER_BATCH, DEFAULT_UPDATE_CELLS_BATCHING_PERIOD, DEFAULT_VIEW_AREA_COVERAGE_PERCENT_THRESHOLD, DEFAULT_START_REACHED_THRESHOLD, FIRST_INDEX, EMPTY_OFFSET, NO_INDEX, NO_CONTENT_LENGTH_SENT, INVERTED_Y_STYLE, INVERTED_X_STYLE, readScrollOffset, readLayoutLength, readLayoutOffset, buildOffsets, computeWindow, throttleWindow, visiblePercent, isCellViewable, offsetForIndex, averageMeasuredLength, averageMeasuredStride, highestMeasuredIndex, computeEndReached, computeStartReached, buildViewabilityPairs, computeViewableSet, diffViewable, maxMinimumViewTime, buildListPlan, computeMvcpAdjustment, resolveItemKey, indexOfItem, offsetForEnd, isSeparatorGapInRange, decideEdgeReached, resolveStickySectionHeaders, wrapFixedLayout, resolveAverageLength, } from './state/virtualized-list.js';
 // The orchestration reducer: the one pure state machine every list adapter drives, folding the
 // after-commit effect skeleton (window recompute -> edge -> viewability -> initial-scroll -> MVCP)
 // out of each adapter's reactive glue. The adapter maps events to actions and runs the effects.
 export { reduceList, createInitialListState, listEffectSignature, } from './state/virtualized-list-reducer.js';
+export { subscribeListDiagnostics } from './state/virtualized-list-diagnostics.js';
 export { SINGLE_COLUMN, chunkIntoRows, rowKeyExtractor, expandRowToken, expandRowViewability, lastItemOfRow, firstItemOfRow, } from './state/flat-list.js';
 export { flattenSections, unwrapEntryItem, sectionEntryKey, scrollLocationToFlatIndex, } from './state/section-list.js';
+export { registerPressableBehavior, PRESSABLE_TAG, } from './behaviors/pressable.js';
+export { foldImagePayload, IMAGE_TAG, registerImageBehavior, } from './behaviors/image.js';
+export { foldInputAccessoryViewPayload, INPUT_ACCESSORY_VIEW_TAG, registerInputAccessoryViewBehavior, } from './behaviors/input-accessory-view.js';
+export { registerTextInputBehavior, buildTextInputHandle, TEXT_INPUT_TAG, TEXT_INPUT_MULTILINE_TAG, } from './behaviors/text-input.js';
+export { registerSwitchBehavior, SWITCH_TAG } from './behaviors/switch.js';

package/build/resolve-intrinsic.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolve a primitive tag to the intrinsic it should actually commit, given its creation props.
+ *
+ * A tag with no `intrinsicWhen` — every primitive but `TextInput` today — passes through by
+ * identity, so a renderer may call this unconditionally without paying a lookup per prop.
+ */
+export declare function resolveIntrinsicTag(tag: string, props: Readonly<Record<string, unknown>> | undefined): string;

package/build/resolve-intrinsic.js

@@ -0,0 +1,49 @@
+// The RUNTIME half of `HOST_PRIMITIVES.intrinsicWhen` — choosing WHICH native view a primitive
+// commits, from the props it was created with.
+//
+// Why this has to exist at runtime at all. `intrinsicWhen` lets one primitive map to two native
+// views (`TextInput` -> `RCTSinglelineTextInputView` / `RCTMultilineTextInputView`), and until now
+// only the lowering transforms read it — so the choice was made at COMPILE time, from the source
+// text. That is why `dynamicIntrinsicChoice` had to be a refusal category: a transform seeing
+// `multiline={isLong}` cannot know the value, so it refused to lower the element at all.
+//
+// A public primitive TAG has no transform in front of it on three of the five adapters, so the
+// choice has to be made where the value is actually known — here, at element creation. That is a
+// capability the compiler never had, and it is why the refusal category disappears WITH the
+// transform rather than migrating into it.
+//
+// WHAT THIS DELIBERATELY DOES NOT DO: react to the prop CHANGING later. A node's native view is
+// fixed at `createNode` and no prop write moves a node between view types, so flipping `multiline`
+// on a mounted input needs the node re-created — exactly as a browser re-initialises on an
+// `<input type>` change. Re-creation is the renderer's business, not this function's; until a
+// renderer implements it, a runtime flip keeps the view it was created with.
+import { HOST_PRIMITIVES } from '../host-primitives.cjs';
+const CHOICE_BY_BASE_TAG = new Map(Object.values(HOST_PRIMITIVES).flatMap((primitive) => primitive.intrinsicWhen === undefined
+    ? []
+    : [
+        [
+            primitive.intrinsic,
+            {
+                prop: primitive.intrinsicWhen.prop,
+                alternate: primitive.intrinsicWhen.intrinsic,
+            },
+        ],
+    ]));
+/**
+ * Resolve a primitive tag to the intrinsic it should actually commit, given its creation props.
+ *
+ * A tag with no `intrinsicWhen` — every primitive but `TextInput` today — passes through by
+ * identity, so a renderer may call this unconditionally without paying a lookup per prop.
+ */
+export function resolveIntrinsicTag(tag, props) {
+    const choice = CHOICE_BY_BASE_TAG.get(tag);
+    if (choice === undefined || props === undefined)
+        return tag;
+    // Explicit rather than truthy, and the string form is not decoration: a template-driven adapter
+    // can deliver `multiline="true"` as an ATTRIBUTE STRING (Angular's `multiline="true"` vs
+    // `[multiline]="true"`), and plain truthiness would then read `multiline="false"` — also a
+    // non-empty string — as multiline. An absent prop keeps the base tag.
+    return props[choice.prop] === true || props[choice.prop] === 'true'
+        ? choice.alternate
+        : tag;
+}

package/build/state/pressable.d.ts

@@ -1,5 +1,6 @@
 import { type ISymbioteEvent } from '@symbiote-native/engine';
 export declare const DEFAULT_DELAY_LONG_PRESS_MS = 500;
+export declare const DEFAULT_MIN_PRESS_DURATION_MS = 130;
 export declare const DEFAULT_PRESS_RECT_OFFSETS: {
     top: number;
     left: number;
@@ -56,19 +57,26 @@ export interface IPressRuntime {
     longPressCancel: (() => void) | undefined;
     longPressFired: boolean;
     pressDelayCancel: (() => void) | undefined;
+    pressOutCancel: (() => void) | undefined;
     pressOrigin: {
         x: number;
         y: number;
     } | undefined;
     driftedOut: boolean;
     region: IResponderRegion | undefined;
+    active: boolean;
+    activatedAt: number | undefined;
+    delayElapsed: boolean;
+    disposed: boolean;
 }
 export declare function createPressRuntime(): IPressRuntime;
+export declare function disposePressRuntime(runtime: IPressRuntime): void;
 export type IFrameCallback = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
 export interface IPressHost {
     setPressed: (pressed: boolean) => void;
     getMeasureFn: () => ((callback: IFrameCallback) => void) | undefined;
     schedule: (callback: () => void, ms: number) => () => void;
+    now: () => number;
 }
 export interface IPressMachineConfig {
     onPress?: IPressHandler;
@@ -78,6 +86,7 @@ export interface IPressMachineConfig {
     onLongPress?: IPressHandler;
     delayLongPress: number;
     unstable_pressDelay: number;
+    minPressDuration?: number;
     hitSlop?: IRectOffset;
     pressRetentionOffset?: IRectOffset;
 }

package/build/state/pressable.js

@@ -11,9 +11,16 @@
 // the decision of when each callback fires) is here, shared by every adapter.
 import { dlog, Platform } from '@symbiote-native/engine';
 export const DEFAULT_DELAY_LONG_PRESS_MS = 500;
+// Pressability's default active-visual floor for a plain Pressable. Touchable* overrides this to 0.
+export const DEFAULT_MIN_PRESS_DURATION_MS = 130;
 // RN's default extra slop kept around a press once it is active, before a drift fires pressOut.
 // The PressRect extension (Pressability.js DEFAULT_PRESS_RECT_OFFSETS). Per-edge, deeper bottom.
-export const DEFAULT_PRESS_RECT_OFFSETS = { top: 20, left: 20, bottom: 30, right: 20 };
+export const DEFAULT_PRESS_RECT_OFFSETS = {
+    top: 20,
+    left: 20,
+    bottom: 30,
+    right: 20,
+};
 // ---- geometry (pure) --------------------------------------------------------------------------
 // A rect offset is a per-edge object (not the scalar shorthand). Reads the asymmetric form
 // without a cast.
@@ -58,7 +65,12 @@ export function readPoint(event) {
 export function computeRegion(width, height, pageX, pageY) {
     if (!width && !height && !pageX && !pageY)
         return undefined;
-    return { left: pageX, top: pageY, right: pageX + width, bottom: pageY + height };
+    return {
+        left: pageX,
+        top: pageY,
+        right: pageX + width,
+        bottom: pageY + height,
+    };
 }
 // Build the Android native-feedback prop the inner View carries from the ripple config. RN runs
 // the color through processColor → a native int; we have no native bridge in JS, so we keep the
@@ -81,11 +93,40 @@ export function createPressRuntime() {
         longPressCancel: undefined,
         longPressFired: false,
         pressDelayCancel: undefined,
+        pressOutCancel: undefined,
         pressOrigin: undefined,
         driftedOut: false,
         region: undefined,
+        active: false,
+        activatedAt: undefined,
+        delayElapsed: false,
+        disposed: false,
     };
 }
+function cancelRuntimeTimer(runtime, key) {
+    const cancel = runtime[key];
+    if (cancel === undefined)
+        return;
+    cancel();
+    runtime[key] = undefined;
+}
+// RN Pressability.reset(): cancel every timer and make any already-queued callback inert. The
+// adapter invokes this exactly once from its own unmount/destroy hook.
+export function disposePressRuntime(runtime) {
+    if (runtime.disposed)
+        return;
+    runtime.disposed = true;
+    cancelRuntimeTimer(runtime, 'longPressCancel');
+    cancelRuntimeTimer(runtime, 'pressDelayCancel');
+    cancelRuntimeTimer(runtime, 'pressOutCancel');
+    runtime.longPressFired = false;
+    runtime.pressOrigin = undefined;
+    runtime.driftedOut = false;
+    runtime.region = undefined;
+    runtime.active = false;
+    runtime.activatedAt = undefined;
+    runtime.delayElapsed = false;
+}
 // Measure the responder's on-screen frame and cache it as the retention region for the life of
 // the press (RN measures on responder grant, _measureResponderRegion). When measure is
 // unavailable (no node yet, an uncommitted node, or a host slot without a measure method,
@@ -113,7 +154,7 @@ function measureRegion(runtime, measureFn) {
 // (the React adapter's useMemo body) lives here, shared by every adapter. The adapter rebuilds
 // these per render (the closures capture the live config) while the runtime persists across them.
 export function createPressHandlers(config, runtime, host) {
-    const { onPress, onPressIn, onPressOut, onPressMove, onLongPress, delayLongPress, unstable_pressDelay, } = config;
+    const { onPress, onPressIn, onPressOut, onPressMove, onLongPress, delayLongPress, unstable_pressDelay, minPressDuration = DEFAULT_MIN_PRESS_DURATION_MS, } = config;
     // Per-edge offsets for the measured-rect retention test (RN's hitSlop + pressRectOffset).
     // pressRetentionOffset defaults to RN's DEFAULT_PRESS_RECT_OFFSETS when unset; hitSlop to zero.
     const hitSlopRect = normalizeRect(config.hitSlop);
@@ -132,23 +173,31 @@ export function createPressHandlers(config, runtime, host) {
         const origin = runtime.pressOrigin;
         if (origin === undefined)
             return true;
-        return Math.hypot(point.x - origin.x, point.y - origin.y) <= fallbackThreshold;
+        return (Math.hypot(point.x - origin.x, point.y - origin.y) <= fallbackThreshold);
     }
     function clearLongPress() {
-        if (runtime.longPressCancel !== undefined) {
-            runtime.longPressCancel();
-            runtime.longPressCancel = undefined;
-        }
+        cancelRuntimeTimer(runtime, 'longPressCancel');
+    }
+    function clearPressDelay() {
+        cancelRuntimeTimer(runtime, 'pressDelayCancel');
+    }
+    function clearPressOut() {
+        cancelRuntimeTimer(runtime, 'pressOutCancel');
     }
-    // The real activation: flip pressed-state on, arm the long-press timer, fire onPressIn. Split
-    // out so unstable_pressDelay can defer it behind a timer while an early release flushes it.
     function activate(event) {
+        if (runtime.disposed || runtime.active || runtime.driftedOut)
+            return;
+        // A new grant or drift-back-in supersedes a delayed out from the previous active interval.
+        clearPressOut();
+        runtime.active = true;
+        runtime.activatedAt = host.now();
         dlog('Pressable pressIn');
         host.setPressed(true);
-        runtime.longPressFired = false;
-        if (onLongPress) {
+        if (!runtime.longPressFired && onLongPress) {
             runtime.longPressCancel = host.schedule(() => {
                 runtime.longPressCancel = undefined;
+                if (runtime.disposed || !runtime.active || runtime.driftedOut)
+                    return;
                 runtime.longPressFired = true;
                 dlog('Pressable longPress timer fired');
                 onLongPress(event);
@@ -156,51 +205,99 @@ export function createPressHandlers(config, runtime, host) {
         }
         onPressIn?.(event);
     }
-    // Flush a still-pending pressDelay timer immediately, so a pressOut/press that arrives before
-    // the delay elapsed still sees an activated press.
-    function flushPressDelay(event) {
-        if (runtime.pressDelayCancel !== undefined) {
-            runtime.pressDelayCancel();
-            runtime.pressDelayCancel = undefined;
-            activate(event);
+    function deactivate(event) {
+        if (runtime.disposed || !runtime.active)
+            return;
+        runtime.active = false;
+        clearLongPress();
+        const activatedAt = runtime.activatedAt ?? host.now();
+        runtime.activatedAt = undefined;
+        const heldFor = Math.max(0, host.now() - activatedAt);
+        const wait = Math.max(minPressDuration - heldFor, 0);
+        const finish = () => {
+            runtime.pressOutCancel = undefined;
+            if (runtime.disposed)
+                return;
+            host.setPressed(false);
+            onPressOut?.(event);
+        };
+        if (wait > 0) {
+            dlog(`Pressable pressOut deferred ${wait}ms`);
+            runtime.pressOutCancel = host.schedule(finish, wait);
         }
+        else {
+            finish();
+        }
+    }
+    // An honest release arrives as press then pressOut. If it beat delayPressIn, activate now so the
+    // tap still flashes and calls onPressIn; a cancelled/out-of-bounds gesture never calls this path.
+    function completePressDelay(event) {
+        if (runtime.pressDelayCancel !== undefined)
+            clearPressDelay();
+        if (!runtime.delayElapsed)
+            runtime.delayElapsed = true;
+        if (!runtime.driftedOut)
+            activate(event);
+    }
+    function resetGesture() {
+        runtime.pressOrigin = undefined;
+        runtime.region = undefined;
+        runtime.driftedOut = false;
+        runtime.delayElapsed = false;
+        runtime.longPressFired = false;
     }
     return {
         handlePressIn(event) {
+            if (runtime.disposed)
+                return;
+            // A new grant cancels a delayed out from the prior gesture, matching Pressability's
+            // onResponderGrant -> _cancelPressOutDelayTimeout.
+            clearPressDelay();
+            clearLongPress();
+            clearPressOut();
+            runtime.active = false;
+            runtime.activatedAt = undefined;
+            runtime.longPressFired = false;
+            runtime.delayElapsed = false;
             runtime.pressOrigin = readPoint(event);
             runtime.driftedOut = false;
-            // Measure now so the move stream tests against the real frame, not a press-start radius.
             measureRegion(runtime, host.getMeasureFn());
             if (unstable_pressDelay > 0) {
                 dlog(`Pressable pressIn deferred ${unstable_pressDelay}ms`);
                 runtime.pressDelayCancel = host.schedule(() => {
                     runtime.pressDelayCancel = undefined;
-                    activate(event);
+                    if (runtime.disposed)
+                        return;
+                    runtime.delayElapsed = true;
+                    if (!runtime.driftedOut)
+                        activate(event);
                 }, unstable_pressDelay);
                 return;
             }
+            runtime.delayElapsed = true;
             activate(event);
         },
         handlePressOut(event) {
+            if (runtime.disposed)
+                return;
             dlog('Pressable pressOut');
-            flushPressDelay(event);
+            // A cancellation before delayPressIn must stay inert. An honest release already flushed the
+            // delay in handlePress, because the engine emits press immediately before pressOut.
+            clearPressDelay();
             clearLongPress();
-            runtime.pressOrigin = undefined;
-            runtime.region = undefined;
-            host.setPressed(false);
-            onPressOut?.(event);
+            deactivate(event);
+            resetGesture();
         },
         handlePress(event) {
+            if (runtime.disposed)
+                return;
             dlog('Pressable press');
-            flushPressDelay(event);
+            completePressDelay(event);
             clearLongPress();
-            // A drift past the retention region cancels the tap (RN); reset and suppress.
             if (runtime.driftedOut) {
-                runtime.driftedOut = false;
                 dlog('Pressable press suppressed by drift past retention region');
                 return;
             }
-            // A fired long press cancels the tap: reset the flag and suppress onPress.
             if (runtime.longPressFired) {
                 runtime.longPressFired = false;
                 dlog('Pressable press suppressed by prior longPress');
@@ -208,11 +305,9 @@ export function createPressHandlers(config, runtime, host) {
             }
             onPress?.(event);
         },
-        // Responder-move stream of the Pressable's own View. onPressMove fires on every move while
-        // the press is live (RN). Then the retention test: a move outside the measured region
-        // (expanded by hitSlop+pressRectOffset) fires an early pressOut and marks the tap suppressed;
-        // a move back inside re-activates.
         handleResponderMove(event) {
+            if (runtime.disposed)
+                return;
             onPressMove?.(event);
             const here = readPoint(event);
             if (!here)
@@ -222,14 +317,15 @@ export function createPressHandlers(config, runtime, host) {
                     dlog('Pressable drifted past retention region — deactivating');
                     runtime.driftedOut = true;
                     clearLongPress();
-                    host.setPressed(false);
-                    onPressOut?.(event);
+                    // Before delayPressIn there was no activation, so there is no onPressOut to emit.
+                    deactivate(event);
                 }
             }
             else if (runtime.driftedOut) {
                 dlog('Pressable returned inside retention region — reactivating');
                 runtime.driftedOut = false;
-                activate(event);
+                if (runtime.delayElapsed)
+                    activate(event);
             }
         },
     };

package/build/state/sticky-header-reducer.js

@@ -15,7 +15,7 @@
 // ./view/render-scroll-sticky; this module composes them into the ordered transition every adapter
 // shares. Ported from ScrollViewStickyHeader.js's effect.
 import { dlog } from '@symbiote-native/engine';
-import { computeStickyInterpolation, stickyDebounceMs } from '../view/render-scroll-sticky.js';
+import { computeStickyInterpolation, stickyDebounceMs, } from '../view/render-scroll-sticky.js';
 // The un-measured identity interpolation (RN: a fresh AnimatedInterpolation before the header has
 // measured its own y/height). Kept as the reset the initial state and every rebuild start from.
 const IDENTITY_INPUT_RANGE = [-1, 0];
@@ -68,7 +68,9 @@ function headerTag(state) {
 }
 export function reduceSticky(state, action, inputs) {
     dlog(`STICKY[reducer ${headerTag(state)}] action=${action.kind}` +
-        (action.kind === 'layout' ? ` y=${action.y} height=${action.height}` : '') +
+        (action.kind === 'layout'
+            ? ` y=${action.y} height=${action.height}`
+            : '') +
         (action.kind === 'animated-tick' || action.kind === 'debounce-fired'
             ? ` value=${action.value}`
             : '') +
@@ -88,13 +90,19 @@ export function reduceSticky(state, action, inputs) {
             // native-driven rebuild (fresh AnimatedProps/AnimatedStyle graph, fresh native connect) commit a
             // fresh prop identity on every redundant layout, which can itself provoke another relayout pass —
             // an unbounded same-tick rebuild ping-pong that trips Svelte's effect_update_depth_exceeded guard.
-            const alreadyAtThisGeometry = state.measured && state.layoutY === action.y && state.layoutHeight === action.height;
+            const alreadyAtThisGeometry = state.measured &&
+                state.layoutY === action.y &&
+                state.layoutHeight === action.height;
             state.layoutY = action.y;
             state.layoutHeight = action.height;
             state.measured = true;
             const effects = [];
             if (inputs.index !== undefined) {
-                effects.push({ kind: 'record-header-y', index: inputs.index, y: action.y });
+                effects.push({
+                    kind: 'record-header-y',
+                    index: inputs.index,
+                    y: action.y,
+                });
             }
             if (alreadyAtThisGeometry && state.rangesEmitted) {
                 dlog(`STICKY[reducer ${headerTag(state)}] layout: redundant geometry, skipped rebuild`);
@@ -161,12 +169,27 @@ export function reduceSticky(state, action, inputs) {
             return {
                 state,
                 effects: [
-                    { kind: 'schedule-debounce', delay: stickyDebounceMs(inputs.os), value: action.value },
+                    {
+                        kind: 'schedule-debounce',
+                        delay: stickyDebounceMs(inputs.os),
+                        value: action.value,
+                    },
                 ],
                 changed: false,
             };
         }
         case 'debounce-fired': {
+            // Already sitting at this value: emit nothing. Same bail-out the 'layout' case above spells
+            // out, for the same reason - React's own header gets it free from setTranslateY (an unchanged
+            // primitive bails out of the re-render), a reducer has to say it. Device-confirmed 2026-08-18:
+            // without it a re-arriving settled value emits apply-passthrough, the adapter force-renders,
+            // the passthrough prop gets a fresh identity, the animated graph reconnects and re-emits into
+            // another tick -> another debounce -> another passthrough. One header survives it; a screen of
+            // 200 trips React's "Maximum update depth exceeded" and takes the app down.
+            if (state.translateY === action.value) {
+                dlog(`STICKY[reducer ${headerTag(state)}] debounce-fired: already at translateY=${action.value}, no-op`);
+                return { state, effects: [], changed: false };
+            }
             // The debounce completed: commit the settled translateY. Once a NON-zero value commits, re-arm
             // the swallow gate so the next interpolation rebuild's spurious 0 is dropped (RN).
             dlog(`STICKY[reducer ${headerTag(state)}] debounce-fired: committing translateY=${action.value}`);

package/build/state/switch.js

@@ -27,5 +27,5 @@ export function valueFromChange(event) {
 // retained tree never diverges and nothing re-commits. The imperative command is the only
 // correction path. No report yet (null) or agreement → no command.
 export function shouldSnapBack(state, fabricValue) {
-    return state.lastNativeReport !== null && state.lastNativeReport !== fabricValue;
+    return (state.lastNativeReport !== null && state.lastNativeReport !== fabricValue);
 }

package/build/state/text-input.d.ts

@@ -1,4 +1,4 @@
-import type { ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
+import type { IMeasureOnSuccess, IMeasureInWindowOnSuccess, IMeasureLayoutOnSuccess, ISymbioteNode, IPlatformOSType, ISymbioteEvent, ITextStyle } from '@symbiote-native/engine';
 import type { IAccessibilityProps, IAriaProps } from '../accessibility-props';
 export type IInputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
 export type IEnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
@@ -10,6 +10,7 @@ export type ITextInputSelection = {
 export type ITextInputEventHandler = (event: ISymbioteEvent) => void;
 export declare const INITIAL_EVENT_COUNT = 0;
 export declare const SELECTION_NONE = -1;
+export declare function keyboardTypeForInputMode(inputMode: string, os: IPlatformOSType): string | undefined;
 export declare function mapAutoComplete(map: Record<string, string>, token: string): string | undefined;
 export declare function foldAutoComplete(token: string | undefined): {
     autoComplete: string | undefined;
@@ -94,10 +95,15 @@ export type ITextInputProps = IAccessibilityProps & IAriaProps & {
     onSelectionChange?: ITextInputEventHandler;
     onContentSizeChange?: ITextInputEventHandler;
 };
+export declare const TEXT_INPUT_CALLBACK_NAMES: readonly string[];
 export type ITextInputHandle = {
     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;
 };