@rafaelaugusto/jolt 0.1.0-beta.9 → 0.1.0-rc.2

package/platforms/ios/src/JoltInteractiveNavigation.m

@@ -0,0 +1,255 @@
+#import "JoltInteractiveNavigation.h"
+#import "JoltSpringState.h"
+#import "JoltSharedLayoutFlight.h"
+
+@interface JoltInteractiveNavigation () {
+    JoltSpringState _spring;
+}
+@property(nonatomic, weak) UINavigationController *navigation;
+@property(nonatomic, weak) UIViewController *presented;
+@property(nonatomic) UIScreenEdgePanGestureRecognizer *pan;
+@property(nonatomic, copy) BOOL (^shouldBegin)(void);
+@property(nonatomic, copy) void (^onEvent)(NSInteger);
+@property(nonatomic) id<UIViewControllerContextTransitioning> context;
+@property(nonatomic) UIView *fromView, *toView, *shade;
+@property(nonatomic) CGAffineTransform fromTransform, toTransform;
+@property(nonatomic) CGFloat fromAlpha, toAlpha;
+@property(nonatomic) JoltSharedLayoutFlight *sharedFlight;
+@property(nonatomic) CGRect bounds;
+@property(nonatomic) CADisplayLink *link;
+@property(nonatomic) double stiffness, damping, mass, started, previous, target, direction, timeScale;
+@property(nonatomic) NSInteger operation;
+@property(nonatomic) NSNumber *pendingEnd;
+@property(nonatomic, readwrite) BOOL interactive;
+@property(nonatomic) BOOL reduced, settling, committed, disposed, suppressed, sharedPending;
+@property(nonatomic) double pendingStarted, rawProgress, gestureOffset;
+@end
+
+@implementation JoltInteractiveNavigation
+static NSUInteger active = 0, recognizers = 0;
++ (NSUInteger)activeCount { return active; }
++ (NSUInteger)recognizerCount { return recognizers; }
++ (instancetype)attach:(UINavigationController *)navigation stiffness:(double)stiffness
+                damping:(double)damping mass:(double)mass
+            shouldBegin:(BOOL (^)(void))shouldBegin onEvent:(void (^)(NSInteger))onEvent {
+    JoltInteractiveNavigation *owner = [self new];
+    owner.navigation = navigation;
+    owner.stiffness = stiffness; owner.damping = damping; owner.mass = mass;
+    owner.shouldBegin = shouldBegin; owner.onEvent = onEvent;
+    owner.pan = [[UIScreenEdgePanGestureRecognizer alloc] initWithTarget:owner action:@selector(pan:)];
+    owner.pan.delegate = owner;
+    owner.direction = navigation.view.effectiveUserInterfaceLayoutDirection == UIUserInterfaceLayoutDirectionRightToLeft ? -1 : 1;
+    owner.pan.edges = owner.direction < 0 ? UIRectEdgeRight : UIRectEdgeLeft;
+    [navigation.view addGestureRecognizer:owner.pan];
+    recognizers++;
+    [[NSNotificationCenter defaultCenter] addObserver:owner selector:@selector(cancel) name:UIApplicationWillResignActiveNotification object:nil];
+    return owner;
+}
+- (UIGestureRecognizer *)contentPop {
+    // The full-content pop gesture was added in iOS 26. Keep older SDKs compatible.
+    if ([self.navigation respondsToSelector:NSSelectorFromString(@"interactiveContentPopGestureRecognizer")])
+        return [self.navigation valueForKey:@"interactiveContentPopGestureRecognizer"];
+    return nil;
+}
+- (void)sync {
+    if (self.disposed || self.navigation.topViewController != self.presented) return;
+    if (!self.suppressed) {
+        self.suppressed = YES;
+    }
+    self.navigation.interactivePopGestureRecognizer.enabled = NO;
+    self.contentPop.enabled = NO;
+}
+- (void)prepareOperation:(NSInteger)operation presented:(UIViewController *)presented reduced:(BOOL)reduced timeScale:(double)timeScale {
+    self.operation = operation; self.reduced = reduced;
+    self.timeScale = timeScale;
+    if (operation == UINavigationControllerOperationPush) self.presented = presented;
+}
+- (BOOL)gestureRecognizerShouldBegin:(UIGestureRecognizer *)recognizer {
+    CGPoint velocity = [self.pan velocityInView:self.navigation.view];
+    return !self.disposed && !self.context && self.navigation.topViewController == self.presented &&
+        self.navigation.viewControllers.count > 1 && !self.navigation.transitionCoordinator &&
+        velocity.x * self.direction > fabs(velocity.y) && self.shouldBegin && self.shouldBegin();
+}
+- (void)pan:(UIScreenEdgePanGestureRecognizer *)pan {
+    if (pan.state == UIGestureRecognizerStateBegan) {
+        self.pendingEnd = nil;self.rawProgress=0;self.gestureOffset=0;
+        self.interactive = YES;
+        if (self.onEvent) self.onEvent(2); // JS enters Core's interactive state and invokes its pop callback once.
+        // UIKit may deliver startInteractiveTransition on the next main-loop turn.
+        // Keep the interactive request alive until that context arrives.
+    }
+    if (!self.interactive || self.settling) return;
+    double width = MAX(1, self.context ? self.bounds.size.width : self.navigation.view.bounds.size.width);
+    double progress = MAX(0, MIN(1, [pan translationInView:self.navigation.view].x * self.direction / width));
+    double velocity = [pan velocityInView:self.navigation.view].x * self.direction / width;
+    self.rawProgress=progress;
+    double mapped=self.sharedPending?0:MAX(0,MIN(1,(progress-self.gestureOffset)/MAX(.01,1-self.gestureOffset)));
+    _spring = (JoltSpringState){mapped, velocity/MAX(.01,1-self.gestureOffset)};
+    if (self.context) {
+        [self render:_spring.position];
+        [self.context updateInteractiveTransition:_spring.position];
+    }
+    if (pan.state == UIGestureRecognizerStateEnded || pan.state == UIGestureRecognizerStateCancelled || pan.state == UIGestureRecognizerStateFailed) {
+        BOOL finish = pan.state == UIGestureRecognizerStateEnded && progress + velocity * .16 > .5;
+        if (self.context) [self settle:finish velocity:velocity];
+        else self.pendingEnd = @(finish);
+    }
+}
+- (NSTimeInterval)transitionDuration:(id<UIViewControllerContextTransitioning>)context { return self.reduced ? 0 : .55; }
+- (BOOL)wantsInteractiveStart { return self.interactive; }
+- (CGFloat)completionSpeed { return 1; }
+- (UIViewAnimationCurve)completionCurve { return UIViewAnimationCurveLinear; }
+- (double)progress { return _spring.position; }
+- (double)velocity { return _spring.velocity; }
+- (void)prepare:(id<UIViewControllerContextTransitioning>)context {
+    self.context = context; active++;
+    UIViewController *from = [context viewControllerForKey:UITransitionContextFromViewControllerKey];
+    UIViewController *to = [context viewControllerForKey:UITransitionContextToViewControllerKey];
+    self.fromView = [context viewForKey:UITransitionContextFromViewKey] ?: from.view;
+    self.toView = [context viewForKey:UITransitionContextToViewKey] ?: to.view;
+    self.fromTransform = self.fromView.transform; self.toTransform = self.toView.transform;
+    self.fromAlpha = self.fromView.alpha; self.toAlpha = self.toView.alpha;
+    self.toView.frame = [context finalFrameForViewController:to];
+    UIView *container = context.containerView;
+    if (self.operation == UINavigationControllerOperationPush) [container addSubview:self.toView];
+    else [container insertSubview:self.toView belowSubview:self.fromView];
+    [self.toView setNeedsLayout];
+    // A recycled page may still be rebuilding its JS-backed data source. Let
+    // the deferred provider cross Core's layout boundary before forcing UIKit.
+    if(!self.sharedDeferred)[self.toView layoutIfNeeded];
+    self.bounds = container.bounds;
+    self.sharedPending=self.sharedDeferred;self.pendingStarted=CACurrentMediaTime();
+    // One setup callback after UIKit lays out both pages; subsequent progress stays native.
+    if(self.sharedEnabled && self.onEvent)self.onEvent(8);
+    self.shade = [[UIView alloc] initWithFrame:self.bounds];
+    self.shade.backgroundColor = UIColor.blackColor;
+    self.shade.userInteractionEnabled = NO; self.shade.isAccessibilityElement = NO;
+    [container insertSubview:self.shade belowSubview:self.operation == UINavigationControllerOperationPush ? self.toView : self.fromView];
+    _spring = (JoltSpringState){0, 0};
+    [self render:0];
+}
+- (void)startInteractiveTransition:(id<UIViewControllerContextTransitioning>)context {
+    JoltSpringState held = _spring;
+    [self prepare:context];
+    _spring = self.sharedPending?(JoltSpringState){0,held.velocity}:held; [self render:_spring.position];
+    [context updateInteractiveTransition:MAX(0, MIN(1, _spring.position))];
+    [self startLink]; // Monitors resize/suspension while the finger is held; no JS display callbacks.
+    if (self.pendingEnd || self.disposed) {
+        [self settle:!self.disposed && self.pendingEnd.boolValue velocity:_spring.velocity];
+        self.pendingEnd = nil;
+    }
+}
+- (void)animateTransition:(id<UIViewControllerContextTransitioning>)context {
+    [self prepare:context];
+    if (self.onEvent) self.onEvent(0);
+    [self settle:YES velocity:0];
+}
+- (void)render:(double)progress {
+    double p = MAX(0, MIN(1, progress)), width = self.bounds.size.width * self.direction;
+    BOOL push = self.operation == UINavigationControllerOperationPush;
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    if(self.sharedPending) {
+        self.fromView.transform=self.fromTransform;self.toView.transform=self.toTransform;self.fromView.alpha=self.fromAlpha;self.toView.alpha=self.toAlpha;self.shade.alpha=0;
+    } else if(self.sharedFlight) {
+        self.fromView.alpha = self.fromAlpha * (push ? 1 : 1-p); self.toView.alpha = self.toAlpha * (push ? p : 1);
+        self.shade.alpha = 0;
+        [self.sharedFlight updateInteractive:p];
+    } else if(self.sharedDeferred && !push) {
+        // A missing/deleted recycled target fades to the live collection. Do
+        // not translate its table while Core is realizing replacement cells.
+        self.fromView.alpha=self.fromAlpha*(1-p);self.toView.alpha=self.toAlpha;
+        self.shade.alpha=0;
+    } else {
+        self.fromView.transform = CGAffineTransformConcat(self.fromTransform, CGAffineTransformMakeTranslation(width * (push ? -.25 * p : p), 0));
+        self.toView.transform = CGAffineTransformConcat(self.toTransform, CGAffineTransformMakeTranslation(width * (push ? 1 - p : -.25 * (1 - p)), 0));
+        self.shade.alpha = .16 * (push ? p : 1 - p);
+    }
+    [CATransaction commit];
+}
+- (BOOL)prepareSharedFrom:(UIView *)from to:(UIView *)to image:(BOOL)image fromRadius:(double)fromRadius toRadius:(double)toRadius maxPixels:(double)maxPixels {
+    if(!self.context || self.reduced || self.sharedFlight || !from || !to)return NO;
+    JoltSharedLayoutFlight *flight=image?[JoltSharedLayoutFlight captureNavigationImage:from radius:fromRadius maxPixels:maxPixels]:[JoltSharedLayoutFlight capture:from image:NO radius:fromRadius maxPixels:maxPixels];
+    NSString *geometry=image?[flight prepareNavigationImage:to radius:toRadius maxPixels:maxPixels]:[flight prepare:to image:NO radius:toRadius maxPixels:maxPixels];
+    if(!geometry || ![flight beginInteractive:geometry]) { [flight dispose]; return NO; }
+    self.sharedFlight=flight; return YES;
+}
+- (void)completeSharedPreparation {
+    if(!self.context || !self.sharedPending)return;
+    self.sharedPending=NO;self.gestureOffset=self.rawProgress;
+    _spring.position=0;self.started=CACurrentMediaTime();self.previous=self.started;
+    [self render:0];
+    if(self.settling && self.reduced)[self finish];
+}
+- (void)startLink {
+    if (self.link || !self.context) return;
+    self.previous = CACurrentMediaTime();
+    self.link = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+    if (@available(iOS 15.0, *)) {
+        float maximum = MIN(120, UIScreen.mainScreen.maximumFramesPerSecond);
+        self.link.preferredFrameRateRange = CAFrameRateRangeMake(MIN(80, maximum), maximum, maximum);
+    }
+    [self.link addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
+- (void)settle:(BOOL)finish velocity:(double)velocity {
+    if (!self.context || self.settling) return;
+    self.committed = finish; self.settling = YES; self.target = finish ? 1 : 0;
+    _spring.velocity = velocity;
+    if (self.interactive) {
+        if (finish) [self.context finishInteractiveTransition]; else [self.context cancelInteractiveTransition];
+        if (self.onEvent) self.onEvent(finish ? 3 : 4);
+    }
+    if (!self.context) return; // An observer may synchronously cancel/dispose at the release boundary.
+    self.started = CACurrentMediaTime(); self.previous = self.started;
+    if (self.sharedPending && !finish){self.sharedPending=NO;[self finish];return;}
+    if ((self.reduced && !self.sharedPending) || self.disposed) { [self finish]; return; }
+    [self startLink];
+}
+- (void)tick:(CADisplayLink *)link {
+    if (!CGRectEqualToRect(self.bounds, self.context.containerView.bounds) || !self.context.containerView.window) { [self cancel]; return; }
+    if(self.sharedFlight && ![self.sharedFlight destinationIsStable]) { [self cancel]; return; }
+    if(self.sharedPending){if(CACurrentMediaTime()-self.pendingStarted>5.1)[self completeSharedPreparation];else return;}
+    if (!self.settling) return;
+    double now = CACurrentMediaTime(), seconds = MAX(0, now - self.previous); self.previous = now;
+    _spring = JoltSpringAdvance(_spring, self.target, self.stiffness * self.timeScale * self.timeScale, self.damping * self.timeScale, self.mass, seconds);
+    if (!isfinite(_spring.position) || !isfinite(_spring.velocity)) { [self finish]; return; }
+    [self render:_spring.position];
+    // Bound even a deliberately slow/undamped spring; never leave UIKit's route queue stuck.
+    if ((fabs(_spring.position - self.target) < .0005 && fabs(_spring.velocity) < .005) || now - self.started >= 3) [self finish];
+}
+- (void)finish {
+    if (!self.context) return;
+    [self.link invalidate]; self.link = nil;
+    BOOL completed = self.committed, interactive = self.interactive;
+    self.sharedPending=NO;
+    _spring = (JoltSpringState){completed ? 1 : 0, 0}; [self render:_spring.position];
+    self.fromView.transform = self.fromTransform; self.toView.transform = self.toTransform;
+    self.fromView.alpha = self.fromAlpha; self.toView.alpha = self.toAlpha;
+    [self.sharedFlight dispose]; self.sharedFlight = nil;
+    [self.shade removeFromSuperview]; self.shade = nil;
+    id<UIViewControllerContextTransitioning> context = self.context;
+    self.context = nil; self.fromView = nil; self.toView = nil;
+    self.settling = NO; self.interactive = NO; active--;
+    // Complete exactly once. Core/Router observes UIKit's actual committed controller.
+    [context completeTransition:completed];
+    [self sync];
+    if (self.onEvent) self.onEvent(interactive ? (completed ? 5 : 6) : 1);
+}
+- (void)cancel {
+    if (!self.context) { if (self.interactive) self.pendingEnd = @NO; return; }
+    if (!self.settling) [self settle:!self.interactive velocity:0];
+    [self finish]; // Preserve an already-decided completion; otherwise roll an active drag back.
+}
+- (void)disposeRestoringSwipe:(BOOL)enabled {
+    if (self.disposed) return;
+    self.disposed = YES;
+    [self cancel];
+    [[NSNotificationCenter defaultCenter] removeObserver:self];
+    [self.navigation.view removeGestureRecognizer:self.pan]; self.pan.delegate = nil; self.pan = nil;
+    recognizers--;
+    if (self.suppressed && self.navigation.topViewController == self.presented) {
+        self.navigation.interactivePopGestureRecognizer.enabled = enabled;
+        self.contentPop.enabled = enabled;
+    }
+    self.onEvent = nil; self.shouldBegin = nil;
+}
+@end

package/platforms/ios/src/JoltLiveSpring.h

@@ -0,0 +1,29 @@
+#import <UIKit/UIKit.h>
+NS_ASSUME_NONNULL_BEGIN
+@class JoltLiveSpringBinding;
+@interface JoltLiveSpring : NSObject
++ (instancetype)create:(double)initial stiffness:(double)stiffness damping:(double)damping mass:(double)mass
+             restDelta:(double)restDelta restSpeed:(double)restSpeed reduced:(BOOL)reduced;
+@property(nonatomic, readonly) double position;
+@property(nonatomic, readonly) double velocity;
+@property(nonatomic, readonly) BOOL moving;
++ (NSUInteger)activeCount;
++ (NSUInteger)nodeCount;
++ (void)sync:(UIView *)view;
+- (void)follow:(JoltLiveSpring *)source mappings:(NSString *)mappings;
+- (void)updateInput:(NSString *)snapshot;
+- (void)setSensorInput:(double)value;
+- (void)setTarget:(double)value;
+- (void)holdInput:(double)value velocity:(double)velocity;
+- (void)releaseInput:(double)target velocity:(double)velocity;
+- (void)setReduced:(BOOL)value;
+- (void)setPaused:(BOOL)value;
+- (JoltLiveSpringBinding *)bind:(UIView *)view property:(NSString *)property mappings:(NSString *)mappings;
+- (void)dispose;
+@end
+@interface JoltLiveSpringBinding : NSObject
+@property(nonatomic, readonly) double value;
+- (void)setLayers:(NSString *)inputs;
+- (void)cancel;
+@end
+NS_ASSUME_NONNULL_END

package/platforms/ios/src/JoltLiveSpring.m

@@ -0,0 +1,243 @@
+#import "JoltLiveSpring.h"
+#import "JoltSpringState.h"
+#import <QuartzCore/QuartzCore.h>
+
+static id decode(NSString *json) {
+    return [NSJSONSerialization JSONObjectWithData:[json dataUsingEncoding:NSUTF8StringEncoding] options:0 error:nil];
+}
+static double mapped(double value, NSArray *mappings) {
+    for (NSDictionary *mapping in mappings) {
+        NSArray *input = mapping[@"input"], *output = mapping[@"output"];
+        BOOL clamp = [mapping[@"clamp"] boolValue];
+        if (clamp && value <= [input.firstObject doubleValue]) { value = [output.firstObject doubleValue]; continue; }
+        if (clamp && value >= [input.lastObject doubleValue]) { value = [output.lastObject doubleValue]; continue; }
+        NSUInteger index = 0;
+        while (index < input.count - 2 && value > [input[index + 1] doubleValue]) index++;
+        double span = [input[index + 1] doubleValue] - [input[index] doubleValue];
+        double fraction = span > 0 ? (value - [input[index] doubleValue]) / span : value < [input[index] doubleValue] ? 0 : 1;
+        value = [output[index] doubleValue] + ([output[index + 1] doubleValue] - [output[index] doubleValue]) * fraction;
+    }
+    return value;
+}
+static BOOL inputRunning(NSDictionary *input, double anchor, double now) {
+    double repeat = [input[@"repeat"] doubleValue];
+    return [input[@"running"] boolValue] && (repeat < 0 || now - anchor + [input[@"elapsed"] doubleValue] <
+           [input[@"delay"] doubleValue] + [input[@"duration"] doubleValue] * (repeat + 1));
+}
+static double inputValue(NSDictionary *input, double anchor, double now) {
+    NSArray *values = input[@"values"], *times = input[@"times"];
+    if (![input[@"running"] boolValue] || values.count < 2) return [input[@"value"] doubleValue];
+    if (!inputRunning(input, anchor, now)) return [input[@"to"] doubleValue];
+    double time = MAX(0, now - anchor + [input[@"elapsed"] doubleValue] - [input[@"delay"] doubleValue]);
+    double duration = MAX(1, [input[@"duration"] doubleValue]);
+    double iteration = floor(time / duration), progress = fmod(time, duration) / duration;
+    if ([input[@"reverse"] boolValue] && fmod(iteration, 2) >= 1) progress = 1 - progress;
+    NSUInteger lo = 0, hi = times.count - 1;
+    while (lo + 1 < hi) { NSUInteger mid = (lo + hi) / 2; if ([times[mid] doubleValue] <= progress) lo = mid; else hi = mid; }
+    double start = [times[lo] doubleValue], end = [times[hi] doubleValue];
+    double fraction = end > start ? (progress - start) / (end - start) : 1;
+    return [values[lo] doubleValue] + ([values[hi] doubleValue] - [values[lo] doubleValue]) * MAX(0, MIN(1, fraction));
+}
+
+@interface JoltLiveSpring () {
+    JoltSpringState _state;
+}
+@property(nonatomic) double stiffness, damping, mass, restDelta, restSpeed;
+@property(nonatomic, readwrite) BOOL moving;
+@property(nonatomic) BOOL reduced, paused, disposed, direct, inputHeld, sensorDriven;
+@property(nonatomic) double targetValue;
+@property(nonatomic, nullable) JoltLiveSpring *source;
+@property(nonatomic) NSArray *sourceMaps;
+@property(nonatomic) NSDictionary *input;
+@property(nonatomic) double anchor;
+@property(nonatomic) NSMutableArray<JoltLiveSpringBinding *> *bindings;
+- (void)step:(double)now seconds:(double)seconds;
+- (void)apply;
+- (void)wake;
+@end
+@interface JoltLiveSpringBinding ()
+@property(nonatomic, weak) UIView *view;
+@property(nonatomic, weak) JoltLiveSpring *node;
+@property(nonatomic) NSString *property;
+@property(nonatomic) NSArray *mappings;
+@property(nonatomic) BOOL stopped;
+@property(nonatomic) NSArray *sampledLayers;
+@property(nonatomic) double layerAnchor;
+- (BOOL)running:(double)now;
+- (void)apply;
+@end
+
+@implementation JoltLiveSpring
+static NSMutableArray<JoltLiveSpring *> *nodes;
+static CADisplayLink *displayLink;
+static double previousFrame;
++ (void)initialize {
+    if (self == [JoltLiveSpring class]) nodes = [NSMutableArray new];
+}
++ (void)schedule {
+    if (displayLink || !nodes.count) return;
+    displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(tick:)];
+    if (@available(iOS 15.0, *)) {
+        float maximum = MIN(120, UIScreen.mainScreen.maximumFramesPerSecond);
+        displayLink.preferredFrameRateRange = CAFrameRateRangeMake(MIN(80, maximum), maximum, maximum);
+    }
+    [displayLink addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+}
++ (void)tick:(CADisplayLink *)link {
+    double now = link.timestamp * 1000;
+    double remaining = previousFrame == 0 ? 1.0 / 120 : MIN(.064, MAX(0, link.timestamp - previousFrame));
+    previousFrame = link.timestamp;
+    while (remaining > 1e-9) {
+        double dt = MIN(remaining, 1.0 / 240);
+        remaining -= dt;
+        for (JoltLiveSpring *node in nodes) [node step:now - remaining * 1000 seconds:dt];
+    }
+    BOOL active = NO;
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    for (JoltLiveSpring *node in nodes) {
+        [node apply]; active |= node.moving;
+        for (JoltLiveSpringBinding *binding in node.bindings) active |= [binding running:now];
+    }
+    [CATransaction commit];
+    if (!active) { [displayLink invalidate]; displayLink = nil; previousFrame = 0; }
+}
++ (instancetype)create:(double)initial stiffness:(double)stiffness damping:(double)damping mass:(double)mass
+             restDelta:(double)restDelta restSpeed:(double)restSpeed reduced:(BOOL)reduced {
+    JoltLiveSpring *node = [self new];
+    node->_state = (JoltSpringState){initial, 0};
+    node.stiffness = stiffness; node.damping = damping; node.mass = mass;
+    node.restDelta = restDelta; node.restSpeed = restSpeed; node->_reduced = reduced;
+    node.direct = YES; node.targetValue = initial;
+    node.bindings = [NSMutableArray new]; node.sourceMaps = @[];
+    [nodes addObject:node];
+    return node;
+}
+- (double)position { return _state.position; }
+- (double)velocity { return _state.velocity; }
++ (NSUInteger)activeCount { return displayLink ? 1 : 0; }
++ (NSUInteger)nodeCount { return nodes.count; }
+- (void)follow:(JoltLiveSpring *)source mappings:(NSString *)mappings {
+    if (self.disposed || source.disposed || [nodes indexOfObject:source] >= [nodes indexOfObject:self])
+        [NSException raise:NSInvalidArgumentException format:@"A spring can only follow an existing live node"];
+    self.sourceMaps = decode(mappings); self.source = source; [self wake];
+}
+- (void)updateInput:(NSString *)snapshot {
+    if (self.disposed) return;
+    self.sensorDriven = NO; self.input = decode(snapshot); self.direct = NO; self.anchor = CACurrentMediaTime() * 1000; [self wake];
+}
+- (void)setSensorInput:(double)value {
+    if (self.disposed || !isfinite(value) || (self.sensorDriven && self.inputHeld && _state.position == value)) return;
+    self.sensorDriven = YES; self.inputHeld = YES; self.direct = YES; self.targetValue = value; self.input = nil;
+    _state = (JoltSpringState){value, 0}; self.moving = NO;
+    [JoltLiveSpring schedule];
+}
+- (void)setTarget:(double)value {
+    if (self.disposed) return;
+    self.sensorDriven = NO; self.direct = YES; self.targetValue = value; self.input = nil; [self wake];
+}
+- (void)holdInput:(double)value velocity:(double)velocity {
+    if (self.disposed) return;
+    self.sensorDriven = NO; self.inputHeld = YES; self.direct = YES; self.targetValue = value; self.input = nil;
+    _state = (JoltSpringState){value, velocity}; self.moving = YES;
+    [CATransaction begin]; [CATransaction setDisableActions:YES]; [self apply]; [CATransaction commit];
+    [JoltLiveSpring schedule];
+}
+- (void)releaseInput:(double)target velocity:(double)velocity {
+    if (self.disposed) return;
+    self.inputHeld = NO; _state.velocity = velocity; [self setTarget:target];
+}
+- (void)setReduced:(BOOL)value { _reduced = value; [self wake]; }
+- (void)setPaused:(BOOL)value {
+    _paused = value;
+    if (value) self.moving = NO; else [self wake];
+}
+- (void)wake {
+    // Sensor inputs are held data, not springs. A policy change must not wake an endless clock.
+    if (self.disposed || self.paused || self.sensorDriven) return;
+    self.moving = YES;
+    if (self.reduced) {
+        [self step:CACurrentMediaTime() * 1000 seconds:0];
+        [CATransaction begin]; [CATransaction setDisableActions:YES]; [self apply]; [CATransaction commit];
+    }
+    [JoltLiveSpring schedule];
+}
+- (void)step:(double)now seconds:(double)seconds {
+    if (self.disposed || self.paused || self.inputHeld) return;
+    double target = self.source ? mapped(self.source.position, self.sourceMaps) : (self.direct ? self.targetValue : inputValue(self.input, self.anchor, now));
+    BOOL inputMoving = self.source ? self.source.moving : (!self.direct && inputRunning(self.input, self.anchor, now));
+    if (self.reduced) _state = (JoltSpringState){target, 0};
+    else _state = JoltSpringAdvance(_state, target, self.stiffness, self.damping, self.mass, seconds);
+    BOOL rest = fabs(_state.position - target) <= self.restDelta && fabs(_state.velocity) <= self.restSpeed;
+    if (rest && !inputMoving) _state = (JoltSpringState){target, 0};
+    self.moving = inputMoving || !rest;
+}
+- (JoltLiveSpringBinding *)bind:(UIView *)view property:(NSString *)property mappings:(NSString *)mappings {
+    if (self.disposed) [NSException raise:NSInvalidArgumentException format:@"Spring disposed"];
+    JoltLiveSpringBinding *binding = [JoltLiveSpringBinding new];
+    binding.node = self; binding.view = view; binding.property = property; binding.mappings = decode(mappings);
+    [self.bindings addObject:binding];
+    [CATransaction begin]; [CATransaction setDisableActions:YES]; [binding apply]; [CATransaction commit];
+    return binding;
+}
+- (void)apply {
+    for (NSInteger i = self.bindings.count - 1; i >= 0; i--) {
+        JoltLiveSpringBinding *binding = self.bindings[i];
+        if (!binding.view) [self.bindings removeObjectAtIndex:i]; else [binding apply];
+    }
+}
++ (void)sync:(UIView *)view {
+    [CATransaction begin]; [CATransaction setDisableActions:YES];
+    for (JoltLiveSpring *node in nodes)
+        for (JoltLiveSpringBinding *binding in node.bindings)
+            if (binding.view == view) [binding apply];
+    [CATransaction commit];
+}
+- (void)dispose {
+    if (self.disposed) return;
+    self.disposed = YES; self.moving = NO; [self.bindings removeAllObjects]; [nodes removeObject:self];
+    for (JoltLiveSpring *child in nodes) if (child.source == self) {
+        child.source = nil; [child setTarget:mapped(self.position, child.sourceMaps)];
+    }
+    self.source = nil;
+    if (!nodes.count) { [displayLink invalidate]; displayLink = nil; previousFrame = 0; }
+}
+@end
+
+@implementation JoltLiveSpringBinding
+- (double)value { return mapped(self.node.position, self.mappings); }
+- (void)setLayers:(NSString *)inputs {
+    self.sampledLayers = decode(inputs); self.layerAnchor = CACurrentMediaTime() * 1000;
+    [CATransaction begin]; [CATransaction setDisableActions:YES]; [self apply]; [CATransaction commit];
+    [JoltLiveSpring schedule];
+}
+- (BOOL)running:(double)now {
+    for (NSDictionary *layer in self.sampledLayers) if (inputRunning(layer, self.layerAnchor, now)) return YES;
+    return NO;
+}
+- (void)cancel { self.stopped = YES; [self.node.bindings removeObject:self]; }
+- (void)apply {
+    UIView *view = self.view;
+    if (self.stopped || !view.window) return;
+    NSString *key = self.property;
+    double value = self.value;
+    BOOL multiply = [key isEqualToString:@"opacity"] || [key hasPrefix:@"scale"];
+    double now = CACurrentMediaTime() * 1000;
+    for (NSDictionary *layer in self.sampledLayers) {
+        double part = inputValue(layer, self.layerAnchor, now);
+        value = multiply ? value * part : value + part;
+    }
+    if ([key isEqualToString:@"opacity"]) { view.alpha = MAX(0, MIN(1, value)); return; }
+    if ([key isEqualToString:@"x"]) key = @"transform.translation.x";
+    else if ([key isEqualToString:@"y"]) key = @"transform.translation.y";
+    else if ([key isEqualToString:@"scaleX"]) key = @"transform.scale.x";
+    else if ([key isEqualToString:@"scaleY"]) key = @"transform.scale.y";
+    else if ([key isEqualToString:@"rotate"]) { key = @"transform.rotation.z"; value *= M_PI / 180; }
+    else if ([key isEqualToString:@"rotateX"]) { key = @"transform.rotation.x"; value *= M_PI / 180; }
+    else if ([key isEqualToString:@"rotateY"]) { key = @"transform.rotation.y"; value *= M_PI / 180; }
+    [view.layer setValue:@(value) forKeyPath:key];
+    if ([view respondsToSelector:NSSelectorFromString(@"outerShadowContainerLayer")]) {
+        CALayer *shadow = [view valueForKey:@"outerShadowContainerLayer"];
+        [shadow setValue:@(value) forKeyPath:key];
+    }
+}
+@end

package/platforms/ios/src/JoltMotionProbe.h

@@ -0,0 +1,9 @@
+#import <UIKit/UIKit.h>
+
+/** Inert until explicitly started by the optional development inspector. */
+@interface JoltMotionProbe : NSObject
++ (instancetype)startView:(UIView *)view capacity:(NSInteger)capacity hertz:(double)hertz;
++ (NSInteger)activeCount;
+- (NSString *)drain;
+- (void)dispose;
+@end

package/platforms/ios/src/JoltMotionProbe.m

@@ -0,0 +1,72 @@
+#import "JoltMotionProbe.h"
+#import <QuartzCore/QuartzCore.h>
+#include <math.h>
+
+static NSInteger probeCount = 0;
+@interface JoltMotionProbe () {
+    double *_rows;
+}
+@property(nonatomic, weak) UIView *view;
+@property(nonatomic) CADisplayLink *link;
+@property(nonatomic) NSInteger capacity, count, head, dropped, samples;
+@property(nonatomic) double interval, last, sampleCPU, drainCPU;
+@end
+
+@implementation JoltMotionProbe
++ (NSInteger)activeCount { return probeCount; }
++ (instancetype)startView:(UIView *)view capacity:(NSInteger)capacity hertz:(double)hertz {
+    JoltMotionProbe *p = [JoltMotionProbe new];
+    p.view = view; p.capacity = MAX(8, MIN(600, capacity));
+    p.interval = 1000.0 / MAX(1, MIN(120, hertz)); p.last = -INFINITY;
+    p->_rows = calloc(p.capacity * 9, sizeof(double));
+    p.link = [CADisplayLink displayLinkWithTarget:p selector:@selector(frame:)];
+    if (@available(iOS 15.0, *)) {
+        float rate = MIN(hertz, view.window.screen.maximumFramesPerSecond ?: 60);
+        p.link.preferredFrameRateRange = CAFrameRateRangeMake(rate, rate, rate);
+    }
+    [p.link addToRunLoop:NSRunLoop.mainRunLoop forMode:NSRunLoopCommonModes];
+    [[NSNotificationCenter defaultCenter] addObserver:p selector:@selector(dispose) name:UIApplicationDidEnterBackgroundNotification object:nil];
+    probeCount++; return p;
+}
+- (void)frame:(CADisplayLink *)link {
+    if (!self.view.window) { [self dispose]; return; }
+    double begin = CACurrentMediaTime() * 1000;
+    if (begin - self.last < self.interval - 0.5) return;
+    self.last = begin;
+    NSInteger slot;
+    if (self.count == self.capacity) {
+        slot = self.head; self.head = (self.head + 1) % self.capacity; self.dropped++;
+    } else { slot = (self.head + self.count) % self.capacity; self.count++; }
+    double *row = _rows + slot * 9; row[0] = begin;
+    CALayer *layer = self.view.layer.presentationLayer;
+    static NSArray<NSString *> *paths;
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{ paths = @[@"transform.translation.x", @"transform.translation.y", @"transform.scale.x", @"transform.scale.y", @"transform.rotation.z", @"transform.rotation.x", @"transform.rotation.y", @"opacity"]; });
+    for (NSInteger i = 0; i < 8; i++) {
+        // Missing presentation is explicitly unavailable, never replaced with the model layer.
+        row[i + 1] = layer ? [[layer valueForKeyPath:paths[i]] doubleValue] : NAN;
+        if (i >= 4 && i <= 6) row[i + 1] *= 180.0 / M_PI;
+    }
+    self.samples++; self.sampleCPU += CACurrentMediaTime() * 1000 - begin;
+}
+- (NSString *)drain {
+    double begin = CACurrentMediaTime() * 1000;
+    NSMutableArray *out = [NSMutableArray arrayWithCapacity:self.count];
+    for (NSInteger i = 0; i < self.count; i++) {
+        double *row = _rows + ((self.head + i) % self.capacity) * 9;
+        NSMutableArray *values = [NSMutableArray arrayWithCapacity:9];
+        for (NSInteger j = 0; j < 9; j++) [values addObject:isfinite(row[j]) ? @(row[j]) : NSNull.null];
+        [out addObject:values];
+    }
+    self.count = 0; self.head = 0;
+    NSDictionary *result = @{@"rows":out, @"dropped":@(self.dropped), @"samples":@(self.samples), @"sampleCpuMs":@(self.sampleCPU), @"drainCpuMs":@(self.drainCPU), @"active":@(self.link != nil)};
+    NSString *json = [[NSString alloc] initWithData:[NSJSONSerialization dataWithJSONObject:result options:0 error:nil] encoding:NSUTF8StringEncoding];
+    self.drainCPU += CACurrentMediaTime() * 1000 - begin;
+    return json;
+}
+- (void)dispose {
+    if (self.link) { [self.link invalidate]; self.link = nil; probeCount--; }
+    [[NSNotificationCenter defaultCenter] removeObserver:self]; self.view = nil;
+}
+- (void)dealloc { free(_rows); }
+@end

package/platforms/ios/src/JoltReorderSession.h

@@ -0,0 +1,15 @@
+#import <UIKit/UIKit.h>
+
+@interface JoltReorderHandle : UIButton
+@property(nonatomic, copy) void (^onMove)(NSInteger direction);
+@end
+
+@interface JoltReorderSession : NSObject
++ (instancetype)attach:(UITableView *)list options:(NSString *)options onState:(void (^)(NSInteger state, NSInteger index, NSInteger toIndex))onState;
+- (void)registerHandle:(UIView *)view;
+- (void)setEnabled:(BOOL)enabled;
+- (void)setReducedMotion:(BOOL)reduced;
+- (void)cancel;
+- (void)dispose;
+@property(nonatomic, readonly) BOOL active;
+@end