@symbiote-native/components 1.0.0 → 2.0.0

package/build/behaviors/image-background.js

@@ -0,0 +1,139 @@
+// ImageBackground's host behavior: the composition and the prop split the wrapper component did,
+// moved below the framework so the primitive can be a bare tag.
+//
+// THE TWO-NODE SHAPE IS RN'S. `ImageBackground.js:74-103` opens a `<View>` carrying the app's
+// `style`, puts an absolutely-filled `<Image>` inside it, and lays the app's `{children}` AFTER
+// that image so they paint on top. The lowered form is the same two nodes — `image-background`
+// (an RCTView, the tag an app writes) with an RCTImageView built under it.
+//
+// WHY THE SLOT TAKES NO CHILDREN, which is the one thing this primitive needed that ScrollView,
+// ActivityIndicator and Button did not. `childHost` answers two questions at once — which node an
+// owner prop redirects onto, and which node the app's children go under — and those had the same
+// answer for every primitive until this one. Here they differ: the image takes `imageStyle` and the
+// whole `...props` spread, while the children belong beside it. `slotTakesNoChildren` is what
+// splits them (`IHostBehavior`, and it is not a JSX nicety upstream could have collapsed — an
+// Android `<Image>` is an `ImageView`, not a `ViewGroup`).
+//
+// WHERE THE APP'S PROPS GO. RN destructures `children, style, imageStyle, imageRef,
+// importantForAccessibility, ...props` and spreads `...props` onto the Image
+// (`ImageBackground.js:62-81`), so the set that moves is OPEN — every event, every accessibility
+// prop, `testID`, `id`, whatever an app writes next — and only a complement can express it.
+// `IMAGE_BACKGROUND_HOST_PROPS` is the short list that stays behind, and it is shorter than RN's:
+// `importantForAccessibility` rides to the image alone, which is what all five wrappers did, so
+// the tag and the component it replaces commit the same payload. The divergence from RN predates
+// lowering and is unchanged by it.
+//
+// WHAT THE IMAGE'S FOLD OWES. Everything on the image arrives as a real prop write, so its payload
+// is built by the shared `foldImagePayload` like any other `image`. Two things cannot arrive that
+// way and are folded here: the style, which is DERIVED from the owner's own `style` (RN proxies the
+// wrapper's width/height onto the image so it fills the box rather than collapsing to the source's
+// intrinsic size), and `id`, whose rename to `nativeID` is applied per adapter on the tag THEY
+// create and so never reaches a node a behavior built.
+import { appendChild, createElement, flattenStyle, registerHostBehavior, } from '@symbiote-native/engine';
+import { descriptorFor } from '../component-names';
+import { foldImagePayload, IMAGE_TAG } from './image.js';
+export const IMAGE_BACKGROUND_TAG = 'image-background';
+// The inner Image's positioning: absolute-fill behind the box's children.
+const ABSOLUTE_FILL = {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0,
+};
+// The props RN keeps on the wrapper View (`ImageBackground.js:74-78`), plus the two spellings of a
+// class name — `routeProp`'s slot redirect runs above its own class branch, so an unlisted `class`
+// would style the image instead of the box.
+const IMAGE_BACKGROUND_HOST_PROPS = ['style', 'class', 'className'];
+// The owner props the image's payload is derived from. Only `style`, because a class name is
+// published INTO `node.props.style` by `pushClassStyle` — so a `class` write arrives here spelled
+// `style` and the proxied width/height follow a class-declared box as well as an inline one.
+const IMAGE_BACKGROUND_SLOT_DERIVED = ['style'];
+// `imageStyle` is the wrapper's own name for the image's `style`. A bare class NAME is a legal
+// value for it — every adapter's wrapper resolved one — and `routeProp` routes a string landing on
+// `style` as `class` instead, so the registry resolves it on the image with nothing needed here.
+const IMAGE_BACKGROUND_SLOT_PROPS = { imageStyle: 'style' };
+// A StyleProp is an object, an array of them, or a registered class array — all of which
+// `flattenStyle` already handles one layer down. The only thing to exclude is a scalar.
+function styleOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    if (Array.isArray(value))
+        return value;
+    return { ...value };
+}
+// RN opts the wrapper out of iOS's Smart Invert for its whole subtree (`ImageBackground.js:75`) —
+// a photograph inverted by accessibility settings is the case that prop exists for. None of the
+// five wrappers ever wrote it, so this closes a standing gap rather than reproducing one.
+const hostFold = props => ({
+    ...props,
+    accessibilityIgnoresInvertColors: true,
+});
+// Read one explicit dimension off the (already-flattened) box style. A dp number or a percentage
+// string is a valid IDimensionValue; anything else (auto / undefined) yields undefined.
+function readDimension(style, key) {
+    const value = Object.hasOwn(style, key) ? Reflect.get(style, key) : undefined;
+    if (typeof value === 'number' || typeof value === 'string')
+        return value;
+    return undefined;
+}
+function imageFold(owner) {
+    return props => {
+        // RN's own workaround, and its comment is worth reading before "simplifying" this
+        // (`ImageBackground.js:86-96`): an RN Image overwrites its own width/height from the source's
+        // intrinsic size, which fights the box's explicit dimensions, so they are proxied back on.
+        // Reads the OWNER's live style — a class name lands there too, published by `pushClassStyle`.
+        const box = flattenStyle(styleOf(owner.props.style));
+        const next = {
+            ...props,
+            // `imageStyle` last, so a caller still wins over the fill and the proxy.
+            style: [
+                ABSOLUTE_FILL,
+                {
+                    width: readDimension(box, 'width'),
+                    height: readDimension(box, 'height'),
+                },
+                styleOf(props.style),
+            ],
+        };
+        // Unconditional priority when both are set, matching RN (`View.js:77-79`) and `foldHostBag`.
+        // A raw `id` is a key no ViewConfig declares, so Fabric drops it and the nativeID is lost.
+        if (Object.hasOwn(next, 'id')) {
+            next.nativeID = next.id;
+            delete next.id;
+        }
+        return foldImagePayload(next);
+    };
+}
+// Returns the image, so `slotProps` / `slotPropsExcept` / `slotDerived` all point at it — and the
+// app's children stay on the owner because of `slotTakesNoChildren`, not because of what this
+// returns. The image is appended FIRST and nothing else is ever placed in front of it, which is
+// what makes the children paint over it.
+//
+// Built WITHOUT handing `IMAGE_TAG` to `createElement`, deliberately: that would attach Image's own
+// behavior and set `payloadFold` to `foldImagePayload` alone, and this node's style has to be
+// derived from the owner. `payloadFold` is a single slot, so the composition is spelled here — and
+// it still calls the one shared mapping rather than restating it.
+function buildBackgroundImage(node) {
+    const descriptor = descriptorFor(IMAGE_TAG);
+    const image = createElement(descriptor.component, descriptor.isText);
+    image.payloadFold = imageFold(node);
+    appendChild(node, image);
+    return image;
+}
+const imageBackgroundBehavior = {
+    slotProps: IMAGE_BACKGROUND_SLOT_PROPS,
+    slotPropsExcept: IMAGE_BACKGROUND_HOST_PROPS,
+    slotDerived: IMAGE_BACKGROUND_SLOT_DERIVED,
+    slotTakesNoChildren: true,
+    buildStructure: buildBackgroundImage,
+    foldPayload: hostFold,
+    // Required by the interface and deliberately empty: this primitive owns no timer, no listener
+    // and no native handshake. Written out rather than shared with a `noop` so the emptiness reads
+    // as a decision.
+    attach() { },
+    detach() { },
+};
+export function registerImageBackgroundBehavior() {
+    registerHostBehavior(IMAGE_BACKGROUND_TAG, imageBackgroundBehavior);
+}

