@symbiote-native/components 0.2.2 → 0.2.4

package/build/bootstrap.js

@@ -1,13 +1,12 @@
 // Zero-config host bootstrap for @symbiote-native/components' four RN-backed seams
 // (colorProcessor, imageSourceResolver, deviceEventSource, nativeViewConfigSource), wired from
-// real react-native in one call — collapses what every canary example currently hand-wires at
+// real react-native in one call - collapses what every canary example currently hand-wires at
 // startup. Lives OUTSIDE the package's main barrel (see package.json's separate "./bootstrap"
 // export): react-native's own source is Flow syntax Vitest's transform can't parse, so anything
 // importing it directly must stay unreachable from the tested main index.ts.
 import { processColor, DeviceEventEmitter, Image } from 'react-native';
-import { setColorProcessor, setDeviceEventSource, setNativeViewConfigSource, } from '@symbiote-native/engine';
-import { setImageSourceResolver } from './view/render-image.js';
-// @ts-expect-error react-native ships no types for this internal path (plain .js) — the
+import { setColorProcessor, setDeviceEventSource, setImageSourceResolver, setNativeViewConfigSource, } from '@symbiote-native/engine';
+// @ts-expect-error react-native ships no types for this internal path (plain .js) - the
 // try/catch below is what actually proves the shape, not TS.
 import * as ReactNativeViewConfigRegistry from 'react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry';
 // Third-party Fabric views derive their events + prop processors from RN's own ViewConfig
@@ -23,7 +22,7 @@ function defaultNativeViewConfigSource(name) {
 }
 // require('./x.png') asset ids and {uri} sources are resolved by RN's own resolver before they
 // reach the shared render fns. `source` is untyped at the setImageSourceResolver seam by design
