@symbiote-native/engine 0.2.0 → 0.3.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)
 ```
 
@@ -98,7 +105,7 @@ before a tag is guaranteed to exist.
 - **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/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';

package/build/animated/operators.js

@@ -57,7 +57,10 @@ export class AnimatedAddition extends AnimatedBinaryOp {
         return a + b;
     }
     __getNativeConfig() {
-        return { type: 'addition', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
+        return {
+            type: 'addition',
+            input: [this.a.__getNativeTag(), this.b.__getNativeTag()],
+        };
     }
 }
 export class AnimatedSubtraction extends AnimatedBinaryOp {
@@ -65,7 +68,10 @@ export class AnimatedSubtraction extends AnimatedBinaryOp {
         return a - b;
     }
     __getNativeConfig() {
-        return { type: 'subtraction', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
+        return {
+            type: 'subtraction',
+            input: [this.a.__getNativeTag(), this.b.__getNativeTag()],
+        };
     }
 }
 export class AnimatedMultiplication extends AnimatedBinaryOp {
@@ -73,7 +79,10 @@ export class AnimatedMultiplication extends AnimatedBinaryOp {
         return a * b;
     }
     __getNativeConfig() {
-        return { type: 'multiplication', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
+        return {
+            type: 'multiplication',
+            input: [this.a.__getNativeTag(), this.b.__getNativeTag()],
+        };
     }
 }
 export class AnimatedDivision extends AnimatedBinaryOp {
@@ -97,7 +106,10 @@ export class AnimatedDivision extends AnimatedBinaryOp {
         return a / b;
     }
     __getNativeConfig() {
-        return { type: 'division', input: [this.a.__getNativeTag(), this.b.__getNativeTag()] };
+        return {
+            type: 'division',
+            input: [this.a.__getNativeTag(), this.b.__getNativeTag()],
+        };
     }
 }
 export class AnimatedModulo extends AnimatedWithChildren {
@@ -127,7 +139,11 @@ export class AnimatedModulo extends AnimatedWithChildren {
         super.__makeNative(platformConfig);
     }
     __getNativeConfig() {
-        return { type: 'modulus', input: this.a.__getNativeTag(), modulus: this.modulus };
+        return {
+            type: 'modulus',
+            input: this.a.__getNativeTag(),
+            modulus: this.modulus,
+        };
     }
 }
 export class AnimatedDiffClamp extends AnimatedWithChildren {
@@ -167,7 +183,12 @@ export class AnimatedDiffClamp extends AnimatedWithChildren {
         super.__makeNative(platformConfig);
     }
     __getNativeConfig() {
-        return { type: 'diffclamp', input: this.a.__getNativeTag(), min: this.min, max: this.max };
+        return {
+            type: 'diffclamp',
+            input: this.a.__getNativeTag(),
+            min: this.min,
+            max: this.max,
+        };
     }
 }
 export function add(a, b) {

package/build/animated/props.js

@@ -15,7 +15,7 @@ import { AnimatedNode, AnimatedWithChildren } from './graph.js';
 import { setNativeProps, getNativeTag } from '../commit.js';
 import { isSymbioteNode } from '../node.js';
 import { registerPostCommit } from '../post-commit.js';
-import { nativeAnimated } from './native/native-animated.js';
+import { nativeAnimated, } from './native/native-animated.js';
 import { AnimatedStyle } from './style.js';
 function isAnimatedNode(value) {
     return value instanceof AnimatedNode;

package/build/animated/rgba.js

@@ -16,7 +16,12 @@ export const DEFAULT_COLOR = { r: 0, g: 0, b: 0, a: 1 };
 export function normalizeColor(color) {
     if (typeof color === 'number') {
         const c = color >>> 0;
-        return { r: (c >>> 24) & 255, g: (c >>> 16) & 255, b: (c >>> 8) & 255, a: (c & 255) / 255 };
+        return {
+            r: (c >>> 24) & 255,
+            g: (c >>> 16) & 255,
+            b: (c >>> 8) & 255,
+            a: (c & 255) / 255,
+        };
     }
     const trimmed = color.trim();
     if (trimmed.startsWith('#'))
@@ -42,7 +47,12 @@ function parseHex(hex) {
         return { r: (int >>> 16) & 255, g: (int >>> 8) & 255, b: int & 255, a: 1 };
     }
     const c = int >>> 0;
-    return { r: (c >>> 24) & 255, g: (c >>> 16) & 255, b: (c >>> 8) & 255, a: (c & 255) / 255 };
+    return {
+        r: (c >>> 24) & 255,
+        g: (c >>> 16) & 255,
+        b: (c >>> 8) & 255,
+        a: (c & 255) / 255,
+    };
 }
 function parseRgb(str) {
     const match = /^rgba?\(([^)]+)\)$/i.exec(str);
@@ -51,5 +61,10 @@ function parseRgb(str) {
     const parts = match[1].split(',').map(part => Number.parseFloat(part.trim()));
     if (parts.length < 3 || parts.some(n => Number.isNaN(n)))
         return undefined;
-    return { r: parts[0], g: parts[1], b: parts[2], a: parts.length >= 4 ? parts[3] : 1 };
+    return {
+        r: parts[0],
+        g: parts[1],
+        b: parts[2],
+        a: parts.length >= 4 ? parts[3] : 1,
+    };
 }

package/build/animated/style.js

@@ -73,7 +73,9 @@ export class AnimatedTransform extends AnimatedWithChildren {
             const result = {};
             for (const key of Object.keys(entry)) {
                 const value = entry[key];
-                result[key] = isAnimatedNode(value) ? value.__getAnimatedValue() : value;
+                result[key] = isAnimatedNode(value)
+                    ? value.__getAnimatedValue()
+                    : value;
             }
             return result;
         });
@@ -96,10 +98,18 @@ export class AnimatedTransform extends AnimatedWithChildren {
                 const value = entry[key];
                 if (isAnimatedNode(value)) {
                     // __getNativeTag only: creation is edge-free; the connect is a later phase.
-                    transforms.push({ type: 'animated', property: key, nodeTag: value.__getNativeTag() });
+                    transforms.push({
+                        type: 'animated',
+                        property: key,
+                        nodeTag: value.__getNativeTag(),
+                    });
                 }
                 else {
-                    transforms.push({ type: 'static', property: key, value: transformDataType(value) });
+                    transforms.push({
+                        type: 'static',
+                        property: key,
+                        value: transformDataType(value),
+                    });
                 }
             }
         }

package/build/animated/value-xy.d.ts

@@ -26,10 +26,13 @@ export declare class AnimatedValueXY {
         left: AnimatedValue;
         top: AnimatedValue;
     };
-    getTranslateTransform(): [{
-        translateX: AnimatedValue;
-    }, {
-        translateY: AnimatedValue;
-    }];
+    getTranslateTransform(): [
+        {
+            translateX: AnimatedValue;
+        },
+        {
+            translateY: AnimatedValue;
+        }
+    ];
 }
 export {};

package/build/animated/value-xy.js

@@ -17,7 +17,10 @@ export class AnimatedValueXY {
     // Each joint id maps to the two per-axis listener ids it registered, so
     // removeListener can tear both down together.
     jointListeners = new Map();
-    constructor(value = { x: 0, y: 0 }) {
+    constructor(value = {
+        x: 0,
+        y: 0,
+    }) {
         if (typeof value.x === 'number' && typeof value.y === 'number') {
             this.x = new AnimatedValue(value.x);
             this.y = new AnimatedValue(value.y);

package/build/appearance/index.js

@@ -62,7 +62,10 @@ export const Appearance = {
             return;
         }
         module.setColorScheme(colorScheme);
-        cachedScheme = colorScheme === 'unspecified' ? (module.getColorScheme() ?? null) : colorScheme;
+        cachedScheme =
+            colorScheme === 'unspecified'
+                ? (module.getColorScheme() ?? null)
+                : colorScheme;
     },
     // Subscribe to color-scheme changes. The listener receives `{ colorScheme }`.
     addChangeListener(listener) {

package/build/commit.d.ts

@@ -3,6 +3,19 @@ import { type ISymbioteNode } from './node';
 export { processColor, setColorProcessor } from './platform-color';
 export declare function disposeRoot(rootTag: IRootTag): void;
 export declare function commitChildren(rootTag: IRootTag, children: readonly ISymbioteNode[]): void;
+export interface ICommitProfile {
+    commits: number;
+    walkMs: number;
+    nodesVisited: number;
+    propWrites: number;
+    propNoops: number;
+    childScans: number;
+    childScanProbed: number;
+    childFlattens: number;
+    childFlattenProbed: number;
+    childFlattenWidest: number;
+}
+export declare function readCommitProfile(): ICommitProfile;
 export declare function setNativeProps(node: ISymbioteNode, partial: Record<string, unknown>): void;
 export declare function getNativeTag(node: ISymbioteNode): number | undefined;
 export declare function whenCommitted(node: ISymbioteNode, action: () => void): () => void;