@symbiote-native/engine 0.2.0 → 0.4.0

package/README.md

@@ -9,7 +9,7 @@ current one, clones only what changed, and calls `completeRoot` — the persiste
 dance Fabric requires, done **once**, for every framework.
 
 > New to SymbioteNative? The [root README](../../README.md) has the architecture and the one fact it
-> rests on — React is just *one client* of `nativeFabricUIManager`. This package is what sits
+> rests on — React is just _one client_ of `nativeFabricUIManager`. This package is what sits
 > between every adapter and that native slot.
 
 ---
@@ -48,17 +48,24 @@ The entire surface a renderer seam drives:
 
 ```ts
 import {
-  createElement, createRawText, createAnchor,
-  appendChild, insertBefore, removeChild,
-  routeProp, setEventListener, setProp, setText,
+  createElement,
+  createRawText,
+  createAnchor,
+  appendChild,
+  insertBefore,
+  removeChild,
+  routeProp,
+  setEventListener,
+  setProp,
+  setText,
 } from '@symbiote-native/engine';
 
-const node = createElement('RCTView');          // component IS the Fabric view name
+const node = createElement('RCTView'); // component IS the Fabric view name
 const text = createRawText('Hello');
 appendChild(node, text);
-routeProp(node, 'onPress', () => {});            // ← the flat-bag entry point (React/Vue/Solid):
-                                                  //   decides event-vs-prop via the ViewConfig,
-                                                  //   NOT by the "onX" naming convention
+routeProp(node, 'onPress', () => {}); // ← the flat-bag entry point (React/Vue/Solid):
+//   decides event-vs-prop via the ViewConfig,
+//   NOT by the "onX" naming convention
 ```
 
 `routeProp` is the one call a flat-bag adapter should route every prop through — a **structural**
@@ -72,7 +79,7 @@ import { createSurface } from '@symbiote-native/engine';
 
 const surface = createSurface(rootTag);
 surface.appendChild(root, node);
