@motion.page/sdk 1.1.1 → 1.1.3

package/dist/core/Animation.d.ts

@@ -58,6 +58,7 @@ export declare class Animation {
     private _pendingFitSetup;
     private _fitCleanupFn;
     private _unregisterCallback;
+    private _activationCallback;
     /**
      * Initialize the animation
      */
@@ -190,6 +191,11 @@ export declare class Animation {
      * This avoids circular dependency with Engine
      */
     setUnregisterCallback(callback: () => void): void;
+    /**
+     * Set callback invoked whenever this animation becomes active.
+     * Used by Engine to restart the global ticker after it idles.
+     */
+    setActivationCallback(callback: () => void): void;
     /**
      * Capture current element values as start values for all PropTweens
      * This enables proper chaining in timelines

package/dist/core/Engine.d.ts

@@ -25,6 +25,7 @@ export declare class Engine {
     private timelines;
     private _captureTarget;
     private ticker;
+    private _tickerSubscribed;
     private animationPool;
     private propTweenPool;
     private constructor();
@@ -36,6 +37,9 @@ export declare class Engine {
      * Main update loop called by Ticker
      */
     private update;
+    private _ensureTickerSubscription;
+    private _hasActiveWork;
+    private _releaseTickerIfIdle;
     /**
      * Create a new animation (called by AnimationBuilder)
      * Returns either a single Animation or an array of Animations (for stagger)

package/dist/core/Timeline.d.ts

@@ -21,11 +21,17 @@ export declare class Timeline {
      * @internal
      */
     private static _registerWithEngine;
+    private static _activateEngine;
     /**
      * Set the engine registration callback. Called once by Engine during initialization.
      * @internal
      */
     static setEngineRegisterCallback(callback: (name: string, timeline: Timeline) => void): void;
+    /**
+     * Set the engine activation callback. Called once by Engine during initialization.
+     * @internal
+     */
+    static setEngineActivationCallback(callback: () => void): void;
     private _name?;
     private _children;
     private _duration;
@@ -62,6 +68,7 @@ export declare class Timeline {
      * @internal
      */
     setUnregisterCallback(callback: () => void): void;
+    private _notifyActivated;
     private _previousStart;
     private _previousEnd;
     private _eachInstances?;
@@ -149,10 +156,34 @@ export declare class Timeline {
     private _createInstanceForElement;
     /**
      * Create a timeline instance for multiple elements (for each mode with explicit container target).
-     * This is a sibling of _createInstanceForElement — the only difference is that it accepts an
-     * Element[] and passes the array directly to AnimationBuilder instead of a single element.
+     * This is a sibling of _createInstanceForElement — the difference is that it accepts an
+     * Element[] of scoped targets (animation targets belonging to one container).
+     *
+     * Per-builder filtering: each cloned builder ONLY animates the subset of `elements`
+     * that the original builder targeted. Without this, a builder for `.subtitle` would
+     * also animate `.eyebrow` and `.section-title` elements that happen to share the
+     * same scoped container — producing visually broken animations.
      */
     private _createInstanceForElements;
+    /**
+     * Find animation targets that "belong" to a container in each-mode.
+     *
+     * Strategy 1 (preferred): the container itself (when it's also an animation
+     *   target) and/or its descendants. Covers the most common Builder workflow
+     *   where the trigger target IS the animation target (e.g.
+     *   `.onScroll({ target: '.fade-up', each: true })` animating `.fade-up`),
+     *   as well as parent-child setups (e.g. `.section-header` containing
+     *   `.eyebrow`/`.subtitle`).
+     * Strategy 2 (sibling fallback): anim targets sharing the container's parent
+     *   that aren't owned by another container.
+     *
+     * Returns [] when neither strategy yields targets — the caller skips this
+     * container, dropping the orphaned anim targets entirely. This matches the
+     * documented behaviour: when each:true + explicit target is set, only anim
+     * targets associated with a container (self, descendant, or sibling) are
+     * animated.
+     */
+    private _findScopedTargetsForContainer;
     /**
      * Resolve a CSS selector string or Element into an array of DOM elements.
      */