package/build/behaviors/image.d.ts

@@ -1,3 +1,3 @@
-export declare const IMAGE_TAG = "symbiote-image";
+export declare const IMAGE_TAG = "image";
 export declare function foldImagePayload(props: Readonly<Record<string, unknown>>): Record<string, unknown>;
 export declare function registerImageBehavior(): void;

package/build/behaviors/image.js

@@ -10,7 +10,7 @@
 // hand and says so in its own header, because nothing was exported to call.
 //
 // WHY THIS MAY SHARE THE WRAPPER'S TAG, where TextInput needed `-managed`. A behavior fold is keyed
-// on the tag, and `renderImage` emits `symbiote-image` too — so on a wrapper-built node this fold
+// on the tag, and `renderImage` emits `image` too — so on a wrapper-built node this fold
 // runs on ALREADY-FOLDED props. That is safe here and only here, because the mapping is idempotent:
 // every alias it consumes (`src`, `srcSet`, `alt`, `width`, `height`, …) is absent from its own
 // output, `source` comes back in the array shape `normalizeSource` guarantees, and
@@ -20,7 +20,7 @@
 // so the property has to be pinned or it is an accident waiting to be broken.
 import { registerHostBehavior, } from '@symbiote-native/engine';
 import { IMAGE_VIEW_PROP_NAMES, mapImageProps, } from '../view/render-image/index.js';