-surface.commit();          // synchronous — for a framework that already batches (React)
+surface.commit(); // synchronous — for a framework that already batches (React)
 // surface.requestCommit(); // microtask-coalesced — for reactive frameworks (Vue/Svelte/Angular)
 ```
 
@@ -90,15 +97,21 @@ before a tag is guaranteed to exist.
 - **Runtime modules**, framework-agnostic, re-exported by every adapter: `Platform`,
   `StyleSheet` (+ `computeHairlineWidth`), `Dimensions`, `PixelRatio`, `Appearance`, `AppState`,
   `Keyboard`, `AccessibilityInfo`, `BackHandler`, `PermissionsAndroid`, `LayoutAnimation`,
-  `InteractionManager`, `PanResponder`, and the imperative modules `Alert`, `Share`,
+  `InteractionManager`, `PanResponder`, `StatusBar`, and the imperative modules `Alert`, `Share`,
   `ActionSheetIOS`, `Linking`, `Vibration`, `ToastAndroid`, `Settings`, `I18nManager`.
+- **Host behaviors** (`registerHostBehavior` / `IHostBehavior` / `hasHostBehaviors` /
+  `clearHostBehaviors` / `appListenerFor` / `setBehaviorListener` / `requestCommitFor`) — the
+  registry that lets a primitive's state machine live directly on the engine node instead of
+  inside a framework component, so a `Pressable`/`Switch`/`TextInput`/`Image` can compile to a
+  bare intrinsic tag ("host-primitive lowering"). `@symbiote-native/components` registers its
+  behaviors against this seam; the engine never imports them back.
 - **`Animated`** — both the JS and native driver (`timing` / `spring` / `decay` / `loop` /
   `ValueXY` / tracking / `diffClamp` / `Easing`), including the native-event attachment path
   (`attachNativeEvent`, `AnimatedEvent`).
 - **The style pipeline** — `flattenStyle`, the CSS-style processors RN itself runs in JS
   (`processBoxShadow`, `processFilter`, `processTransform`, `processTransformOrigin`,
   `processAspectRatio`, `processFontVariant`, `processBackgroundImage`), and the runtime
-  **class-name registry** (`registerStyles` / `resolveClassName` / `scopeClassName`) that
+  **class-name registry** (`registerRules` / `resolveClassName` / `renameClassTokens`) that
   `@symbiote-native/css-parser`'s build-time output resolves against — shared by every adapter's
   `class` / `className` / `addClass` prop path.
 - **`AppRegistry` core** (`createAppRegistry`) — registry bookkeeping + headless-task plumbing;

package/build/accessibility-props.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Whether one key is an alias this fold consumes. `startsWith` rather than a Set lookup: this runs
+ * on `setProp`, the hottest write path in the engine (32 001 writes on one benchmark create), and
+ * it is guarded by the node's sticky flag so it is reached at most once per node per key. The
+ * `role` comparison comes first because it is the one alias with no prefix.
+ */
+export declare function isAriaAliasKey(key: string): boolean;
+/**
+ * Fold the web-alias `aria-*` / `role` props into RN's canonical `accessibility*` props.
+ *
+ * Returns the input BY IDENTITY when no alias is present — the fast path that keeps this off the
+ * hot path for the ~99% of nodes carrying none, and the property idempotence rests on: pass 1
+ * blanks every alias, so a second pass finds nothing and returns by identity again.
+ *
+ * The alias keys are blanked to `undefined` rather than deleted. That is not laziness: `setProp`
+ * treats an `undefined` write as a delete and `fabricProps` skips undefined, so a blanked alias
+ * cannot reach Fabric, while a `delete` would deoptimise the object's shape on every folded node.
+ */
+export declare function foldAriaProps(props: Record<string, unknown>): Record<string, unknown>;

package/build/accessibility-props.js

@@ -0,0 +1,209 @@
+// RN's `aria-*` / `role` -> `accessibility*` fold, at the layer every path goes through.
+//
+// WHY IT IS HERE AND NOT IN A WRAPPER. It used to run inside each primitive's COMPONENT, which is
+// exactly the layer host-primitive lowering removes. A per-attribute element path cannot do it —
+// `aria-checked` has to be folded against a sibling `accessibilityState` — so the four lowering
+// transforms REFUSED any element carrying `role` or an `aria-*` attribute
+// (`REFUSAL_CATEGORIES.bagFold`). Accessibility props are ordinary in real code, so that refusal
+// cost lowering coverage on every primitive, including the three already lowered. Moving the fold
+// down deletes the refusal instead of teaching four transforms a bag operation they cannot express.
+//
+// IT IS A MOVE, NOT A REWRITE, AND THAT IS DELIBERATE. The function carries TWO CONTRADICTORY
+// PRECEDENCE RULES: for the scalars an explicit `accessibility*` WINS and the alias only fills a
+// hole (`if (next.X === undefined)`), while INSIDE the `accessibilityState` / `accessibilityValue`
+// composites the ALIAS wins per field (`ariaBusy ?? existing?.busy`). Both mirror RN's View.js.
+// Anyone "cleaning this up" collapses them into one rule, and every component test stays green
+// while real accessibility silently changes. `core/components/src/accessibility-props.test.ts`
+// pins both directions; read it before touching the branches below.
+//
+// Record-level rather than typed, because the engine's caller has a raw `node.props` bag and an
+// interface is not assignable to `Record<string, unknown>` (no index signature). The typed
+// `resolveAccessibilityProps<T>` in `core/components` stays where adapters already import it and
+// delegates here, keeping its own typed gate so the fast path allocates nothing.
+import { dlog } from './debug.js';
+// Copied line for line from the wrapper this replaces. The first copy silently dropped five
+// entries (`button`, `grid`, `link`, `list`, `listitem`) — a role that falls through simply passes
+// unmapped, so `role="listitem"` would have reached Fabric as `listitem` instead of `list` with
+// nothing red anywhere. Diff this against RN's View.js rather than reading it for plausibility.
+const ROLE_TO_ACCESSIBILITY_ROLE = {
+    alert: 'alert',
+    button: 'button',
+    checkbox: 'checkbox',
+    combobox: 'combobox',
+    grid: 'grid',
+    heading: 'header',
+    img: 'image',
+    link: 'link',
+    list: 'list',
+    listitem: 'list',
+    menu: 'menu',
+    menubar: 'menubar',
+    menuitem: 'menuitem',
+    none: 'none',
+    presentation: 'none',
+    progressbar: 'progressbar',
+    radio: 'radio',
+    radiogroup: 'radiogroup',
+    scrollbar: 'scrollbar',
+    searchbox: 'search',
+    slider: 'adjustable',
+    spinbutton: 'spinbutton',
+    summary: 'summary',
+    switch: 'switch',
+    tab: 'tab',
+    tablist: 'tablist',
+    timer: 'timer',
+    toolbar: 'toolbar',
+};
+const ARIA_KEYS = [
+    'role',
+    'aria-label',
+    'aria-labelledby',
+    'aria-live',
+    'aria-hidden',
+    'aria-busy',
+    'aria-checked',
+    'aria-disabled',
+    'aria-expanded',
+    'aria-selected',
+    'aria-modal',
+    'aria-valuemax',
+    'aria-valuemin',
+    'aria-valuenow',
+    'aria-valuetext',
+];
+// An indexed loop rather than `.some(key => …)`: the callback captures `props`, so a closure is
+// allocated per call, and this is the gate on a path that runs once per node.
+function hasAnyAriaKey(props) {
+    for (let index = 0; index < ARIA_KEYS.length; index += 1) {
+        if (props[ARIA_KEYS[index]] !== undefined)
+            return true;
+    }
+    return false;
+}
+/**
+ * Whether one key is an alias this fold consumes. `startsWith` rather than a Set lookup: this runs
+ * on `setProp`, the hottest write path in the engine (32 001 writes on one benchmark create), and
+ * it is guarded by the node's sticky flag so it is reached at most once per node per key. The
+ * `role` comparison comes first because it is the one alias with no prefix.
+ */
+export function isAriaAliasKey(key) {
+    return key === 'role' || key.startsWith('aria-');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function fieldOf(source, field) {
+    return isRecord(source) ? source[field] : undefined;
+}
+/**
+ * Fold the web-alias `aria-*` / `role` props into RN's canonical `accessibility*` props.
+ *
+ * Returns the input BY IDENTITY when no alias is present — the fast path that keeps this off the
+ * hot path for the ~99% of nodes carrying none, and the property idempotence rests on: pass 1
+ * blanks every alias, so a second pass finds nothing and returns by identity again.
+ *
+ * The alias keys are blanked to `undefined` rather than deleted. That is not laziness: `setProp`
+ * treats an `undefined` write as a delete and `fabricProps` skips undefined, so a blanked alias
+ * cannot reach Fabric, while a `delete` would deoptimise the object's shape on every folded node.
+ */
+export function foldAriaProps(props) {
+    if (!hasAnyAriaKey(props))
+        return props;
+    const bag = { ...props };
+    dlog('foldAriaProps: folding aria/role aliases into accessibility* props');
+    const role = bag.role;
+    const ariaLabel = bag['aria-label'];
+    const ariaLabelledBy = bag['aria-labelledby'];
+    const ariaLive = bag['aria-live'];
+    const ariaHidden = bag['aria-hidden'];
+    const ariaBusy = bag['aria-busy'];
+    const ariaChecked = bag['aria-checked'];
+    const ariaDisabled = bag['aria-disabled'];
+    const ariaExpanded = bag['aria-expanded'];
+    const ariaSelected = bag['aria-selected'];
+    const ariaModal = bag['aria-modal'];
+    const ariaValueMax = bag['aria-valuemax'];
+    const ariaValueMin = bag['aria-valuemin'];
+    const ariaValueNow = bag['aria-valuenow'];
+    const ariaValueText = bag['aria-valuetext'];
+    for (let index = 0; index < ARIA_KEYS.length; index += 1) {
+        bag[ARIA_KEYS[index]] = undefined;
+    }
+    // RULE ONE, for every scalar: the explicit prop WINS, the alias only fills a hole.
+    if (typeof ariaLabelledBy === 'string' &&
+        bag.accessibilityLabelledBy === undefined) {
+        bag.accessibilityLabelledBy = ariaLabelledBy.split(/\s*,\s*/g);
+    }
+    if (ariaLabel !== undefined && bag.accessibilityLabel === undefined) {
+        bag.accessibilityLabel = ariaLabel;
+    }
+    if (ariaLive !== undefined && bag.accessibilityLiveRegion === undefined) {
+        bag.accessibilityLiveRegion = ariaLive === 'off' ? 'none' : ariaLive;
+    }
+    // One input, TWO outputs, and the second is conditional on the VALUE rather than on presence.
+    if (ariaHidden !== undefined) {
+        if (bag.accessibilityElementsHidden === undefined) {
+            bag.accessibilityElementsHidden = ariaHidden;
+        }
+        if (ariaHidden === true && bag.importantForAccessibility === undefined) {
+            bag.importantForAccessibility = 'no-hide-descendants';
+        }
+    }
+    if (ariaModal !== undefined && bag.accessibilityViewIsModal === undefined) {
+        bag.accessibilityViewIsModal = ariaModal;
+    }
+    if (typeof role === 'string' && bag.accessibilityRole === undefined) {
+        bag.accessibilityRole = ROLE_TO_ACCESSIBILITY_ROLE[role] ?? role;
+    }
+    // RULE TWO, INSIDE the composites: the polarity INVERTS and the ALIAS wins per field. Read from
+    // the ORIGINAL props, not from `bag` — the loop above has already blanked the aliases there.
+    //
+    // UPSTREAM-BUG(react-native): View.js:96 is `checked: ariaChecked ?? accessibilityState?.checked`
+    // — NO type coercion. A template writes `aria-checked="true"` as a STRING in every framework we
+    // support, so `accessibilityState.checked` reaches native as `'true'` where the native side
+    // declares `boolean | 'mixed'`. Ported verbatim for parity; do NOT add a cast without recording
+    // a deliberate divergence. Found by the Svelte session 2026-08-31 and pinned as an ASSERTION in
+    // `adapters/svelte/src/aria-fold-parity.test.ts`, so a future decision to coerce shows up as a
+    // failing test at the point the decision was made rather than as a silent behaviour change.
+    //
+    // A SECOND, SMALLER DIVERGENCE, and this one is ours rather than upstream's — it predates the
+    // move down and is kept only because changing it here would be an undeclared behaviour change:
+    // upstream gates the composite on `!= null` (View.js:87-92) and this gates on `!== undefined`.
+    // So an explicit `aria-busy={null}` builds an all-undefined `accessibilityState` here and builds
+    // nothing upstream. The VALUES agree either way — `??` treats null and undefined alike — so only
+    // the composite's existence differs.
+    //
+    // The composite is REPLACED by a fresh literal listing exactly the known fields, so an unknown
+    // field riding on the incoming object is dropped. Faithful to RN and pinned by a test; it is the
+    // shape of bug that only shows for whoever passes a field RN adds later.
+    const existingState = fieldOf(props, 'accessibilityState');
+    if (existingState !== undefined ||
+        ariaBusy !== undefined ||
+        ariaChecked !== undefined ||
+        ariaDisabled !== undefined ||
+        ariaExpanded !== undefined ||
+        ariaSelected !== undefined) {
+        bag.accessibilityState = {
+            busy: ariaBusy ?? fieldOf(existingState, 'busy'),
+            checked: ariaChecked ?? fieldOf(existingState, 'checked'),
+            disabled: ariaDisabled ?? fieldOf(existingState, 'disabled'),
+            expanded: ariaExpanded ?? fieldOf(existingState, 'expanded'),
+            selected: ariaSelected ?? fieldOf(existingState, 'selected'),
+        };
+    }
+    const existingValue = fieldOf(props, 'accessibilityValue');
+    if (existingValue !== undefined ||
+        ariaValueMax !== undefined ||
+        ariaValueMin !== undefined ||
+        ariaValueNow !== undefined ||
+        ariaValueText !== undefined) {
+        bag.accessibilityValue = {
+            max: ariaValueMax ?? fieldOf(existingValue, 'max'),
+            min: ariaValueMin ?? fieldOf(existingValue, 'min'),
+            now: ariaValueNow ?? fieldOf(existingValue, 'now'),
+            text: ariaValueText ?? fieldOf(existingValue, 'text'),
+        };
+    }
+    return bag;
+}

package/build/action-sheet-ios/index.js

@@ -41,7 +41,10 @@ export const ActionSheetIOS = {
         else if (typeof destructiveButtonIndex === 'number') {
             destructiveButtonIndices = [destructiveButtonIndex];
         }
-        const nativeOptions = { ...remainingOptions, destructiveButtonIndices };
+        const nativeOptions = {
+            ...remainingOptions,
+            destructiveButtonIndices,
+        };
         manager.showActionSheetWithOptions(nativeOptions, buttonIndex => {
             dlog(`ActionSheetIOS callback buttonIndex=${buttonIndex}`);
             callback(buttonIndex);

package/build/animated/animations/composition.js

@@ -211,7 +211,9 @@ export function loop(animation, config = {}) {
                 return;
             }
             const restart = (result = { finished: true }) => {
-                if (isFinished || iterationsSoFar === iterations || result.finished === false) {
+                if (isFinished ||
+                    iterationsSoFar === iterations ||
+                    result.finished === false) {
                     callback?.(result);
                 }
                 else {

package/build/animated/animations/spring-config.js

@@ -34,7 +34,10 @@ export function fromBouncinessAndSpeed(bounciness, speed) {
         return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
     }
     function b3Friction3(x) {
-        return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;
+        return (0.00000045 * Math.pow(x, 3) -
+            0.000332 * Math.pow(x, 2) +
+            0.1078 * x +
+            5.84);
     }
     function b3Nobounce(tension) {
         if (tension <= 18)

package/build/animated/animations/spring.js

@@ -6,10 +6,12 @@
 // continuous. The native-config export is dropped.
 import { dlog } from '../../debug.js';
 import { BaseAnimation } from './base.js';
-import { cancelFrame, clearTimer, requestFrame, setTimer } from './raf.js';
-import { fromBouncinessAndSpeed, fromOrigamiTensionAndFriction } from './spring-config.js';
+import { cancelFrame, clearTimer, requestFrame, setTimer, } from './raf.js';
+import { fromBouncinessAndSpeed, fromOrigamiTensionAndFriction, } from './spring-config.js';
 function resolveStiffnessDampingMass(config) {
-    if (config.stiffness !== undefined || config.damping !== undefined || config.mass !== undefined) {
+    if (config.stiffness !== undefined ||
+        config.damping !== undefined ||
+        config.mass !== undefined) {
         return {
             stiffness: config.stiffness ?? 100,
             damping: config.damping ?? 10,
@@ -18,10 +20,18 @@ function resolveStiffnessDampingMass(config) {
     }
     if (config.bounciness !== undefined || config.speed !== undefined) {
         const springConfig = fromBouncinessAndSpeed(config.bounciness ?? 8, config.speed ?? 12);
-        return { stiffness: springConfig.stiffness, damping: springConfig.damping, mass: 1 };
+        return {
+            stiffness: springConfig.stiffness,
+            damping: springConfig.damping,
+            mass: 1,
+        };
     }
     const springConfig = fromOrigamiTensionAndFriction(config.tension ?? 40, config.friction ?? 7);
-    return { stiffness: springConfig.stiffness, damping: springConfig.damping, mass: 1 };
+    return {
+        stiffness: springConfig.stiffness,
+        damping: springConfig.damping,
+        mass: 1,
+    };
 }
 export class SpringAnimation extends BaseAnimation {
     overshootClamping;
@@ -141,7 +151,8 @@ export class SpringAnimation extends BaseAnimation {
             position =
                 this.toValue -
                     envelope *
-                        (((v0 + zeta * omega0 * x0) / omega1) * Math.sin(omega1 * t) + x0 * Math.cos(omega1 * t));
+                        (((v0 + zeta * omega0 * x0) / omega1) * Math.sin(omega1 * t) +
+                            x0 * Math.cos(omega1 * t));
             velocity =
                 zeta *
                     omega0 *
@@ -149,13 +160,15 @@ export class SpringAnimation extends BaseAnimation {
                     ((Math.sin(omega1 * t) * (v0 + zeta * omega0 * x0)) / omega1 +
                         x0 * Math.cos(omega1 * t)) -
                     envelope *
-                        (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) - omega1 * x0 * Math.sin(omega1 * t));
+                        (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) -
+                            omega1 * x0 * Math.sin(omega1 * t));
         }
         else {
             // Critically damped.
             const envelope = Math.exp(-omega0 * t);
             position = this.toValue - envelope * (x0 + (v0 + omega0 * x0) * t);
-            velocity = envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0));
+            velocity =
+                envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0));
         }
         this.lastTime = now;
         this.lastPosition = position;
@@ -177,7 +190,8 @@ export class SpringAnimation extends BaseAnimation {
         const isVelocity = Math.abs(velocity) <= this.restSpeedThreshold;
         let isDisplacement = true;
         if (this.stiffness !== 0) {
-            isDisplacement = Math.abs(this.toValue - position) <= this.restDisplacementThreshold;
+            isDisplacement =
+                Math.abs(this.toValue - position) <= this.restDisplacementThreshold;
         }
         if (isOvershooting || (isVelocity && isDisplacement)) {
             if (this.stiffness !== 0) {

package/build/animated/animations/timing.js

@@ -5,7 +5,7 @@
 import { Easing } from '../easing.js';
 import { dlog } from '../../debug.js';
 import { BaseAnimation } from './base.js';
-import { cancelFrame, clearTimer, requestFrame, setTimer } from './raf.js';
+import { cancelFrame, clearTimer, requestFrame, setTimer, } from './raf.js';
 let cachedEaseInOut;
 function easeInOut() {
     if (cachedEaseInOut === undefined) {
@@ -80,7 +80,8 @@ export class TimingAnimation extends BaseAnimation {
             return;
         }
         this.onUpdate(this.fromValue +
-            this.easing((now - this.startTime) / this.duration) * (this.toValue - this.fromValue));
+            this.easing((now - this.startTime) / this.duration) *
+                (this.toValue - this.fromValue));
         if (this.__active) {
             this.animationFrame = requestFrame(() => this.onFrame());
         }

package/build/animated/bezier.js

@@ -40,7 +40,8 @@ function binarySubdivide(x, lower, upper, mX1, mX2) {
         else {
             lo = currentT;
         }
-    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+    } while (Math.abs(currentX) > SUBDIVISION_PRECISION &&
+        ++i < SUBDIVISION_MAX_ITERATIONS);
     return currentT;
 }
 function newtonRaphsonIterate(x, guess, mX1, mX2) {

package/build/animated/color.js

@@ -11,7 +11,7 @@ import { DEFAULT_COLOR, normalizeColor } from './rgba.js';
 // live in the dependency-free ./rgba leaf (see its header for the cycle it breaks).
 export { normalizeColor };
 function isRgbaInput(value) {
-    return typeof value === 'object' && value !== null && 'r' in value && 'g' in value;
+    return (typeof value === 'object' && value !== null && 'r' in value && 'g' in value);
 }
 function toChannel(value) {
     return value instanceof AnimatedValue ? value : new AnimatedValue(value);
@@ -59,7 +59,9 @@ export class AnimatedColor extends AnimatedWithChildren {
     // pattern). flushValue dedupes by leaf identity, so a single flush rebuilds
     // every bound prop once even though four channels changed.
     setValue(value) {
-        const rgba = typeof value === 'object' ? value : (normalizeColor(value) ?? DEFAULT_COLOR);
+        const rgba = typeof value === 'object'
+            ? value
+            : (normalizeColor(value) ?? DEFAULT_COLOR);
         this.withSuspendedCallbacks(() => {
             this.r.setValue(rgba.r);
             this.g.setValue(rgba.g);

package/build/animated/event.js

@@ -17,14 +17,16 @@ import { dlog } from '../debug.js';
 import { getNativeTag, whenCommitted } from '../commit.js';
 import { isSymbioteNode } from '../node.js';
 import { AnimatedNode, flushValue } from './graph.js';
-import { isNativeAnimatedAvailable, nativeAnimated } from './native/native-animated.js';
+import { isNativeAnimatedAvailable, nativeAnimated, } from './native/native-animated.js';
 import { isRecord } from '../type-guards.js';
 // A value node settable from an event field. AnimatedValue carries setValue; we
 // duck-type it (rather than importing AnimatedValue) to keep this leaf-agnostic
 // and avoid a value<->event import cycle.
 function settableValue(node) {
     const candidate = Reflect.get(node, 'setValue');
-    return typeof candidate === 'function' ? value => candidate.call(node, value) : undefined;
+    return typeof candidate === 'function'
+        ? value => candidate.call(node, value)
+        : undefined;
 }
 // Walk the mapping to every leaf AnimatedNode, recording its key path. Shared by
 // the JS handler (to set values) and the native attach (to register paths).
@@ -128,7 +130,9 @@ export class AnimatedEvent {
             if (!this.attachedNatively) {
                 // Paths are stored relative to `nativeEvent` (the native module excludes
                 // that prefix); the JS event arg still carries it, so re-add it here.
-                const nativeEvent = isRecord(args[0]) ? Reflect.get(args[0], 'nativeEvent') : undefined;
+                const nativeEvent = isRecord(args[0])
+                    ? Reflect.get(args[0], 'nativeEvent')
+                    : undefined;
                 for (const mapped of this.mappedValues) {
                     const extracted = extractAtPath(nativeEvent, mapped.path);
                     if (extracted === undefined)

package/build/animated/graph.js

@@ -10,7 +10,7 @@
 //   B) bottom-up: each flagged leaf re-pulls its whole subtree via __getValue()
 //      to rebuild composite props (e.g. transform from many parents).
 import { generateNativeNodeTag, nativeAnimated, } from './native/native-animated.js';
-import { checkValidRanges, createInterpolation } from './interpolation.js';
+import { checkValidRanges, createInterpolation, } from './interpolation.js';
 import { dlog } from '../debug.js';
 let nextListenerId = 1;
 // Depth of the currently-active withSuspendedCallbacks blocks. While > 0, a
@@ -81,7 +81,10 @@ export class AnimatedNode {
             // (AnimatedNode.js:146-148) rather than in each node's config method.
             const config = this.platformConfig === undefined
                 ? this.__getNativeConfig()
-                : { ...this.__getNativeConfig(), platformConfig: this.platformConfig };
+                : {
+                    ...this.__getNativeConfig(),
+                    platformConfig: this.platformConfig,
+                };
             nativeAnimated.createAnimatedNode(this.nativeTag, config);
         }
         return this.nativeTag;
@@ -221,7 +224,9 @@ function numericValueOf(node) {
 // under useDefineForClassFields. So leaves are detected structurally instead.
 function leafUpdate(node) {
     const candidate = Reflect.get(node, 'update');
-    return typeof candidate === 'function' ? () => candidate.call(node) : undefined;
+    return typeof candidate === 'function'
+        ? () => candidate.call(node)
+        : undefined;
 }
 // Top-down walk to the leaves, then re-pull each leaf (deduped by node identity,
 // so a diamond in the graph still updates a leaf once). Suppressed inside a

package/build/animated/index.d.ts

@@ -14,7 +14,7 @@ export { AnimatedTracking } from './animations/tracking';
 export { timing, spring, decay, parallel, sequence, stagger, loop, delay, type ICompositeAnimation, type ITimingConfig, type ISpringConfig, type IDecayConfig, type IParallelConfig, type ILoopAnimationConfig, } from './animations/composition';
 export { nativeAnimated, isNativeAnimatedAvailable, type INativeNodeConfig, type INativeAnimationConfig, type INativeEventMapping, type IPlatformConfig, } from './native/native-animated';
 export { AnimatedProps } from './props';
-export { createAnimatedLeafLifecycle, type IAnimatedLeafLifecycle } from './leaf-lifecycle';
+export { createAnimatedLeafLifecycle, type IAnimatedLeafLifecycle, } from './leaf-lifecycle';
 export { AnimatedStyle, AnimatedTransform } from './style';
 export { AnimatedMock } from './mock';
-export { reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode } from './shared';
+export { reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './shared';

package/build/animated/index.js

@@ -21,8 +21,8 @@ export { nativeAnimated, isNativeAnimatedAvailable, } from './native/native-anim
 // no React/Vue). They live here with the rest of the graph; every adapter's
 // createAnimatedComponent + Animated namespace re-exports them.
 export { AnimatedProps } from './props.js';
-export { createAnimatedLeafLifecycle } from './leaf-lifecycle.js';
+export { createAnimatedLeafLifecycle, } from './leaf-lifecycle.js';
 export { AnimatedStyle, AnimatedTransform } from './style.js';
 export { AnimatedMock } from './mock.js';
 // Framework-agnostic createAnimatedComponent helpers. Both adapters import them.
-export { reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode } from './shared.js';
+export { reduceProps, isAnimatedNode, readPassthroughStyle, resolveHostNode, } from './shared.js';

package/build/animated/interpolation.js

@@ -171,7 +171,9 @@ function createStringInterpolation(config, outputRange) {
         return input => {
             const values = interpolations.map(interpolation => interpolation(input));
             let i = 0;
-            return template.map(c => (typeof c === 'number' ? values[i++] : c)).join('');
+            return template
+                .map(c => (typeof c === 'number' ? values[i++] : c))
+                .join('');
         };
     }
     // Colors: r,g,b must be integers, so round them; alpha stays continuous but is
@@ -195,5 +197,8 @@ export function createInterpolation(config) {
     if (isStringOutputRange(config.outputRange)) {
         return createStringInterpolation(config, config.outputRange);
     }
-    return createNumericInterpolation({ ...config, outputRange: config.outputRange });
+    return createNumericInterpolation({
+        ...config,
+        outputRange: config.outputRange,
+    });
 }

package/build/animated/mock.js

@@ -11,7 +11,7 @@ import { AnimatedValueXY } from './value-xy.js';
 import { AnimatedColor } from './color.js';
 import { AnimatedNode } from './graph.js';
 import { Easing } from './easing.js';
-import { add, subtract, multiply, divide, modulo, diffClamp } from './operators.js';
+import { add, subtract, multiply, divide, modulo, diffClamp, } from './operators.js';
 import { event, forkEvent, unforkEvent } from './event.js';
 import { dlog } from '../debug.js';
 // Prevent a callback invocation from recursively triggering another callback,

package/build/animated/native/native-animated.js

@@ -11,7 +11,7 @@
 // native host) is inert until a native-driven animation actually starts.
 import { dlog } from '../../debug.js';
 import { getNativeModule } from '../../native-modules/index.js';
-import { NativeEventEmitter } from '../../native-events.js';
+import { NativeEventEmitter, } from '../../native-events.js';
 import { isRecord } from '../../type-guards.js';
 // iOS bridgeless registers the Turbo variant; the legacy name is the fallback.
 const TURBO_MODULE_NAME = 'NativeAnimatedTurboModule';