upwwwards 0.1.7-beta.1 → 0.1.8-beta.1

package/dist/{Thread-Cvf__-O4.d.ts → Thread-5NGNyOJb.d.ts}

@@ -8,13 +8,14 @@ declare namespace CallStack {
     type CALLBACK = (...args: any) => void;
 }
 /**
-    * Callstack: an ordered list of synchronous callbacks that are invoked together, in insertion order,
-    * with the same arguments (similar to a lightweight event emitter for a single event).
+    * Ordered list of synchronous callbacks invoked together, in insertion order, with the same arguments
+    * (a lightweight single-event emitter).
     *
-    * Callbacks run either all at once with `loop`, or one at a time with `gen`, which returns a generator
-    * that pauses after each callback (used by the frame scheduler `Thread` to spread work across frames).
-    * Callbacks may be added or removed while the stack is being iterated: removals are applied immediately
-    * without skipping the next callback, and additions only run from the next iteration.
+    * Run them all at once with {@link CallStack.loop}, or one-by-one with {@link CallStack.gen} (yields after each
+    * callback so a caller such as `Up.Thread` can spread work across frames).
+    * You may {@link CallStack.add}, {@link CallStack.remove}, or {@link CallStack.clear} while an iteration is running:
+    * removals apply immediately without skipping the next callback, additions run from the next iteration,
+    * and `clear` skips any callback that has not run yet.
     *
     * If a callback throws, the error is logged with `Logs.error` and the remaining callbacks of that
     * iteration are skipped; the error is not rethrown.
@@ -93,6 +94,12 @@ declare class CallStack<T extends CallStack.CALLBACK> {
         * ```
     */
     gen(...args: Parameters<T>): Thread.GENERATOR;