-export const IMAGE_TAG = 'symbiote-image';
+export const IMAGE_TAG = 'image';
 const RESIZE_MODES = new Set([
     'cover',
     'contain',

package/build/behaviors/input-accessory-view.d.ts

@@ -1,3 +1,3 @@
-export declare const INPUT_ACCESSORY_VIEW_TAG = "symbiote-input-accessory-view";
+export declare const INPUT_ACCESSORY_VIEW_TAG = "input-accessory-view";
 export declare function foldInputAccessoryViewPayload(props: Readonly<Record<string, unknown>>): Record<string, unknown>;
 export declare function registerInputAccessoryViewBehavior(): void;

package/build/behaviors/input-accessory-view.js

@@ -15,7 +15,7 @@
 // nothing can end up with two owners on one node. Idempotence is asserted rather than reasoned.
 //
 // PLATFORM. This is the only primitive in its group that is not platform-invariant in what it
-// COMMITS TO: `symbiote-input-accessory-view` resolves to `RCTInputAccessoryView` on iOS and to a
+// COMMITS TO: `input-accessory-view` resolves to `RCTInputAccessoryView` on iOS and to a
 // plain `RCTView` on Android. The fold itself is platform-invariant on purpose — it reproduces the
 // wrapper's mapping exactly, on both platforms, so the lowered and wrapped paths cannot diverge
 // per-platform. What it does NOT do is fix the pre-existing Android divergence underneath it:
@@ -26,7 +26,7 @@
 // make the two paths disagree.
 import { registerHostBehavior, } from '@symbiote-native/engine';
 import { INPUT_ACCESSORY_VIEW_PROP_NAMES, mapInputAccessoryViewProps, } from '../view/render-input-accessory-view.js';
-export const INPUT_ACCESSORY_VIEW_TAG = 'symbiote-input-accessory-view';
+export const INPUT_ACCESSORY_VIEW_TAG = 'input-accessory-view';
 const CONSUMED = new Set(INPUT_ACCESSORY_VIEW_PROP_NAMES);
 function stringOf(value) {
     return typeof value === 'string' ? value : undefined;

package/build/behaviors/pressable.d.ts

@@ -1,2 +1,60 @@
-export declare const PRESSABLE_TAG = "symbiote-pressable";
+import { type IHostBehavior, type ISymbioteNode } from '@symbiote-native/engine';
+import { type IPressMachineConfig } from '../state/pressable';
+import type { IAccessibilityStateValue } from '../accessibility-props';
+export declare const PRESSABLE_TAG = "pressable";
+/**
+ * A last look at the machine's config before its handlers are built, for a tag that IS a pressable
+ * plus something — TouchableOpacity, whose fade has to run between the machine and the app's own
+ * `onPressIn`.
+ *
+ * Called from `rebuild`, so once per gesture rather than once per mount: it sees the config the
+ * props actually hold by the time a finger lands, and anything it captures is discarded with the
+ * gesture. Per-node state that must OUTLIVE a gesture belongs on the caller's own WeakMap.
+ */
+export type IPressConfigRefinement = (node: ISymbioteNode, config: IPressMachineConfig) => IPressMachineConfig;
+/**
+ * What the machine reads as `disabled`, for a tag whose spelling of it is not the raw prop.
+ *
+ * There is no resolver by default because RN's Pressable hands Pressability the RAW prop
+ * (`Pressable.js:266`) — `aria-disabled` there changes only what is ANNOUNCED. Button is the one
+ * primitive that differs: it resolves `disabled ?? aria-disabled ?? accessibilityState.disabled` in
+ * the component and passes the ANSWER down as the touchable's own prop (`Button.js:337` -> `:386`),
+ * which a single tag has no second node to pass to.
+ *
+ * Reads the bag and returns the answer; it must never write one back. `resolveButtonDisabled`
+ * short-circuits on an authored `disabled`, so a resolved value stored in `node.props.disabled`
+ * would answer the NEXT resolution as if the app had written it and the tag could never re-enable.
+ */
+export type IDisabledResolver = (props: Readonly<Record<string, unknown>>) => boolean | undefined;
+export declare function booleanOr(value: unknown): boolean | undefined;
+export declare function asAccessibilityState(value: unknown): IAccessibilityStateValue | undefined;
+export declare function accessibleUnlessOptedOut(props: Readonly<Record<string, unknown>>): boolean;
+/**
+ * The machine on `node`, reading its props and the app's callbacks off `options.source` when that
+ * is a different node.
+ *
+ * Exported for a behavior whose responder is not its own node — `./touchable-native-feedback`,
+ * whose tag commits nothing and adopts the app's single child as the responder. Every other caller
+ * goes through `createPressBehavior`, where source and node are the same.
+ *
+ * Re-callable on the same node: a second call replaces the state and the dispatchers, which is what
+ * a re-arm after `detachPressMachine` needs.
+ */
+export declare function attachPressMachine(node: ISymbioteNode, options?: {
+    readonly refine?: IPressConfigRefinement;
+    readonly disabledOf?: IDisabledResolver;
+    readonly source?: ISymbioteNode;
+}): void;
+/** See `attachPressMachine`: the same teardown `createPressBehavior` registers as its `detach`. */
+export declare function detachPressMachine(node: ISymbioteNode): void;
+/**
+ * The press machine as behavior parts, so a tag that is a pressable PLUS something can compose it
+ * instead of re-implementing it.
+ *
+ * Spread into the caller's own behavior and wrap `attach`/`detach` around these — the touchable
+ * family needs a per-node Animated value opened before the machine and closed after it. The
+ * WeakMap holding the machine's own state is keyed by node, so one node may hold exactly one of
+ * these; a tag composing it therefore must not also register the plain `pressable` behavior.
+ */
+export declare function createPressBehavior(refine?: IPressConfigRefinement, disabledOf?: IDisabledResolver): Pick<IHostBehavior, 'attach' | 'detach' | 'foldPayload' | 'ownedListeners'>;
 export declare function registerPressableBehavior(): void;

package/build/behaviors/pressable.js

@@ -15,9 +15,9 @@
 // does NOT re-export. A bare `import './register';` sitting NEXT TO such a re-export does not work
 // either: Babel merges the two imports of one specifier and the merged dependency stays lazy.
 import { appListenerFor, dlog, registerHostBehavior, requestCommitFor, setBehaviorListener, setNodePressed, } from '@symbiote-native/engine';
-import { createPressHandlers, createPressRuntime, disposePressRuntime, DEFAULT_DELAY_LONG_PRESS_MS, rippleProps, } from '../state/pressable.js';
-import { buildPressableListeners, resolveDisabledAccessibilityState, } from '../view/render-pressable/index.js';
-export const PRESSABLE_TAG = 'symbiote-pressable';
+import { createPressHandlers, createPressRuntime, disposePressRuntime, DEFAULT_DELAY_LONG_PRESS_MS, DEFAULT_MIN_PRESS_DURATION_MS, rippleProps, } from '../state/pressable.js';
+import { buildPressableListeners, resolveDisabledAccessibilityState, resolvePressableFocusable, } from '../view/render-pressable/index.js';
+export const PRESSABLE_TAG = 'pressable';
 const states = new WeakMap();
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -25,6 +25,12 @@ function isRecord(value) {
 function numberOr(value, fallback) {
     return typeof value === 'number' ? value : fallback;
 }
+// The bag arrives as `unknown` off `node.props`; every RN default below is written against
+// `boolean | undefined`. Exported to the sibling behaviors folding the same bag, and deliberately
+// NOT to the shared barrel — same reasoning as `asAccessibilityState`.
+export function booleanOr(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
 // A scalar offset or the per-edge object; anything else reads as "no offset", which the machine
 // turns into RN's defaults. Same narrowing the component path does — kept here rather than shared
 // because the component's version narrows Vue attrs, and this one narrows engine props.
@@ -61,16 +67,17 @@ const MACHINE_ONLY_KEYS = [
     'disabled',
     'cancelable',
     'delayLongPress',
+    'minPressDuration',
     'unstable_pressDelay',
     'pressRetentionOffset',
     'delayHoverIn',
     'delayHoverOut',
 ];
 // Narrowed field by field rather than cast: the bag arrives as `unknown` off `node.props`. A local
-// twin of the guard each adapter keeps for its own attrs (Vue's `asAccessibilityState`) — not
-// hoisted to the shared barrel, because every adapter re-exports that barrel wholesale and a
-// narrowing helper is not API anyone should be able to import.
-function asAccessibilityState(value) {
+// twin of the guard each adapter keeps for its own attrs (Vue's `asAccessibilityState`) — exported
+// to the sibling behaviors that fold the same bag, and deliberately NOT to the shared barrel, which
+// every adapter re-exports wholesale: a narrowing helper is not API anyone should be able to import.
+export function asAccessibilityState(value) {
     if (!isRecord(value))
         return undefined;
     const state = {};
@@ -135,8 +142,26 @@ function foldPayload(props) {
     // skipping undefined is a coincidence to lean on, not a contract to rely on here.
     if (resolved !== undefined)
         out.accessibilityState = resolved;
+    out.accessible = accessibleUnlessOptedOut(props);
+    // Pressable.js:258 — the plain form, with no press-handler or disabled leg. A Touchable composing
+    // this tag has already resolved its own three-leg formula and passed the answer in as `focusable`,
+    // which `!== false` leaves alone.
+    out.focusable = resolvePressableFocusable(booleanOr(props.focusable));
     return out;
 }
+// RN makes every pressable accessible unless the app opts OUT — `Pressable.js:252`
+// (`accessible: accessible !== false`), and the whole Touchable family repeats it verbatim
+// (`TouchableOpacity.js:303`, `TouchableHighlight.js:337`). `!== false` rather than `?? true`, so
+// only a literal `false` opts out and an explicit `undefined` still reads as accessible.
+//
+// Nothing in this repo did it until 2026-09-09, on either path, so a Pressable reached a screen
+// reader as a plain view unless the app wrote the prop. Landing it in the fold above alone reddens
+// four equivalence arms — correctly, since those compare the wrapper against the lowered path — so
+// the behavior and every adapter's wrapper have to move in ONE change. Exported for the wrappers
+// that need to say it themselves, and for the tags whose behavior is their only path.
+export function accessibleUnlessOptedOut(props) {
+    return props.accessible !== false;
+}
 // From the STASH, not from `node.props`. Every name below is in `ownedListeners`, so `routeProp`
 // diverts the app's `onPress` away from `node.listeners` (where it would evict the behavior's own
 // dispatcher) and into the stash — which makes the stash the only place it exists. Reading
@@ -158,6 +183,11 @@ function configFor(node) {
         onLongPress: callbackAt(node, 'longPress'),
         delayLongPress: numberOr(node.props.delayLongPress, DEFAULT_DELAY_LONG_PRESS_MS),
         unstable_pressDelay: numberOr(node.props.unstable_pressDelay, 0),
+        // RN's Touchables own the deactivation floor in their OWN machine and hand Pressability
+        // `minPressDuration: 0` (TouchableOpacity.js:195). While they were wrappers they passed it as
+        // an internal input; on the tag there is nowhere else to say it, so the floor has to be a
+        // readable prop or every Touchable holds its fade for the machine's 130 ms default.
+        minPressDuration: numberOr(node.props.minPressDuration, DEFAULT_MIN_PRESS_DURATION_MS),
         hitSlop: asRectOffset(node.props.hitSlop),
         pressRetentionOffset: asRectOffset(node.props.pressRetentionOffset),
     };
@@ -170,12 +200,21 @@ function configFor(node) {
 // once the props exist. A gesture is one interaction, so a handful of closures per press is
 // invisible — unlike doing it per prop write, which is the cost this whole tier exists to remove.
 function rebuild(node, state) {
-    const handlers = createPressHandlers(configFor(node), state.runtime, state.host);
+    // `state.source` for everything READ, `node` for the refinement, which acts on the responder
+    // (dispatching a view command needs the committed node, not the one holding the props).
+    const source = state.source;
+    const base = configFor(source);
+    const handlers = createPressHandlers(state.refine === undefined ? base : state.refine(node, base), state.runtime, state.host);
     state.isBuilt = true;
+    // Re-read every gesture, so a tag whose resolver looks past `disabled` — `./button`, at
+    // `aria-disabled` — re-enables on the next touch instead of latching at its first answer.
+    const disabled = state.disabledOf === undefined
+        ? source.props.disabled
+        : state.disabledOf(source.props);
     state.listeners = buildPressableListeners(handlers, {
-        disabled: node.props.disabled === true ? true : undefined,
-        cancelable: typeof node.props.cancelable === 'boolean'
-            ? node.props.cancelable
+        disabled: disabled === true ? true : undefined,
+        cancelable: typeof source.props.cancelable === 'boolean'
+            ? source.props.cancelable
             : undefined,
     });
 }
@@ -228,7 +267,24 @@ function installListeners(node, state) {
         setBehaviorListener(node, event, symbioteEvent => dispatch(node, state, key, [symbioteEvent]));
     }
 }
-function attach(node) {
+function attachWith(refine, disabledOf) {
+    return node => attach(node, { refine, disabledOf });
+}
+/**
+ * The machine on `node`, reading its props and the app's callbacks off `options.source` when that
+ * is a different node.
+ *
+ * Exported for a behavior whose responder is not its own node — `./touchable-native-feedback`,
+ * whose tag commits nothing and adopts the app's single child as the responder. Every other caller
+ * goes through `createPressBehavior`, where source and node are the same.
+ *
+ * Re-callable on the same node: a second call replaces the state and the dispatchers, which is what
+ * a re-arm after `detachPressMachine` needs.
+ */
+export function attachPressMachine(node, options = {}) {
+    attach(node, options);
+}
+function attach(node, options) {
     const timers = new Set();
     const runtime = createPressRuntime();
     const host = {
@@ -264,6 +320,9 @@ function attach(node) {
     const state = {
         runtime,
         host,
+        refine: options.refine,
+        disabledOf: options.disabledOf,
+        source: options.source ?? node,
         timers,
         listeners: {},
         isBuilt: false,
@@ -271,6 +330,10 @@ function attach(node) {
     states.set(node, state);
     installListeners(node, state);
 }
+/** See `attachPressMachine`: the same teardown `createPressBehavior` registers as its `detach`. */
+export function detachPressMachine(node) {
+    detach(node);
+}
 function detach(node) {
     const state = states.get(node);
     if (state === undefined)
@@ -286,11 +349,18 @@ function detach(node) {
     states.delete(node);
     dlog('pressable behavior detached');
 }
-// Idempotent: an adapter entry may be imported more than once in a bundle, and re-registering the
-// same tag with an equivalent behavior must not double-install anything.
-export function registerPressableBehavior() {
-    registerHostBehavior(PRESSABLE_TAG, {
-        attach,
+/**
+ * The press machine as behavior parts, so a tag that is a pressable PLUS something can compose it
+ * instead of re-implementing it.
+ *
+ * Spread into the caller's own behavior and wrap `attach`/`detach` around these — the touchable
+ * family needs a per-node Animated value opened before the machine and closed after it. The
+ * WeakMap holding the machine's own state is keyed by node, so one node may hold exactly one of
+ * these; a tag composing it therefore must not also register the plain `pressable` behavior.
+ */
+export function createPressBehavior(refine, disabledOf) {
+    return {
+        attach: attachWith(refine, disabledOf),
         detach,
         foldPayload,
         // Every name the machine needs as an INPUT. The responder pair is not optional — it is how a
@@ -306,5 +376,10 @@ export function registerPressableBehavior() {
             'responderMove',
             'responderTerminationRequest',
         ],
-    });
+    };
+}
+// Idempotent: an adapter entry may be imported more than once in a bundle, and re-registering the
+// same tag with an equivalent behavior must not double-install anything.
+export function registerPressableBehavior() {
+    registerHostBehavior(PRESSABLE_TAG, createPressBehavior());
 }

package/build/behaviors/refresh-control.d.ts

@@ -0,0 +1,2 @@
+export declare const REFRESH_CONTROL_TAG = "refresh-control";
+export declare function registerRefreshControlBehavior(): void;

package/build/behaviors/refresh-control.js

@@ -0,0 +1,83 @@
+// RefreshControl's machine, on the engine node instead of inside a framework component.
+//
+// WHAT THE FIVE WRAPPERS ACTUALLY DO, counted before writing this — the audit rule's instruction to
+// grep the fold's OUTPUT rather than trust one wrapper. Four of the five (react, vue, solid,
+// svelte) fold exactly `resolveAccessibilityProps` and forward, and that fold ALREADY runs in the
+// engine at `fabricProps` on every path (the aria fold `SafeAreaView`'s spec entry cites). So there
+// is nothing left for a `foldPayload` here to do, and this behavior deliberately declares none.
+//
+// The fifth is Angular, and it is the whole reason this file exists: it alone reproduces RN's
+// CONTROLLED handshake (`RefreshControl.js:145-166`) — mirror what native last reported, and when
+// the app's `refreshing` disagrees, command native back with `setNativeRefreshing`. React, Vue,
+// Solid and Svelte have never had it, so a pull whose handler leaves `refreshing` false spins
+// forever on four of five adapters. Moving it here closes that as a P0 parity gap rather than
+// porting it four more times.
+//
+// ONE COMMAND NAME ON BOTH PLATFORMS — no `Platform.OS` branch, unlike Switch's snap-back
+// (`setValue` / `setNativeValue`). RN sends `setNativeRefreshing` through both
+// `PullToRefreshCommands` and `AndroidSwipeRefreshLayoutCommands` (`RefreshControl.js:152,157`).
+//
+// PLACEMENT IS NOT THIS FILE'S PROBLEM, though the tier audit once filed the primitive as
+// impossible over it. iOS puts the control BESIDE the scroll view's content and Android makes it
+// the scroll view's PARENT, and that decision belongs to the ScrollView, which now states it as
+// data — `claimedChildren: { [REFRESH_CONTROL]: platform.claimMode }` in
+// `behaviors/scroll-view/shared.ts`, honoured by the engine's `appendChild`. A claim is keyed on
+// the child's FABRIC name and needs nothing from the child's own behavior, so the two are
+// independent; `refresh-control-placement.test.ts` pins that both ways round.
+//
+// WHY THE DIVERGENCE CHECK IS DEFERRED A MICROTASK, and why `afterCommit` alone is not enough:
+// `behaviors/switch.ts`'s module header, verbatim. Same shape, same two triggers, same reasons —
+// an ACCEPTING app's state reaches `node.props` only after its own reconciliation, and a REJECTING
+// app writes no prop at all, so the commit that `afterCommit` waits for never comes.
+import { appListenerFor, dispatchViewCommand, dlog, registerHostBehavior, setBehaviorListener, } from '@symbiote-native/engine';
+export const REFRESH_CONTROL_TAG = 'refresh-control';
+// RN's own name for the command, sent to whichever of the two native views the platform resolved.
+const SET_NATIVE_REFRESHING = 'setNativeRefreshing';
+// What native LAST reported, absent until it has reported at all. Absent is not `false`: native is
+// optimistic — it spins on the gesture before JS approves — so only a report can make the mirror
+// authoritative, and an app that drives `refreshing` on its own initiative must never be corrected
+// against a value native never claimed.
+const reported = new WeakMap();
+// Shared by both triggers — see the module header for why there are two.
+function evaluateSnapBack(node) {
+    const lastNativeReport = reported.get(node);
+    if (lastNativeReport === undefined)
+        return; // no report yet, nothing to disagree with
+    const refreshing = node.props.refreshing === true;
+    if (lastNativeReport === refreshing) {
+        dlog(`RefreshControl behavior snap-back no-op refreshing=${refreshing}`);
+        return;
+    }
+    dlog(`RefreshControl behavior ${SET_NATIVE_REFRESHING} reported=${lastNativeReport} refreshing=${refreshing}`);
+    dispatchViewCommand(node, SET_NATIVE_REFRESHING, [refreshing]);
+    reported.set(node, refreshing);
+}
+function onRefresh(node, event) {
+    // Native has already started spinning by the time this arrives (RefreshControl.js:180), so the
+    // mirror moves BEFORE the app's handler runs — a handler that flips `refreshing` to true then
+    // agrees with it, and one that does nothing is what the deferred check corrects.
+    reported.set(node, true);
+    const listener = appListenerFor(node, 'refresh');
+    if (typeof listener === 'function')
+        listener(event);
+    queueMicrotask(() => evaluateSnapBack(node));
+}
+function attach(node) {
+    setBehaviorListener(node, 'refresh', event => onRefresh(node, event));
+}
+function detach(node) {
+    reported.delete(node);
+}
+// Idempotent: an adapter entry may be imported more than once in a bundle, and re-registering the
+// same tag with an equivalent behavior must not double-install anything.
+export function registerRefreshControlBehavior() {
+    registerHostBehavior(REFRESH_CONTROL_TAG, {
+        attach,
+        // Closes the case a microtask scheduled from `onRefresh` cannot: the app moves `refreshing` on
+        // its own while a past report is still unresolved. Costs nothing extra — it fires only on a
+        // commit that already changed something.
+        afterCommit: evaluateSnapBack,
+        detach,
+        ownedListeners: ['refresh'],
+    });
+}

package/build/behaviors/scroll-view/index.android.d.ts

@@ -0,0 +1 @@
+export declare function registerScrollViewBehavior(): void;

package/build/behaviors/scroll-view/index.android.js

@@ -0,0 +1,52 @@
+// ScrollView's behavior on Android, where a RefreshControl is not a child at all.
+//
+// An Android ScrollView holds exactly ONE child, so a sibling refresh control is an `addViewAt`
+// crash rather than a layout mistake. RN inverts the tree instead: `AndroidSwipeRefreshLayout`
+// WRAPS the scroll view, and the scroll view's style is split across the two boxes — layout on the
+// wrapper's frame, visual on the scroller (`ScrollView.js:1856`). `nestedScrollEnabled` goes on the
+// inner view so it consumes the gesture before the refresh parent sees it.
+//
+// The two folds below are what neither node can work out alone: the wrapper is the APP's node, so
+// it carries whatever the app wrote on `<RefreshControl>` and knows nothing about the scroll view's
+// style. RN reaches the same place through `cloneElement`, which likewise OVERRIDES the refresh
+// control's own `style` — so replacing it here is parity, not a liberty.
+import {} from '@symbiote-native/engine';
+import { splitScrollViewStyle } from '../../scroll-view-commands.js';
+import { ownerFold, registerScrollViewBehaviors, } from './shared.js';
+// The owner under a wrap: the ordinary fold with the VISUAL half of its own style in place of the
+// composed one. Delegating rather than restating is what keeps `decelerationRate`, `horizontal` and
+// `nestedScrollEnabled` in ONE place — none of the three has anything to do with the wrap, and the
+// hand-written copy this replaced had already lost the first of them.
+function wrappedOwnerFold(base, horizontal) {
+    const plain = ownerFold(base, horizontal);
+    return props => ({
+        ...plain(props),
+        style: splitScrollViewStyle(base, props.style).inner,
+    });
+}
+// The wrapper: the LAYOUT half of the OWNER's style, read off the owner because that is where the
+// app wrote it. Kept in step by `slotDerived` naming `style`, which marks the wrapper dirty on an
+// owner style write.
+function wrapperFold(owner, base) {
+    return props => ({
+        ...props,
+        style: splitScrollViewStyle(base, owner.props.style).outer,
+    });
+}
+const android = {
+    claimMode: 'wrap',
+    slotDerived: ['style'],
+    onWrapChange: (base, horizontal) => (owner, wrapper) => {
+        // Back to the ordinary composition, not to `undefined` — the plain fold carries the axis and
+        // the gesture props, which have nothing to do with the wrap.
+        owner.payloadFold =
+            wrapper === undefined
+                ? ownerFold(base, horizontal)
+                : wrappedOwnerFold(base, horizontal);
+        if (wrapper !== undefined)
+            wrapper.payloadFold = wrapperFold(owner, base);
+    },
+};
+export function registerScrollViewBehavior() {
+    registerScrollViewBehaviors(android);
+}

package/build/behaviors/scroll-view/index.d.ts

@@ -0,0 +1,2 @@
+export { registerScrollViewBehavior } from './index.ios';
+export { HORIZONTAL_SCROLL_VIEW_TAG, REFRESH_CONTROL, SCROLL_VIEW_TAG, } from './shared';

package/build/behaviors/scroll-view/index.ios.d.ts

@@ -0,0 +1 @@
+export declare function registerScrollViewBehavior(): void;

package/build/behaviors/scroll-view/index.ios.js

@@ -0,0 +1,10 @@
+// ScrollView's behavior on iOS: a RefreshControl is a SIBLING of the content view, rendered before
+// it (`ScrollView.js:1844`). That is the whole platform half — a claim in `beside` mode, and the
+// engine's placement rule already puts a claimed child before the slot.
+//
+// This file is also the base the folder's `index.ts` re-exports for headless, matching
+// `render-scroll-view`'s own choice to make iOS the default for anything platform-branched.
+import { registerScrollViewBehaviors } from './shared.js';
+export function registerScrollViewBehavior() {
+    registerScrollViewBehaviors({ claimMode: 'beside' });
+}

package/build/behaviors/scroll-view/index.js

@@ -0,0 +1,5 @@
+// The base of the folder-as-module group: Metro picks `index.ios` / `index.android` per platform,
+// and everything else (tsx, vitest, headless) lands here. iOS is the default for the same reason
+// `render-scroll-view`'s own `Platform.select` defaults to it.
+export { registerScrollViewBehavior } from './index.ios.js';
+export { HORIZONTAL_SCROLL_VIEW_TAG, REFRESH_CONTROL, SCROLL_VIEW_TAG, } from './shared.js';

package/build/behaviors/scroll-view/shared.d.ts

@@ -0,0 +1,11 @@
+import { type IClaimMode, type IHostBehavior, type IPayloadFold, type IViewStyle } from '@symbiote-native/engine';
+export declare const SCROLL_VIEW_TAG = "scroll-view";
+export declare const HORIZONTAL_SCROLL_VIEW_TAG = "horizontal-scroll-view";
+export declare const REFRESH_CONTROL: string;
+export declare function ownerFold(base: IViewStyle, horizontal: boolean): IPayloadFold;
+export interface IScrollPlatform {
+    claimMode: IClaimMode;
+    onWrapChange?: (base: IViewStyle, horizontal: boolean) => IHostBehavior['onWrapChange'];
+    slotDerived?: readonly string[];
+}
+export declare function registerScrollViewBehaviors(platform: IScrollPlatform): void;