-// (any component's resolved shape flows through it) — this is the I/O edge where it crosses
+// (any component's resolved shape flows through it) - this is the I/O edge where it crosses
 // into RN's own typed Image API.
 function defaultImageSourceResolver(source) {
     return Image.resolveAssetSource(source);

package/build/index.d.ts

@@ -18,8 +18,10 @@ export { buildScrollViewHandle, splitLayoutProps, attachStickyScroll, isSymbiote
 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 { IImageSource, IImageStatics, IImageSourceProp, IResizeMode, IImageSize, IImageCacheStatus, IImageProps, IImageViewProps, } from './view/render-image';
-export { renderImage, imageStatics, setImageSourceResolver } from './view/render-image';
+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 { imageStatics, setImageSourceResolver } from '@symbiote-native/engine';
 export { renderImageBackground } from './view/render-image-background';
 export type { IImageBackgroundViewProps } from './view/render-image-background';
 export { renderInputAccessoryView } from './view/render-input-accessory-view';
@@ -32,7 +34,7 @@ export { computeInset, readKeyboardFrame, readLayoutFrame, resolveKeyboardAvoidi
 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 type { IPressState, IPressHandler, IPressHandlers, IPressHost, IPressRuntime, IPressMachineConfig, IFrameCallback, IRectOffset, IEdgeInsets, IResponderRegion, IPressableAndroidRippleConfig, IRippleBackground as IPressableRippleBackground, } from './state/pressable';
-export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, } from './view/render-pressable';
+export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, } from './view/render-pressable';
 export { computePressOutWait, 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 } from './state/touchable';
 export { backgroundProps, canUseNativeForeground, selectableBackground, selectableBackgroundBorderless, rippleBackground, } from './view/render-touchable-native-feedback';

package/build/index.js

@@ -11,7 +11,7 @@ export { resolveAccessibilityProps } from './accessibility-props.js';
 // 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
 // re-exports iOS for headless. descriptorFor is the per-platform-bound resolver.
-export { descriptorFor, COMPONENT_DESCRIPTORS } from './component-names/index.js';
+export { descriptorFor, COMPONENT_DESCRIPTORS } from './component-names';
 export { buildDescriptors, makeDescriptorFor } from './component-names/shared.js';
 export { renderActivityIndicator } from './view/render-activity-indicator.js';
 export { renderSwitch } from './view/render-switch.js';
@@ -24,7 +24,8 @@ export { switchReducer, createInitialSwitchState, shouldSnapBack, valueFromChang
 export { resolveDecelerationRate, selectScrollIntrinsics, readLayoutDimension, didContentSizeChange, SCROLL_VIEW_BASE_HORIZONTAL, SCROLL_VIEW_BASE_VERTICAL, } from './view/render-scroll-view.js';
 export { buildScrollViewHandle, splitLayoutProps, attachStickyScroll, isSymbioteEvent, forwardScrollEvent, } from './scroll-view-commands.js';
 export { computeStickyInterpolation, nextStickyHeaderY, stickyDebounceMs, readLayoutNumber, STICKY_HEADER_Z_INDEX, } from './view/render-scroll-sticky.js';
-export { renderImage, imageStatics, setImageSourceResolver } from './view/render-image.js';
+export { renderImage } from './view/render-image.js';
+export { imageStatics, setImageSourceResolver } from '@symbiote-native/engine';
 // ImageBackground: render-only composition (absolute-fill image behind, children on top).
 export { renderImageBackground } from './view/render-image-background.js';
 // InputAccessoryView: render-only host assembly (nativeID/backgroundColor).
@@ -39,7 +40,7 @@ export { computeInset, readKeyboardFrame, readLayoutFrame, resolveKeyboardAvoidi
 // 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 { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, } from './view/render-pressable.js';
+export { buildPressableListeners, resolveDisabledAccessibilityState, noteHoverNoop, shouldSuppressPress, shouldClaimResponder, isTerminationAllowed, } from './view/render-pressable.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, 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';

package/build/scroll-view-commands.d.ts

@@ -1,4 +1,4 @@
-import { type AnimatedValue, type IStyleProp, type ISymbioteEvent, type ISymbioteNode, type IViewStyle } from '@symbiote-native/engine';
+import { isSymbioteEvent, type AnimatedValue, type IStyleProp, type ISymbioteEvent, type ISymbioteNode, type IViewStyle } from '@symbiote-native/engine';
 type IScrollHandler = (event: ISymbioteEvent) => void;
 export interface IScrollViewHandle {
     scrollTo(options?: {
@@ -16,8 +16,7 @@ export declare function splitLayoutProps(style: IStyleProp<IViewStyle> | undefin
     outer: Record<string, unknown>;
     inner: Record<string, unknown>;
 };
-export declare function isSymbioteEvent(value: unknown): value is ISymbioteEvent;
+export { isSymbioteEvent };
 export declare function forwardScrollEvent(handler: IScrollHandler, args: readonly unknown[]): void;
 export declare function buildScrollViewHandle(getNode: () => ISymbioteNode | null): IScrollViewHandle;
 export declare function attachStickyScroll(node: ISymbioteNode, value: AnimatedValue): () => void;
-export {};

package/build/scroll-view-commands.js

@@ -3,7 +3,7 @@
 // the Android RefreshControl wrap, the scroll-event guard/forwarder, and the native sticky
 // scroll-attach are all platform- and framework-invariant, so they live here. The adapter
 // supplies the lifecycle (the node getter, the effect) and re-exports these.
-import { attachNativeEvent, dispatchViewCommand, dlog, flattenStyle, } from '@symbiote-native/engine';
+import { attachNativeEvent, dispatchViewCommand, dlog, flattenStyle, isSymbioteEvent, } from '@symbiote-native/engine';
 // RN's splitLayoutProps key partition (StyleSheet/splitLayoutProps.js): the LAYOUT keys
 // that belong on the OUTER box when a layout-affecting wrapper sits between the laid-out
 // frame and the visual content. Everything NOT in this set (background*, padding*, border*,
@@ -58,12 +58,9 @@ export function splitLayoutProps(style) {
     }
     return { outer, inner };
 }
-export function isSymbioteEvent(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const nativeEvent = Reflect.get(value, 'nativeEvent');
-    return typeof nativeEvent === 'object' && nativeEvent !== null;
-}
+// Re-exported so the package barrel (index.ts) can still export this guard to
+// '@symbiote-native/components' callers, now that it lives in the engine, next to ISymbioteEvent.
+export { isSymbioteEvent };
 // Forward a wrapped scroll event to the user's ScrollHandler. The Animated.event listener
 // hands raw args; the first is the original SymbioteEvent, which we narrow with a runtime
 // guard (no cast) and pass through unchanged so the user sees the same event RN would deliver.

package/build/state/scroll-routing-handle.d.ts

@@ -0,0 +1,10 @@
+import type { ISymbioteNode } from '@symbiote-native/engine';
+import type { IScrollViewHandle } from '../scroll-view-commands';
+export interface IScrollRoutingHandle {
+    flashScrollIndicators(): void;
+    getNativeScrollRef(): IScrollViewHandle | null;
+    getScrollableNode(): IScrollViewHandle | null;
+    getScrollResponder(): IScrollViewHandle | null;
+    getScrollNode(): ISymbioteNode | null;
+    recordInteraction(): void;
+}

package/build/state/scroll-routing-handle.js

@@ -0,0 +1,6 @@
+// The inner-scroll routing tail every windowed-list imperative handle exposes
+// (VirtualizedList, VirtualizedSectionList, and via those FlatList/SectionList). Each
+// method forwards straight to the underlying ScrollView's own handle/node; neither list
+// adds behavior of its own, so the 6 members live here once and both list handle types
+// extend this instead of hand-duplicating (and risking drift in) the signatures.
+export {};

package/build/state/section-list.d.ts

@@ -1,5 +1,4 @@
-import type { ISymbioteNode } from '@symbiote-native/engine';
-import type { IScrollViewHandle } from '../scroll-view-commands';
+import type { IScrollRoutingHandle } from './scroll-routing-handle';
 export interface ISection<ItemT> {
     title: string;
     data: readonly ItemT[];
@@ -22,7 +21,7 @@ export type ISectionEntry<ItemT> = {
     kind: 'section-separator';
     sectionIndex: number;
 };
-export interface IVirtualizedSectionListHandle {
+export interface IVirtualizedSectionListHandle extends IScrollRoutingHandle {
     scrollToLocation(params: {
         sectionIndex: number;
         itemIndex: number;
@@ -30,12 +29,6 @@ export interface IVirtualizedSectionListHandle {
         viewPosition?: number;
         animated?: boolean;
     }): void;
-    flashScrollIndicators(): void;
-    getNativeScrollRef(): IScrollViewHandle | null;
-    getScrollableNode(): IScrollViewHandle | null;
-    getScrollResponder(): IScrollViewHandle | null;
-    getScrollNode(): ISymbioteNode | null;
-    recordInteraction(): void;
 }
 export declare function flattenSections<ItemT>(sections: ReadonlyArray<ISection<ItemT>>, withSeparators: boolean): {
     entries: ISectionEntry<ItemT>[];

package/build/state/section-list.js

@@ -2,8 +2,8 @@
 // section contributes a header row, its item rows, then a footer row (RN counts 2 per
 // section around the items); the flattened sequence feeds VirtualizedList as one tagged
 // stream, so headers, items, and footers are windowed by the same machinery. All of this
-// is pure transform — every adapter reuses it; the adapter supplies only the per-entry
-// element creation (renderSectionHeader / renderItem / …) and the ref wiring.
+// is pure transform - every adapter reuses it; the adapter supplies only the per-entry
+// element creation (renderSectionHeader / renderItem / etc.) and the ref wiring.
 // Flatten sections into entries AND record where each section header lands in the flat
 // stream, so scrollToLocation can map (sectionIndex, itemIndex) -> flat index without
 // re-deriving the layout. withSeparators inserts a section separator between adjacent

package/build/state/virtualized-list.d.ts

@@ -1,6 +1,6 @@
 import type { IViewStyle } from '@symbiote-native/engine';
-import type { ISymbioteEvent, ISymbioteNode } from '@symbiote-native/engine';
-import type { IScrollViewHandle } from '../scroll-view-commands';
+import type { ISymbioteEvent } from '@symbiote-native/engine';
+import type { IScrollRoutingHandle } from './scroll-routing-handle';
 export declare const DEFAULT_WINDOW_SIZE = 21;
 export declare const DEFAULT_INITIAL_NUM_TO_RENDER = 10;
 export declare const DEFAULT_END_REACHED_THRESHOLD = 2;
@@ -52,7 +52,7 @@ export interface IViewabilityConfigCallbackPair<ItemT> {
     viewabilityConfig: IViewabilityConfig;
     onViewableItemsChanged: (info: IViewableItemsChangedInfo<ItemT>) => void;
 }
-export interface IVirtualizedListHandle {
+export interface IVirtualizedListHandle extends IScrollRoutingHandle {
     scrollToOffset(params: {
         offset: number;
         animated?: boolean;
@@ -71,12 +71,6 @@ export interface IVirtualizedListHandle {
     scrollToEnd(params?: {
         animated?: boolean;
     }): void;
-    flashScrollIndicators(): void;
-    getNativeScrollRef(): IScrollViewHandle | null;
-    getScrollableNode(): IScrollViewHandle | null;
-    getScrollResponder(): IScrollViewHandle | null;
-    getScrollNode(): ISymbioteNode | null;
-    recordInteraction(): void;
 }
 export declare function readScrollOffset(event: ISymbioteEvent, horizontal: boolean): number | undefined;
 export declare function readLayoutLength(event: ISymbioteEvent, horizontal: boolean): number | undefined;

package/build/state/virtualized-list.js

@@ -2,7 +2,7 @@
 // (React hooks, Vue reactivity) drives the SAME math from here, so a windowing /
 // viewability / edge-reached bug is fixed once for all adapters. The adapter
 // supplies only its lifecycle (refs/state/effects), the imperative handle
-// wiring, and the per-cell element creation (createElement / h) — never the
+// wiring, and the per-cell element creation (createElement / h) - never the
 // geometry.
 //
 // What lives here:
@@ -17,7 +17,7 @@
 //
 // What stays in the adapter (genuinely framework-bound): the cell CONTENT is the
 // framework's own children (renderItem -> ReactNode / VNode), so there is no
-// Descriptor render fn for a list — the shared layer for lists is this STATE/logic
+// Descriptor render fn for a list - the shared layer for lists is this STATE/logic
 // module, not a view/render-*.ts.
 // Defaults match RN. windowSize is measured in viewport-lengths (21 => ten screens
 // of buffer on each side of the visible region). onEndReachedThreshold is a multiple

package/build/view/layout-event.d.ts

@@ -0,0 +1,2 @@
+import type { ISymbioteEvent } from '@symbiote-native/engine';
+export declare function readLayoutField(event: ISymbioteEvent, key: 'width' | 'height' | 'y'): number | undefined;

package/build/view/layout-event.js

@@ -0,0 +1,12 @@
+// Shared across render-scroll-view's content/frame dimension read (width/height) and
+// render-scroll-sticky's header position read (y/height): both pull a single numeric field out of
+// an onLayout event's nativeEvent.layout. SymbioteEvent.nativeEvent is Record<string, unknown>, so
+// the layout box and the requested field are narrowed at runtime, no cast. A malformed event
+// yields undefined (no-op).
+export function readLayoutField(event, key) {
+    const layout = event.nativeEvent.layout;
+    if (typeof layout !== 'object' || layout === null)
+        return undefined;
+    const value = Reflect.get(layout, key);
+    return typeof value === 'number' ? value : undefined;
+}

package/build/view/render-image.d.ts

@@ -1,15 +1,9 @@
-import { type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
+import { type IImageSource, type IImageSourceProp, type IStyleProp, type ISymbioteEvent, type IViewStyle } from '@symbiote-native/engine';
 import type { IAccessibilityProps, IAriaProps } from '../accessibility-props';
 import { type IDescriptor } from '../descriptor';
+export type { IImageSource, IImageSourceProp };
 type IImageEventHandler = (event: ISymbioteEvent) => void;
 export type IResizeMode = 'cover' | 'contain' | 'stretch' | 'repeat' | 'center';
-export type IImageSource = {
-    uri?: string;
-    scale?: number;
-    width?: number;
-    height?: number;
-};
-export type IImageSourceProp = IImageSource | IImageSource[] | number;
 export type IImageCapInsets = {
     top: number;
     left: number;
@@ -43,29 +37,6 @@ export type IImageProps = IAccessibilityProps & IAriaProps & {
     onProgress?: IImageEventHandler;
     onPartialLoad?: IImageEventHandler;
 };
-export declare function setImageSourceResolver(resolve: (source: unknown) => unknown): void;
-export type IImageSize = {
-    width: number;
-    height: number;
-};
-export type IImageCacheStatus = 'memory' | 'disk' | 'disk/memory';
-type ISizeSuccess = (width: number, height: number) => void;
-type ISizeFailure = (error: unknown) => void;
-declare function getSize(uri: string, success?: ISizeSuccess, failure?: ISizeFailure): Promise<IImageSize>;
-declare function getSizeWithHeaders(uri: string, headers: Record<string, string>, success?: ISizeSuccess, failure?: ISizeFailure): Promise<IImageSize>;
-declare function prefetch(uri: string, callback?: (requestId: number) => void): Promise<boolean>;
-declare function abortPrefetch(requestId: number): void;
-declare function queryCache(uris: string[]): Promise<Record<string, IImageCacheStatus>>;
-declare function resolveAssetSource(source: IImageSourceProp): unknown;
-export type IImageStatics = {
-    getSize: typeof getSize;
-    getSizeWithHeaders: typeof getSizeWithHeaders;
-    prefetch: typeof prefetch;
-    abortPrefetch: typeof abortPrefetch;
-    queryCache: typeof queryCache;
-    resolveAssetSource: typeof resolveAssetSource;
-};
-export declare const imageStatics: IImageStatics;
 export type IImageViewProps = {
     source?: IImageSourceProp;
     defaultSource?: IImageSourceProp;
@@ -83,4 +54,3 @@ export type IImageViewProps = {
     passthrough: Record<string, unknown>;
 };
 export declare function renderImage(view: IImageViewProps): IDescriptor;
-export {};

package/build/view/render-image.js

@@ -1,15 +1,9 @@
-import { dlog, flattenStyle, getNativeModule, Platform, } from '@symbiote-native/engine';
+import { dlog, flattenStyle, resolveImageSource, } from '@symbiote-native/engine';
 import { el } from '../descriptor.js';
-// Default resolver: identity. RN's resolveAssetSource (which turns a require()
-// number into {uri, scale, width, height}) is wired in by the app at startup.
-let resolveSource = source => source;
-export function setImageSourceResolver(resolve) {
-    resolveSource = resolve;
-}
 // Resolve the source, then normalize to the array shape native expects. A single
 // object/number becomes a one-element array; an already-array source passes through.
 function normalizeSource(source) {
-    const resolved = resolveSource(source);
+    const resolved = resolveImageSource(source);
     const sources = Array.isArray(resolved) ? resolved : [resolved];
     dlog(`Image source resolved to ${JSON.stringify(sources)}`);
     return sources;
@@ -108,164 +102,6 @@ function readSourceUri(source) {
     }
     return undefined;
 }
-// The iOS native module name RN registers this under (NativeImageLoaderIOS.js
-// resolves `TurboModuleRegistry.getEnforcing<Spec>('ImageLoader')`). A module
-// name like this is only provable on a real host — a headless fake answers to
-// any name — so this iOS name is device-verify-pending.
-const IMAGE_LOADER_MODULE = 'ImageLoader';
-let imageLoaderModule;
-function getImageLoader() {
-    if (imageLoaderModule === undefined) {
-        imageLoaderModule = getNativeModule(IMAGE_LOADER_MODULE);
-        dlog(`Image: ImageLoader module ${imageLoaderModule ? 'resolved' : 'NOT resolved (null)'}`);
-    }
-    return imageLoaderModule;
-}
-function isNumber(value) {
-    return typeof value === 'number';
-}
-// Narrow native's getSize result. The spec resolves a `[width, height]` array,
-// but tolerate a `{width, height}` object too (getSizeWithHeaders uses that shape).
-function toImageSize(result) {
-    if (Array.isArray(result) && isNumber(result[0]) && isNumber(result[1])) {
-        return { width: result[0], height: result[1] };
-    }
-    if (typeof result === 'object' && result !== null) {
-        const width = Reflect.get(result, 'width');
-        const height = Reflect.get(result, 'height');
-        if (isNumber(width) && isNumber(height))
-            return { width, height };
-    }
-    throw new Error(`Image: unexpected size result from native: ${JSON.stringify(result)}`);
-}
-function requireLoader(method) {
-    const loader = getImageLoader();
-    if (loader === null) {
-        throw new Error(`Image.${method}: ImageLoader native module is not available ` +
-            '(running headless or not linked on this host).');
-    }
-    return loader;
-}
-// Resolve image dimensions, optionally via success/failure callbacks. Always
-// returns the Promise too (RN returns void when a callback is passed, but a
-// promise-and-callback shape is friendlier and a strict superset).
-function getSize(uri, success, failure) {
-    const promise = Promise.resolve()
-        .then(() => requireLoader('getSize').getSize(uri))
-        .then(toImageSize);
-    if (typeof success === 'function') {
-        promise
-            .then(size => success(size.width, size.height))
-            .catch((error) => {
-            if (typeof failure === 'function')
-                failure(error);
-            else
-                dlog(`Image.getSize failed for ${uri}: ${String(error)}`);
-        });
-    }
-    return promise;
-}
-function getSizeWithHeaders(uri, headers, success, failure) {
-    const promise = Promise.resolve()
-        .then(() => requireLoader('getSizeWithHeaders').getSizeWithHeaders(uri, headers))
-        .then(toImageSize);
-    if (typeof success === 'function') {
-        promise
-            .then(size => success(size.width, size.height))
-            .catch((error) => {
-            if (typeof failure === 'function')
-                failure(error);
-            else
-                dlog(`Image.getSizeWithHeaders failed for ${uri}: ${String(error)}`);
-        });
-    }
-    return promise;
-}
-// Android keys an in-flight prefetch by a monotonic requestId (so abortRequest can
-// cancel it); RN's Image.android.js generates the same way. iOS ignores the arg.
-let prefetchRequestId = 0;
-// Download a remote image into the disk cache. Resolves to whether it succeeded.
-// `callback` receives the requestId (RN's Image.android.js shape) so the caller
-// can later pass it to abortPrefetch.
-async function prefetch(uri, callback) {
-    prefetchRequestId += 1;
-    const requestId = prefetchRequestId;
-    if (typeof callback === 'function')
-        callback(requestId);
-    const loader = requireLoader('prefetch');
-    return (Promise.resolve()
-        // Android's prefetchImage keys an abortable request on requestId; iOS takes ONLY the uri and
-        // throws on an extra arg (bridgeless TurboModule arg-count check). Match RN's per-platform call.
-        .then(() => Platform.OS === 'android'
-        ? loader.prefetchImage(uri, requestId)
-        : loader.prefetchImage(uri))
-        .then(result => result === true)
-        .catch((error) => {
-        dlog(`Image.prefetch failed for ${uri}: ${String(error)}`);
-        throw error;
-    }));
-}
-// Cancel an in-flight prefetch by the requestId prefetch handed back. Android
-// only (mirrors Image.android.js -> NativeImageLoaderAndroid.abortRequest); a
-// missing abortRequest (iOS, headless) is a no-op rather than a throw.
-function abortPrefetch(requestId) {
-    const loader = getImageLoader();
-    if (loader === null || typeof loader.abortRequest !== 'function') {
-        dlog(`Image.abortPrefetch(${requestId}): no abortRequest on this host, ignoring`);
-        return;
-    }
-    loader.abortRequest(requestId);
-}
-// Narrow native's queryCache result: an object mapping each known uri to its
-// cache status. Unknown statuses are dropped rather than trusted blindly.
-const CACHE_STATUS = {
-    memory: 'memory',
-    disk: 'disk',
-    'disk/memory': 'disk/memory',
-};
-function toCacheRecord(result) {
-    const record = {};
-    if (typeof result !== 'object' || result === null)
-        return record;
-    for (const key of Object.keys(result)) {
-        const value = Reflect.get(result, key);
-        if (typeof value === 'string' && Object.hasOwn(CACHE_STATUS, value)) {
-            record[key] = CACHE_STATUS[value];
-        }
-    }
-    return record;
-}
-async function queryCache(uris) {
-    return Promise.resolve()
-        .then(() => {
-        const loader = requireLoader('queryCache');
-        // The native queryCache never rejects (RCTImageLoader resolves getImageCacheStatus), so a
-        // rejection here is a JS↔native boundary fault: log whether the method is even callable and
-        // the arg shape, to tell "not a function" (interop gap) from a marshalling reject.
-        dlog(`Image.queryCache: typeof loader.queryCache=${typeof loader.queryCache} uris=${uris.length}`);
-        return loader.queryCache(uris);
-    })
-        .then(toCacheRecord)
-        .catch((error) => {
-        dlog(`Image.queryCache failed: ${String(error)}`);
-        throw error;
-    });
-}
-// PURE JS: run the currently-installed source resolver (the same machinery the
-// Image component uses via normalizeSource). RN's resolveAssetSource turns a
-// require() asset id into {uri, scale, …}; the app injects the real one with
-// setImageSourceResolver, and this exposes its output to callers directly.
-function resolveAssetSource(source) {
-    return resolveSource(source);
-}
-export const imageStatics = {
-    getSize,
-    getSizeWithHeaders,
-    prefetch,
-    abortPrefetch,
-    queryCache,
-    resolveAssetSource,
-};
 export function renderImage(view) {
     // `width` / `height` aliases fold into style (ImageProps.js:195,202); explicit
     // style keys win, matching RN's `{width, height}, ...style` ordering.

package/build/view/render-keyboard-avoiding-view.js

@@ -1,6 +1,6 @@
 // KeyboardAvoidingView: the pure logic + view-contract half (framework-agnostic). It owns
 // every piece that does NOT need a framework: the keyboard/frame inset math, the onLayout
-// frame read, and the behavior → style/structure decision. Each adapter supplies ONLY the
+// frame read, and the behavior -> style/structure decision. Each adapter supplies ONLY the
 // lifecycle (subscribe to the Keyboard module, measure via onLayout, hold the inset in its
 // reactive primitive) and assembles the wrapper element around its own opaque children.
 //
@@ -9,13 +9,11 @@
 // carry. Instead we return a layout DESCRIPTION (which styles to apply and whether to nest)
 // and the adapter builds its own element tree with its children. Mirrors RN's
 // Libraries/Components/Keyboard/KeyboardAvoidingView.js inset/behavior logic.
+import { isRecord } from '@symbiote-native/engine';
 // RN's default keyboardVerticalOffset (KeyboardAvoidingView.js).
 export const DEFAULT_VERTICAL_OFFSET = 0;
 // RN rounds nothing here; 'height' mode collapses flex so the shrunk height holds.
 const COLLAPSED_FLEX = 0;
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
 // Pull the keyboard's top edge (screenY) and height off the raw native payload. The shape is
 // the consumer's knowledge, so we narrow `unknown` here rather than trust a type, no `as`.
 // Returns undefined when the payload isn't a keyboard frame.

package/build/view/render-pressable.d.ts

@@ -1,6 +1,9 @@
 import type { IAccessibilityStateValue } from '../accessibility-props';
 import type { IPressHandlers } from '../state/pressable';
 export declare function resolveDisabledAccessibilityState(accessibilityState: IAccessibilityStateValue | undefined, disabled: boolean | undefined): IAccessibilityStateValue | undefined;
+export declare function shouldSuppressPress(disabled: boolean | undefined): boolean;
+export declare function shouldClaimResponder(disabled: boolean | undefined): boolean;
+export declare function isTerminationAllowed(cancelable: boolean | undefined): boolean;
 export declare function buildPressableListeners(handlers: IPressHandlers, options: {
     disabled?: boolean;
     cancelable?: boolean;

package/build/view/render-pressable.js

@@ -10,12 +10,33 @@ import { dlog } from '@symbiote-native/engine';
 export function resolveDisabledAccessibilityState(accessibilityState, disabled) {
     return disabled !== undefined ? { ...accessibilityState, disabled } : accessibilityState;
 }
-// The listeners the responder View carries. When disabled, leave them off entirely. A press
-// never fires and pressed-state never flips, exactly as RN's disabled Pressable. cancelable ===
-// false refuses to yield the responder (RN routes cancelable to onResponderTerminationRequest,
-// default true when unset).
+// The 3 agnostic gating predicates behind the listener bag below. Angular has no bag to spread -
+// it binds these directly onto template event outputs (see adapters/angular/src/components/
+// pressable/index.ts), so they're exported and shared rather than folded back into
+// buildPressableListeners, keeping both sides on one definition instead of two.
+// A disabled Pressable suppresses a press entirely: it never fires and pressed-state never flips,
+// exactly as RN's disabled Pressable.
+export function shouldSuppressPress(disabled) {
+    return disabled === true;
+}
+// Claim the responder so the move stream reaches this View whenever the press isn't suppressed;
+// retention reads it.
+export function shouldClaimResponder(disabled) {
+    return disabled !== true;
+}
+// cancelable === false refuses to yield the responder (RN routes cancelable to
+// onResponderTerminationRequest). Unset defers to RN's own default, which is allowed - so this
+// resolves to true for undefined rather than hardcoding a value, mirroring the more deliberate of
+// the two definitions this predicate replaces.
+export function isTerminationAllowed(cancelable) {
+    return cancelable !== false;
+}
+// The listeners the responder View carries. When disabled, leave them off entirely - see
+// shouldSuppressPress. onResponderTerminationRequest itself is only attached when cancelable is
+// set at all, so an unset cancelable leaves RN's native default in charge rather than this
+// listener asserting one.
 export function buildPressableListeners(handlers, options) {
-    if (options.disabled === true) {
+    if (shouldSuppressPress(options.disabled)) {
         dlog('Pressable disabled — listeners suppressed');
         return {};
     }
@@ -23,12 +44,11 @@ export function buildPressableListeners(handlers, options) {
         onPress: handlers.handlePress,
         onPressIn: handlers.handlePressIn,
         onPressOut: handlers.handlePressOut,
-        // Claim the responder so the move stream reaches this View; retention reads it.
-        onStartShouldSetResponder: () => true,
+        onStartShouldSetResponder: () => shouldClaimResponder(options.disabled),
         onResponderMove: handlers.handleResponderMove,
     };
     if (options.cancelable !== undefined) {
-        listeners.onResponderTerminationRequest = () => options.cancelable;
+        listeners.onResponderTerminationRequest = () => isTerminationAllowed(options.cancelable);
     }
     return listeners;
 }

package/build/view/render-scroll-sticky.js

@@ -6,6 +6,7 @@
 // piece, the top/inverted inputRange/outputRange math (computeStickyInterpolation), is ported
 // byte-for-byte from ScrollViewStickyHeader.js's effect. The adapter owns the component shell,
 // the layout state, and building the interpolation onto its Animated value.
+import { readLayoutField } from './layout-event.js';
 // RN gives the sticky wrapper zIndex:10 (ScrollViewStickyHeader.js styles.header) so the
 // pinned header paints OVER the rows that scroll up under it. Without it the next rows (later
 // siblings) paint on top and bleed through the header.
@@ -19,16 +20,15 @@ const STICKY_DEBOUNCE_IOS_MS = 64;
 export function stickyDebounceMs(os) {
     return os === 'android' ? STICKY_DEBOUNCE_ANDROID_MS : STICKY_DEBOUNCE_IOS_MS;
 }
+// Thin re-export kept for the existing public surface (adapters import this name from
+// `@symbiote-native/components`); the actual field read is shared with render-scroll-view's
+// width/height read in layout-event.ts.
 export function readLayoutNumber(event, key) {
-    const layout = event.nativeEvent.layout;
-    if (typeof layout !== 'object' || layout === null)
-        return undefined;
-    const value = Reflect.get(layout, key);
-    return typeof value === 'number' ? value : undefined;
+    return readLayoutField(event, key);
 }
-// Build the scroll-offset → translateY interpolation ranges that keep the header pinned.
+// Build the scroll-offset -> translateY interpolation ranges that keep the header pinned.
 // Ported byte-for-byte from ScrollViewStickyHeader.js's effect (both branches). The base
-// [-1, 0] → [0, 0] stub is the un-measured identity; once measured, the top branch pins at
+// [-1, 0] -> [0, 0] stub is the un-measured identity; once measured, the top branch pins at
 // layoutY and tracks 1:1 until the next header pushes it off, while the inverted branch pins
 // at the viewport bottom (stickStartPoint) and tracks up to the collision point.
 export function computeStickyInterpolation(params) {

package/build/view/render-scroll-view.js

@@ -6,15 +6,12 @@
 // helpers from prepareScrollView. What diverges per platform, and how a RefreshControl
 // integrates, stays in the adapter's .ios/.android files.
 import { Platform } from '@symbiote-native/engine';
-// Pull a numeric field out of an onLayout event's nativeEvent.layout without a cast:
-// SymbioteEvent.nativeEvent is Record<string, unknown>, so the layout box and its
-// width/height are narrowed at runtime. A malformed event yields undefined (no-op).
+import { readLayoutField } from './layout-event.js';
+// Thin re-export kept for the existing public surface (adapters import this name from
+// `@symbiote-native/components`); the actual field read is shared with render-scroll-sticky's
+// y/height read in layout-event.ts.
 export function readLayoutDimension(event, key) {
-    const layout = event.nativeEvent.layout;
-    if (typeof layout !== 'object' || layout === null)
-        return undefined;
-    const value = Reflect.get(layout, key);
-    return typeof value === 'number' ? value : undefined;
+    return readLayoutField(event, key);
 }
 // 'normal'/'fast' resolve to DIFFERENT friction constants per platform: RN's
 // processDecelerationRate.js Platform.select()s them: iOS glides longer (0.998/0.99),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/components",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Framework-agnostic component logic (state machines + render functions) for SymbioteNative — written once, inherited by every adapter (React, Vue, Angular, ...).",
   "repository": {
     "type": "git",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@symbiote-native/engine": "0.1.3"
+    "@symbiote-native/engine": "0.1.5"
   },
   "peerDependencies": {
     "react-native": ">=0.86"