+    /**
+        * Removes every callback and resets iteration counters (`length` becomes `0`).
+        * Safe to call during {@link CallStack.loop} / {@link CallStack.gen}: callbacks that have not run yet are skipped.
+        * When no iteration is in progress, any outstanding generator created by {@link CallStack.gen} is closed.
+    */
+    clear(): void;
 }
 
 declare namespace Arrays {
@@ -294,16 +301,6 @@ declare const
     * Key of the method returning the active cache (browser map or request-scoped server map).
 */
 getCache: unique symbol;
-declare const /**
-    * Key of the modifier refreshing viewport metrics.
-    * @internal
-*/
-updateScreenVars: unique symbol;
-declare const /**
-    * Key of the modifier refreshing scroll metrics.
-    * @internal
-*/
-updateScrollVars: unique symbol;
 declare namespace App {
     /**
         * Operating system / device family detected from `navigator.userAgent`.
@@ -332,8 +329,9 @@ declare namespace App {
 /**
     * Application runtime: device and browser detection, viewport and scroll metrics, an application cache,
     * and a wait queue that delays the `LOAD` event (see {@link Event}).
-    * @note Metrics are client-only. They are read once by `Up.set`, then refreshed by Thread modifiers before
-    * `resize` (flag `8`) and `scroll` (flag `32`) tasks run.
+    * @note Metrics are client-only. They are read once by `Up.set`, then refreshed by Thread modifiers on
+    * `resize` (flag `8`) and `scroll` (flag `32`) when those flags are armed ({@link Thread.sub} / {@link Thread.arm}).
+    * With the Scroll plugin, Lenis arms the scroll flag after writing `window.scrollY`.
 */
 declare abstract class App {
     #private;
@@ -489,15 +487,16 @@ declare abstract class App {
     */
     static remove(key: App.CACHE_KEY): boolean;
     /**
-        * Thread modifier refreshing viewport metrics (`w`, `cw`, `sw`, `lw`, `h`, `ch`, `sh`, `lh`).
-        * @internal
+        * Refreshes viewport metrics (`w`, `cw`, `sw`, `lw`, `h`, `ch`, `sh`, `lh`).
+        * Registered as a Thread modifier on {@link Thread.RESIZE_FLAG}; call it yourself only if you need an immediate read outside that phase.
     */
-    static [updateScreenVars](): void;
+    static updateScreenVars(): void;
     /**
-        * Thread modifier refreshing scroll metrics (`y`, `dY`, `downwards`).
-        * @internal
+        * Refreshes scroll metrics (`y`, `dY`, `downwards`) from `window.scrollY`.
+        * Registered as a Thread modifier on {@link Thread.RESIZE_FLAG} and {@link Thread.SCROLL_FLAG}; no-op when `y` is unchanged.
+        * Prefer letting Thread arm those flags (or the Scroll plugin) rather than calling this every frame by hand.
     */
-    static [updateScrollVars](): void;
+    static updateScrollVars(): void;
     /**
         * Clears the application cache and pending wait queue. Called from `Up.destroy` in the browser.
         * @internal
@@ -518,15 +517,15 @@ declare namespace Thread {
         * Thread scheduler configuration, declared in `up.thread` of the Vite initializer.
     */
     type CONFIG = {
-        /**
-            * Soft time budget in ms per frame for flow (one-shot) tasks. Must be greater than `0`. Default: `8`.
-        */
-        flowBudget?: number;
         /**
             * Soft time budget in ms per frame for forever tasks. Must be greater than `0`. Default: `4`.
             * Forever tasks always run every frame; the budget only limits how long their generators may run.
         */
         foreverBudget?: number;
+        /**
+            * Soft time budget in ms per frame for flow (one-shot) tasks. Must be greater than `0`. Default: `8`.
+        */
+        flowBudget?: number;
     };
     /**
         * Flag of `EARTHQUAKE` event tasks (`2`).
@@ -553,10 +552,20 @@ declare namespace Thread {
     */
     type SYNTHRA_FLAG = 2_048;
     /**
-        * Priority flag of a task or modifier: a power of 2 from `1` to `4096`.
-        * Within a frame, lower flags run first; tasks sharing a flag run in insertion order.
+        * Default flag of {@link Thread.sub} when `flag` is omitted (`8192`).
+        * Runs before {@link Thread.MAX_FLAG} (end-of-frame work such as Anime `updateRoot`).
+    */
+    type DEFAULT_FLAG = 8_192;
+    /**
+        * Highest allowed priority flag (`32768`). Reserved for end-of-frame work (e.g. Anime advances GSAP here).
+        * Not the default of {@link Thread.sub} — see {@link Thread.DEFAULT_FLAG}.
     */
-    type FLAG = 1 | EARTHQUAKE_FLAG | 4 | RESIZE_FLAG | 16 | SCROLL_FLAG | 64 | EVENT_FLAG | 256 | OBSERVER_FLAG | 1_024 | SYNTHRA_FLAG | 4_096;
+    type MAX_FLAG = 32_768;
+    /**
+        * Priority flag of a task or modifier: a power of 2 from `1` to {@link Thread.MAX_FLAG} (`32768`).
+        * Within a frame, lower flags run first; for each flag, forever tasks run before flow tasks.
+    */
+    type FLAG = 1 | EARTHQUAKE_FLAG | 4 | RESIZE_FLAG | 16 | SCROLL_FLAG | 64 | EVENT_FLAG | 256 | OBSERVER_FLAG | 1_024 | SYNTHRA_FLAG | 4_096 | DEFAULT_FLAG | 16_384 | MAX_FLAG;
     /**
         * Modifier callback. It is called without arguments and its return value is ignored.
     */
@@ -602,10 +611,12 @@ declare namespace Thread {
     ];
 }
 /**
-    * Frame scheduler of the runtime. Each frame (`requestAnimationFrame`, or an external ticker such as GSAP) runs, in order:
-    * modifiers, then flow tasks (run once, then removed), then forever tasks (run every frame).
-    * Work is grouped by priority flags (see {@link Thread.FLAG}) and limited by a soft time budget ({@link Thread.CONFIG});
-    * flow tasks that do not fit are postponed to the next frame, and generator tasks are resumed across frames.
+    * Frame scheduler of the runtime (`Up.Thread`). Each frame (`requestAnimationFrame`, or an external ticker such as GSAP)
+    * runs, in order: **drivers** → **modifiers** → **tasks by ascending flag** (forever then flow for each flag).
+    * Drivers (see {@link Thread.addDriver}) write frame inputs early (e.g. Lenis `raf`). Modifiers refresh shared data
+    * before tasks; arm them with {@link Thread.sub} or {@link Thread.arm}. Soft budgets ({@link Thread.CONFIG}) apply
+    * separately to forever and flow. Prefer `Up.Event.sub(['TICK', …])` for simple per-frame work; use Thread for
+    * budgets, priorities, drivers, or end-of-frame forever tasks on {@link Thread.MAX_FLAG}.
     * @note Client-only: the frame loop starts with `Up.set`. The Thread is paused while the page is hidden.
 */
 declare abstract class Thread {
@@ -632,10 +643,15 @@ declare abstract class Thread {
     */
     static get App(): typeof App;
     /**
-        * Highest allowed flag, also the default flag of {@link Thread.sub}.
-        * @returns `4096`.
+        * Default priority flag of {@link Thread.sub} when `flag` is omitted (`8192`).
+        * @returns `8192`.
     */
-    static get MAX_FLAG(): Thread.FLAG;
+    static get DEFAULT_FLAG(): Thread.DEFAULT_FLAG;
+    /**
+        * Highest allowed priority flag (`32768`). Use for end-of-frame forever work (e.g. Anime `gsap.updateRoot`).
+        * @returns `32768`.
+    */
+    static get MAX_FLAG(): Thread.MAX_FLAG;
     /**
         * Timestamp (ms) of the last processed frame, in the clock of the frame driver:
         * `requestAnimationFrame` time by default, or the external ticker time when one is attached (e.g. GSAP ticker time × `1000`).
@@ -662,16 +678,32 @@ declare abstract class Thread {
     */
     static [set](): void;
     /**
-        * Registers a modifier: a lightweight hook that refreshes shared data before tasks use it.
-        * After {@link Thread.sub} is called with the same `flag`, the modifier runs once at the start of the next processed frame,
-        * before any task (at most once per frame). Modifiers run by ascending flag, then in registration order.
-        * Registering the same callback twice on the same flag logs a warning and does nothing.
+        * Registers a **driver**: a sync callback run at the **start** of every processed frame, before modifiers and tasks.
+        * Use it for external clocks that write frame inputs (e.g. Scroll registers Lenis `raf` here with `autoRaf: false`).
+        * Callbacks run in registration order with no arguments; prefer sync functions. The same reference can be
+        * registered only once (a duplicate logs a warning and is ignored).
+        * @param callback Function called at the start of the frame (reads {@link Thread.timestamp} if needed).
+        * @example
+        * ```ts
+        * const step = (): void => { lenis.raf(Up.Thread.timestamp) }
+        *
+        * Up.Thread.addDriver(step)
+        * // later
+        * Up.Thread.removeDriver(step)
+        * ```
+    */
+    static addDriver(callback: Thread.CALLBACK): void;
+    /**
+        * Registers a modifier: a lightweight hook that refreshes shared data before tasks of the same `flag`.
+        * After {@link Thread.sub} or {@link Thread.arm} with that flag, the modifier runs once in the modifiers phase
+        * of the next processed frame (at most once per frame), before forever/flow tasks. Modifiers run by ascending
+        * flag, then in registration order. Registering the same callback twice on the same flag logs a warning.
         * @note Keep modifiers cheap: they may run on many frames.
         * @note The `App` metric modifiers (on {@link Thread.RESIZE_FLAG} and {@link Thread.SCROLL_FLAG}) are registered first,
         * so they run before user modifiers of the same flag.
         * @param callback Function called without arguments.
-        * @param flag Priority flag, a power of 2 from `1` to `4096`.
-        * @throws If `flag` is not a power of 2 between `1` and `4096`.
+        * @param flag Priority flag, a power of 2 from `1` to {@link Thread.MAX_FLAG}.
+        * @throws If `flag` is not a power of 2 between `1` and {@link Thread.MAX_FLAG}.
         * @example
         * ```ts
         * let ratio = 1
@@ -680,15 +712,20 @@ declare abstract class Thread {
         * ```
     */
     static addModifier(callback: Thread.CALLBACK, flag: Thread.FLAG): void;
+    /**
+        * Unregisters a driver added with {@link Thread.addDriver}. Does nothing if it is not registered.
+        * @param callback The same function reference passed to `addDriver`.
+    */
+    static removeDriver(callback: Thread.CALLBACK): void;
     /**
         * Removes a modifier registered with {@link Thread.addModifier}. Does nothing if it is not registered on `flag`.
         * @param callback The same function reference passed to `addModifier`.
         * @param flag The flag used when adding the modifier.
-        * @throws If `flag` is not a power of 2 between `1` and `4096`.
+        * @throws If `flag` is not a power of 2 between `1` and {@link Thread.MAX_FLAG}.
     */
     static removeModifier(callback: Thread.CALLBACK, flag: Thread.FLAG): void;
     /**
-        * Clears all modifiers and tasks and stops the internal frame loop. Called from `Up.destroy` in the browser.
+        * Clears all modifiers, tasks, and drivers, and stops the internal frame loop. Called from `Up.destroy` in the browser.
         * @internal
     */
     static [destroy](): void;
@@ -722,9 +759,9 @@ declare abstract class Thread {
         * (the task stays scheduled until the promise settles).
         * @template T Task type, used to type `args`.
         * @param task The task function, identified by reference.
-        * @param flag Priority flag, a power of 2 from `1` to `4096`. Default: {@link Thread.MAX_FLAG} (`4096`).
+        * @param flag Priority flag, a power of 2 from `1` to {@link Thread.MAX_FLAG}. Default: {@link Thread.DEFAULT_FLAG} (`8192`).
         * @param args Arguments passed to the task when it runs (the latest call wins).
-        * @throws If `flag` is not a power of 2 between `1` and `4096`.
+        * @throws If `flag` is not a power of 2 between `1` and {@link Thread.MAX_FLAG} (`32768`).
         * @example
         * ```ts
         * function* build(items: HTMLElement[]): Generator<void, void, void>
@@ -747,6 +784,18 @@ declare abstract class Thread {
         * @param task The same function reference passed to {@link Thread.sub}.
     */
     static unsub(task: Thread.TASK): void;
+    /**
+        * Arms modifiers of `flag` for the next modifiers phase (same frame if called from a driver or before modifiers run).
+        * No-op when no modifiers are registered on `flag`. {@link Thread.sub} calls this automatically; call it yourself
+        * when an external writer updates shared state without scheduling a task (e.g. Scroll arms {@link Thread.SCROLL_FLAG}
+        * after Lenis writes `window.scrollY`, so `App.updateScrollVars` and ScrollTrigger modifiers run).
+        * @param flag Priority flag whose modifiers should run.
+        * @example
+        * ```ts
+        * lenis.on('scroll', () => Up.Thread.arm(32))
+        * ```
+    */
+    static arm(flag: Thread.FLAG): void;
     /**
         * Returns a promise that resolves when a scheduled task completes its next (or current) run, or when it is unsubscribed.
         * @param task The same function reference passed to {@link Thread.sub}.
@@ -781,4 +830,4 @@ declare abstract class Thread {
     static unmarkForever(task: Thread.TASK): void;
 }
 
-export { Arrays as A, CallStack as C, Thread as T, App as a, type AppCache as b, updateScrollVars as c, updateScreenVars as u };
+export { Arrays as A, CallStack as C, Thread as T, App as a, type AppCache as b };

package/dist/core/[1]/[2]/Thread.js

@@ -1,16 +1,19 @@
 import { INHERITANCE, STATUS, construct, set, destroy, apply, start, stop } from "../../../symbols/index.js";
+import Arrays from "../../../scripts/Arrays.js";
 import Logs from "../../../scripts/Logs.js";
-import App, { updateScreenVars, updateScrollVars } from "./[3]/App.js";
+import App from "./[3]/App.js";
 const FOREVER = /* @__PURE__ */ Symbol("FOREVER");
 class Thread {
   // #PROPS
   // ##STATICS
-  static #MAX_FLAG = 4096;
+  static #DEFAULT_FLAG = 8192;
+  static #MAX_FLAG = 32768;
   static #MODIFIERS_MAP = /* @__PURE__ */ new Map();
-  static #FLOW_MAP = /* @__PURE__ */ new Map();
   static #FOREVER_MAP = /* @__PURE__ */ new Map();
-  static #FLOW_LISTED = /* @__PURE__ */ new Map();
+  static #FLOW_MAP = /* @__PURE__ */ new Map();
   static #FOREVER_LISTED = /* @__PURE__ */ new Map();
+  static #FLOW_LISTED = /* @__PURE__ */ new Map();
+  static #DRIVERS_CALLSTACK = new Arrays.CallStack();
   /**
       * Shared HRT stack after hydrating `App` (`[Adapter, App]`); later modules append `Thread`, `Event`.
       * Same array as `App[INHERITANCE]` — does not include `Thread` itself.
@@ -26,8 +29,8 @@ class Thread {
   static #flowBudget = 8;
   static #foreverBudget = 4;
   static #modifiersBitMask = 0;
-  static #flowBitMask = 0;
   static #foreverBitMask = 0;
+  static #flowBitMask = 0;
   static #i = -1;
   static #max = -1;
   static #stack = null;
@@ -54,8 +57,15 @@ class Thread {
     return App;
   }
   /**
-      * Highest allowed flag, also the default flag of {@link Thread.sub}.
-      * @returns `4096`.
+      * Default priority flag of {@link Thread.sub} when `flag` is omitted (`8192`).
+      * @returns `8192`.
+  */
+  static get DEFAULT_FLAG() {
+    return Thread.#DEFAULT_FLAG;
+  }
+  /**
+      * Highest allowed priority flag (`32768`). Use for end-of-frame forever work (e.g. Anime `gsap.updateRoot`).
+      * @returns `32768`.
   */
   static get MAX_FLAG() {
     return Thread.#MAX_FLAG;
@@ -91,9 +101,9 @@ class Thread {
       if (config.flowBudget) config.flowBudget > 0 ? Thread.#flowBudget = config.flowBudget : Logs.warn("THREAD", "THE FLOW BUDGET MUST BE GREATER THAN 0.");
       if (config.foreverBudget) config.foreverBudget > 0 ? Thread.#foreverBudget = config.foreverBudget : Logs.warn("THREAD", "THE FOREVER BUDGET MUST BE GREATER THAN 0.");
     }
-    Thread.addModifier(Thread.App[updateScreenVars], 8);
-    Thread.addModifier(Thread.App[updateScrollVars], 8);
-    Thread.addModifier(Thread.App[updateScrollVars], 32);
+    Thread.addModifier(Thread.App.updateScreenVars, 8);
+    Thread.addModifier(Thread.App.updateScrollVars, 8);
+    Thread.addModifier(Thread.App.updateScrollVars, 32);
   }
   // ##SET
   /**
@@ -113,10 +123,10 @@ class Thread {
   }
   // ##GET
   /**
-      * Returns `flag` after validation, or `MAX_FLAG` when omitted.
+      * Returns `flag` after validation, or `DEFAULT_FLAG` when omitted.
   */
   static #getFlagFrom(flag) {
-    if (flag == null) return Thread.#MAX_FLAG;
+    if (flag == null) return Thread.#DEFAULT_FLAG;
     Thread.#checkFlag(flag);
     return flag;
   }
@@ -144,16 +154,35 @@ class Thread {
     map.get(flag)?.push(wrapper) ?? map.set(flag, [wrapper]);
   }
   /**
-      * Registers a modifier: a lightweight hook that refreshes shared data before tasks use it.
-      * After {@link Thread.sub} is called with the same `flag`, the modifier runs once at the start of the next processed frame,
-      * before any task (at most once per frame). Modifiers run by ascending flag, then in registration order.
-      * Registering the same callback twice on the same flag logs a warning and does nothing.
+      * Registers a **driver**: a sync callback run at the **start** of every processed frame, before modifiers and tasks.
+      * Use it for external clocks that write frame inputs (e.g. Scroll registers Lenis `raf` here with `autoRaf: false`).
+      * Callbacks run in registration order with no arguments; prefer sync functions. The same reference can be
+      * registered only once (a duplicate logs a warning and is ignored).
+      * @param callback Function called at the start of the frame (reads {@link Thread.timestamp} if needed).
+      * @example
+      * ```ts
+      * const step = (): void => { lenis.raf(Up.Thread.timestamp) }
+      *
+      * Up.Thread.addDriver(step)
+      * // later
+      * Up.Thread.removeDriver(step)
+      * ```
+  */
+  static addDriver(callback) {
+    if (Thread.#DRIVERS_CALLSTACK.has(callback)) return Logs.warn("THREAD", "THE DRIVER CALLBACK IS ALREADY REGISTERED.");
+    Thread.#DRIVERS_CALLSTACK.add(callback);
+  }
+  /**
+      * Registers a modifier: a lightweight hook that refreshes shared data before tasks of the same `flag`.
+      * After {@link Thread.sub} or {@link Thread.arm} with that flag, the modifier runs once in the modifiers phase
+      * of the next processed frame (at most once per frame), before forever/flow tasks. Modifiers run by ascending
+      * flag, then in registration order. Registering the same callback twice on the same flag logs a warning.
       * @note Keep modifiers cheap: they may run on many frames.
       * @note The `App` metric modifiers (on {@link Thread.RESIZE_FLAG} and {@link Thread.SCROLL_FLAG}) are registered first,
       * so they run before user modifiers of the same flag.
       * @param callback Function called without arguments.
-      * @param flag Priority flag, a power of 2 from `1` to `4096`.
-      * @throws If `flag` is not a power of 2 between `1` and `4096`.
+      * @param flag Priority flag, a power of 2 from `1` to {@link Thread.MAX_FLAG}.
+      * @throws If `flag` is not a power of 2 between `1` and {@link Thread.MAX_FLAG}.
       * @example
       * ```ts
       * let ratio = 1
@@ -202,11 +231,18 @@ class Thread {
     STACK.splice(INDEX, 1);
     Thread.#updateCurrentAfterRemoving(STACK, INDEX);
   }
+  /**
+      * Unregisters a driver added with {@link Thread.addDriver}. Does nothing if it is not registered.
+      * @param callback The same function reference passed to `addDriver`.
+  */
+  static removeDriver(callback) {
+    Thread.#DRIVERS_CALLSTACK.remove(callback);
+  }
   /**
       * Removes a modifier registered with {@link Thread.addModifier}. Does nothing if it is not registered on `flag`.
       * @param callback The same function reference passed to `addModifier`.
       * @param flag The flag used when adding the modifier.
-      * @throws If `flag` is not a power of 2 between `1` and `4096`.
+      * @throws If `flag` is not a power of 2 between `1` and {@link Thread.MAX_FLAG}.
   */
   static removeModifier(callback, flag) {
     Thread.#checkFlag(flag);
@@ -220,7 +256,7 @@ class Thread {
   }
   // ##UPDATES
   /**
-      * One scheduler frame: refresh `#delta` / `#timestamp`, then run modifiers → flow → forever.
+      * One scheduler frame: refresh `#delta` / `#timestamp`, then drivers → modifiers → tasks (forever then flow per flag).
       * - `STATUS === -1` (stopped): no-op (ticker may still invoke this).
       * - `STATUS === 0` (pending): adopt `timestamp`, set `#delta = 0`, promote to started, then return (no work this frame).
       * - `STATUS === 1` (started): normal tick.
@@ -239,9 +275,9 @@ class Thread {
     }
     Thread.#delta = (timestamp - Thread.#timestamp) / 1e3;
     Thread.#timestamp = timestamp;
+    Thread.#DRIVERS_CALLSTACK.loop();
     Thread.#execModifiers();
-    Thread.#execFlowTasks();
-    Thread.#execForeverTasks();
+    Thread.#execTasks();
     Thread.#stack = null;
   }
   /**
@@ -254,7 +290,7 @@ class Thread {
   }
   // ##DESTROY
   /**
-      * Clears every modifier and task.
+      * Clears every modifier, task, and driver callback.
   */
   static #destroyVars() {
     Thread.#modifiersBitMask = Thread.#flowBitMask = Thread.#foreverBitMask = 0;
@@ -263,6 +299,7 @@ class Thread {
     if (Thread.#FOREVER_MAP.size) Thread.#FOREVER_MAP.clear();
     if (Thread.#FLOW_LISTED.size) Thread.#FLOW_LISTED.clear();
     if (Thread.#FOREVER_LISTED.size) Thread.#FOREVER_LISTED.clear();
+    Thread.#DRIVERS_CALLSTACK.clear();
   }
   /**
       * Stops the internal `requestAnimationFrame` loop.
@@ -274,7 +311,7 @@ class Thread {
     Thread.#tickID = -1;
   }
   /**
-      * Clears all modifiers and tasks and stops the internal frame loop. Called from `Up.destroy` in the browser.
+      * Clears all modifiers, tasks, and drivers, and stops the internal frame loop. Called from `Up.destroy` in the browser.
       * @internal
   */
   static [destroy]() {
@@ -350,88 +387,79 @@ class Thread {
     Thread.#resolve(wrapper);
     return 1;
   }
-  /**
-      * Runs scheduled flow tasks by flag within the flow budget, keeping unfinished ones for the next frame.
-  */
-  static #execFlowTasks() {
-    if (!Thread.#flowBitMask) return;
+  static #execTasks() {
+    let bitMask = Thread.#foreverBitMask | Thread.#flowBitMask;
+    if (!bitMask) return;
     const N1 = performance.now();
-    let bitMask = Thread.#flowBitMask, n = 0, wrapper;
+    let foreverUsage = 0, foreverBitMask = Thread.#foreverBitMask, flowBitMask = Thread.#flowBitMask, n = 0, wrapper;
     Thread.#flowBitMask = 0;
     do {
       const FLAG = bitMask & -bitMask;
       bitMask ^= FLAG;
-      Thread.#stack = Thread.#FLOW_MAP.get(FLAG);
-      Thread.#max = Thread.#stack.length;
-      if (!Thread.#max) continue;
-      Thread.#i = 0;
-      const N2 = n = performance.now(), BUDGET = (Thread.#flowBudget - N2 + N1) / (Thread.#getSize(bitMask) + 1);
-      TASK_LOOP: do {
-        const R = Thread.#execTask(wrapper = Thread.#stack[Thread.#i], BUDGET, N2, n);
-        wrapper = Thread.#FLOW_LISTED.get(wrapper[0]);
-        if (wrapper && wrapper[1] === FLAG) switch (R) {
-          case 0:
-            break TASK_LOOP;
-          case 1: {
-            if (wrapper[4]) {
-              wrapper[4] = false;
-              Thread.#stack[Thread.#i] = [Thread.App.void, FLAG, []];
-              Thread.#stack.push(wrapper);
-            } else Thread.#FLOW_LISTED.delete(wrapper[0]);
-            continue TASK_LOOP;
-          }
-          case 2: {
-            const TASK = wrapper[0];
-            wrapper[5].finally(() => {
-              wrapper = Thread.#FLOW_LISTED.get(TASK);
-              if (!wrapper) return;
+      if (foreverBitMask & FLAG) {
+        foreverBitMask ^= FLAG;
+        Thread.#stack = Thread.#FOREVER_MAP.get(FLAG);
+        Thread.#max = Thread.#stack.length;
+        if (Thread.#max) {
+          Thread.#i = 0;
+          const N2 = performance.now(), BUDGET = (Thread.#foreverBudget - N2 + N1) / (Thread.#getSize(foreverBitMask) + 1);
+          do {
+            Thread.#execTask(Thread.#stack[Thread.#i], BUDGET, N2);
+          } while (++Thread.#i < Thread.#max);
+          foreverUsage += performance.now() - N2;
+        } else Thread.#foreverBitMask ^= FLAG;
+      }
+      if (flowBitMask & FLAG) {
+        flowBitMask ^= FLAG;
+        Thread.#stack = Thread.#FLOW_MAP.get(FLAG);
+        Thread.#max = Thread.#stack.length;
+        if (!Thread.#max) continue;
+        Thread.#i = 0;
+        const N2 = n = performance.now(), BUDGET = (Thread.#flowBudget - N2 + N1 + foreverUsage) / (Thread.#getSize(flowBitMask) + 1);
+        FLOW_TASK_LOOP: do {
+          const R = Thread.#execTask(wrapper = Thread.#stack[Thread.#i], BUDGET, N2, n);
+          wrapper = Thread.#FLOW_LISTED.get(wrapper[0]);
+          if (wrapper && wrapper[1] === FLAG) switch (R) {
+            case 0:
+              break FLOW_TASK_LOOP;
+            case 1: {
               if (wrapper[4]) {
                 wrapper[4] = false;
-                const STACK = Thread.#FLOW_MAP.get(wrapper[1]);
-                if (!STACK) Thread.#FLOW_MAP.set(wrapper[1], [wrapper]);
-                else if (!STACK.includes(wrapper)) STACK.push(wrapper);
-                Thread.#flowBitMask |= wrapper[1];
+                Thread.#stack[Thread.#i] = [Thread.App.void, FLAG, []];
+                Thread.#stack.push(wrapper);
               } else Thread.#FLOW_LISTED.delete(wrapper[0]);
-            });
+              continue FLOW_TASK_LOOP;
+            }
+            case 2: {
+              const TASK = wrapper[0];
+              wrapper[5].finally(() => {
+                wrapper = Thread.#FLOW_LISTED.get(TASK);
+                if (!wrapper) return;
+                if (wrapper[4]) {
+                  wrapper[4] = false;
+                  const STACK = Thread.#FLOW_MAP.get(wrapper[1]);
+                  if (!STACK) Thread.#FLOW_MAP.set(wrapper[1], [wrapper]);
+                  else if (!STACK.includes(wrapper)) STACK.push(wrapper);
+                  Thread.#flowBitMask |= wrapper[1];
+                } else Thread.#FLOW_LISTED.delete(wrapper[0]);
+              });
+            }
+            default:
+              continue FLOW_TASK_LOOP;
           }
-          default:
-            continue TASK_LOOP;
-        }
-        else if (!R) {
-          ++Thread.#i;
-          break TASK_LOOP;
-        }
-      } while (++Thread.#i < Thread.#max && (n = performance.now()) - N2 < BUDGET);
-      Thread.#FLOW_MAP.set(FLAG, Thread.#stack = Thread.#stack.splice(Thread.#i));
-      if (Thread.#stack.length) Thread.#flowBitMask |= FLAG;
-    } while (bitMask);
-  }
-  /**
-      * Runs every forever task by flag, sharing the forever budget between flags.
-  */
-  static #execForeverTasks() {
-    if (!Thread.#foreverBitMask) return;
-    const N1 = performance.now();
-    let bitMask = Thread.#foreverBitMask;
-    do {
-      const FLAG = bitMask & -bitMask;
-      bitMask ^= FLAG;
-      Thread.#stack = Thread.#FOREVER_MAP.get(FLAG);
-      Thread.#max = Thread.#stack.length;
-      if (!Thread.#max) {
-        Thread.#foreverBitMask ^= FLAG;
-        continue;
+          else if (!R) {
+            ++Thread.#i;
+            break FLOW_TASK_LOOP;
+          }
+        } while (++Thread.#i < Thread.#max && (n = performance.now()) - N2 < BUDGET);
+        Thread.#FLOW_MAP.set(FLAG, Thread.#stack = Thread.#stack.splice(Thread.#i));
+        if (Thread.#stack.length) Thread.#flowBitMask |= FLAG;
       }
-      Thread.#i = 0;
-      const N2 = performance.now(), BUDGET = (Thread.#foreverBudget - N2 + N1) / (Thread.#getSize(bitMask) + 1);
-      do {
-        Thread.#execTask(Thread.#stack[Thread.#i], BUDGET, N2);
-      } while (++Thread.#i < Thread.#max);
     } while (bitMask);
   }
   // ##UTILS
   /**
-      * Throws if `flag` is not a power of 2 between `1` and `MAX_FLAG`.
+      * Throws if `flag` is not a power of 2 between `1` and {@link Thread.MAX_FLAG}.
   */
   static #checkFlag(flag) {
     if (flag < 1 || flag > Thread.#MAX_FLAG || (flag & flag - 1) !== 0) Logs.throw("THREAD", `THE FLAG MUST BE A POWER OF 2 AND LESS THAN OR EQUAL TO ${Thread.#MAX_FLAG}.`);
@@ -491,9 +519,9 @@ class Thread {
       * (the task stays scheduled until the promise settles).
       * @template T Task type, used to type `args`.
       * @param task The task function, identified by reference.
-      * @param flag Priority flag, a power of 2 from `1` to `4096`. Default: {@link Thread.MAX_FLAG} (`4096`).
+      * @param flag Priority flag, a power of 2 from `1` to {@link Thread.MAX_FLAG}. Default: {@link Thread.DEFAULT_FLAG} (`8192`).
       * @param args Arguments passed to the task when it runs (the latest call wins).
-      * @throws If `flag` is not a power of 2 between `1` and `4096`.
+      * @throws If `flag` is not a power of 2 between `1` and {@link Thread.MAX_FLAG} (`32768`).
       * @example
       * ```ts
       * function* build(items: HTMLElement[]): Generator<void, void, void>
@@ -518,7 +546,7 @@ class Thread {
       Thread.#add(Thread.#FLOW_MAP, Thread.#FLOW_LISTED, task, FLAG, args);
       Thread.#flowBitMask |= FLAG;
     }
-    if (Thread.#MODIFIERS_MAP.has(FLAG)) Thread.#modifiersBitMask |= FLAG;
+    Thread.arm(FLAG);
   }
   /**
       * Removes a scheduled task. A pending {@link Thread.wait} promise is resolved and a running generator is closed.
@@ -528,6 +556,20 @@ class Thread {
   static unsub(task) {
     task[FOREVER] ? Thread.#remove(Thread.#FOREVER_MAP, Thread.#FOREVER_LISTED, task) : Thread.#remove(Thread.#FLOW_MAP, Thread.#FLOW_LISTED, task);
   }
+  /**
+      * Arms modifiers of `flag` for the next modifiers phase (same frame if called from a driver or before modifiers run).
+      * No-op when no modifiers are registered on `flag`. {@link Thread.sub} calls this automatically; call it yourself
+      * when an external writer updates shared state without scheduling a task (e.g. Scroll arms {@link Thread.SCROLL_FLAG}
+      * after Lenis writes `window.scrollY`, so `App.updateScrollVars` and ScrollTrigger modifiers run).
+      * @param flag Priority flag whose modifiers should run.
+      * @example
+      * ```ts
+      * lenis.on('scroll', () => Up.Thread.arm(32))
+      * ```
+  */
+  static arm(flag) {
+    if (Thread.#MODIFIERS_MAP.has(flag)) Thread.#modifiersBitMask |= flag;
+  }
   /**
       * Returns a promise that resolves when a scheduled task completes its next (or current) run, or when it is unsubscribed.
       * @param task The same function reference passed to {@link Thread.sub}.