@react-three/fiber 10.0.0-canary.2c50459 → 10.0.0-canary.9806389

package/dist/index.cjs

@@ -15,7 +15,6 @@ const UltraHDRLoader_js = require('three/examples/jsm/loaders/UltraHDRLoader.js'
 const gainmapJs = require('@monogrid/gainmap-js');
 const Tb = require('scheduler');
 const traditional = require('zustand/traditional');
-const scheduler = require('@pmndrs/scheduler');
 const suspendReact = require('suspend-react');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -447,9 +446,9 @@ function Environment(props) {
   return props.ground ? /* @__PURE__ */ jsxRuntime.jsx(EnvironmentGround, { ...props }) : props.map ? /* @__PURE__ */ jsxRuntime.jsx(EnvironmentMap, { ...props }) : props.children ? /* @__PURE__ */ jsxRuntime.jsx(EnvironmentPortal, { ...props }) : /* @__PURE__ */ jsxRuntime.jsx(EnvironmentCube, { ...props });
 }
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
 const act = React__namespace["act"];
 const useIsomorphicLayoutEffect = /* @__PURE__ */ (() => typeof window !== "undefined" && (window.document?.createElement || window.navigator?.product === "ReactNative"))() ? React__namespace.useLayoutEffect : React__namespace.useEffect;
 function useMutableCallback(fn) {
@@ -481,7 +480,7 @@ const ErrorBoundary = /* @__PURE__ */ (() => {
   return _a = class extends React__namespace.Component {
     constructor() {
       super(...arguments);
-      __publicField(this, "state", { error: false });
+      __publicField$2(this, "state", { error: false });
     }
     componentDidCatch(err) {
       this.props.set(err);
@@ -489,7 +488,7 @@ const ErrorBoundary = /* @__PURE__ */ (() => {
     render() {
       return this.state.error ? null : this.props.children;
     }
-  }, __publicField(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
+  }, __publicField$2(_a, "getDerivedStateFromError", () => ({ error: true })), _a;
 })();
 
 const is = {
@@ -1649,6 +1648,1038 @@ function notifyAlpha({ message, link }) {
   }
 }
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+const DEFAULT_PHASES = ["start", "input", "physics", "update", "render", "finish"];
+class PhaseGraph {
+  constructor() {
+    /** Ordered list of phase nodes */
+    __publicField$1(this, "phases", []);
+    /** Quick lookup by name */
+    __publicField$1(this, "phaseMap", /* @__PURE__ */ new Map());
+    /** Cached ordered names (invalidated on changes) */
+    __publicField$1(this, "orderedNamesCache", null);
+    this.initializeDefaultPhases();
+  }
+  //* Initialization --------------------------------
+  initializeDefaultPhases() {
+    for (const name of DEFAULT_PHASES) {
+      const node = { name, isAutoGenerated: false };
+      this.phases.push(node);
+      this.phaseMap.set(name, node);
+    }
+    this.invalidateCache();
+  }
+  //* Public API --------------------------------
+  /**
+   * Add a named phase to the graph
+   * @param name - Phase name (must be unique)
+   * @param options - Position options (before or after another phase)
+   */
+  addPhase(name, options = {}) {
+    if (this.phaseMap.has(name)) {
+      console.warn(`[useFrame] Phase "${name}" already exists`);
+      return;
+    }
+    const { before, after } = options;
+    const node = { name, isAutoGenerated: false };
+    let insertIndex = this.phases.length;
+    const targetIndex = this.getPhaseIndex(before ?? after);
+    if (targetIndex !== -1) {
+      insertIndex = before ? targetIndex : targetIndex + 1;
+    } else {
+      const constraintType = before ? "before" : "after";
+      console.warn(`[useFrame] Phase "${before ?? after}" not found for '${constraintType}' constraint`);
+    }
+    this.phases.splice(insertIndex, 0, node);
+    this.phaseMap.set(name, node);
+    this.invalidateCache();
+  }
+  /**
+   * Get ordered list of phase names
+   */
+  getOrderedPhases() {
+    if (this.orderedNamesCache === null) this.orderedNamesCache = this.phases.map((p) => p.name);
+    return this.orderedNamesCache;
+  }
+  /**
+   * Check if a phase exists
+   */
+  hasPhase(name) {
+    return this.phaseMap.has(name);
+  }
+  /**
+   * Get the index of a phase (-1 if not found)
+   */
+  getPhaseIndex(name) {
+    if (!name) return -1;
+    return this.phases.findIndex((p) => p.name === name);
+  }
+  /**
+   * Ensure a phase exists, creating an auto-generated one if needed.
+   * Used for resolving before/after constraints.
+   *
+   * @param name - The phase name to ensure exists
+   * @returns The phase name (may be auto-generated like 'before:render')
+   */
+  ensurePhase(name) {
+    if (this.phaseMap.has(name)) return name;
+    const node = { name, isAutoGenerated: true };
+    this.phases.push(node);
+    this.phaseMap.set(name, node);
+    this.invalidateCache();
+    return name;
+  }
+  /**
+   * Resolve where a job with before/after constraints should go.
+   * Creates auto-generated phases if needed.
+   *
+   * @param before - Phase(s) to run before
+   * @param after - Phase(s) to run after
+   * @returns The resolved phase name
+   */
+  resolveConstraintPhase(before, after) {
+    const beforeArr = before ? Array.isArray(before) ? before : [before] : [];
+    const afterArr = after ? Array.isArray(after) ? after : [after] : [];
+    if (beforeArr.length > 0) {
+      return this.ensureAutoPhase(beforeArr[0], "before", 0);
+    }
+    if (afterArr.length > 0) {
+      return this.ensureAutoPhase(afterArr[0], "after", 1);
+    }
+    return "update";
+  }
+  /**
+   * Ensure an auto-generated phase exists relative to a target phase.
+   * Creates the phase if it doesn't exist, inserting it at the correct position.
+   *
+   * @param target - The target phase name to position relative to
+   * @param prefix - Prefix for auto-generated phase name ('before' or 'after')
+   * @param offset - Insertion offset (0 for before, 1 for after)
+   * @returns The auto-generated phase name
+   */
+  ensureAutoPhase(target, prefix, offset) {
+    const autoName = `${prefix}:${target}`;
+    if (this.phaseMap.has(autoName)) return autoName;
+    const node = { name: autoName, isAutoGenerated: true };
+    const targetIndex = this.getPhaseIndex(target);
+    if (targetIndex !== -1) this.phases.splice(targetIndex + offset, 0, node);
+    else this.phases.push(node);
+    this.phaseMap.set(autoName, node);
+    this.invalidateCache();
+    return autoName;
+  }
+  // Internal --------------------------------
+  invalidateCache() {
+    this.orderedNamesCache = null;
+  }
+}
+
+function rebuildSortedJobs(jobs, phaseGraph) {
+  const orderedPhases = phaseGraph.getOrderedPhases();
+  const buckets = /* @__PURE__ */ new Map();
+  for (const phase of orderedPhases) {
+    buckets.set(phase, []);
+  }
+  for (const job of jobs.values()) {
+    if (!job.enabled) continue;
+    let bucket = buckets.get(job.phase);
+    if (!bucket) {
+      bucket = [];
+      buckets.set(job.phase, bucket);
+    }
+    bucket.push(job);
+  }
+  const sortedBuckets = [];
+  for (const phase of orderedPhases) {
+    const bucket = buckets.get(phase);
+    if (!bucket || bucket.length === 0) continue;
+    bucket.sort((a, b) => {
+      if (a.priority !== b.priority) return b.priority - a.priority;
+      return a.index - b.index;
+    });
+    sortedBuckets.push(hasCrossJobConstraints(bucket) ? topologicalSort(bucket) : bucket);
+  }
+  for (const [phase, bucket] of buckets) {
+    if (!orderedPhases.includes(phase) && bucket.length > 0) {
+      bucket.sort((a, b) => {
+        if (a.priority !== b.priority) return b.priority - a.priority;
+        return a.index - b.index;
+      });
+      sortedBuckets.push(bucket);
+    }
+  }
+  return sortedBuckets.flat();
+}
+function hasCrossJobConstraints(bucket) {
+  const jobIds = new Set(bucket.map((j) => j.id));
+  for (const job of bucket) {
+    for (const ref of job.before) {
+      if (jobIds.has(ref)) return true;
+    }
+    for (const ref of job.after) {
+      if (jobIds.has(ref)) return true;
+    }
+  }
+  return false;
+}
+function topologicalSort(jobs) {
+  const n = jobs.length;
+  if (n <= 1) return jobs;
+  const jobMap = /* @__PURE__ */ new Map();
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjacency = /* @__PURE__ */ new Map();
+  for (const job of jobs) {
+    jobMap.set(job.id, job);
+    inDegree.set(job.id, 0);
+    adjacency.set(job.id, []);
+  }
+  for (const job of jobs) {
+    for (const ref of job.before) {
+      if (jobMap.has(ref)) {
+        adjacency.get(job.id).push(ref);
+        inDegree.set(ref, inDegree.get(ref) + 1);
+      }
+    }
+    for (const ref of job.after) {
+      if (jobMap.has(ref)) {
+        adjacency.get(ref).push(job.id);
+        inDegree.set(job.id, inDegree.get(job.id) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const job of jobs) {
+    if (inDegree.get(job.id) === 0) {
+      queue.push(job);
+    }
+  }
+  queue.sort((a, b) => {
+    if (a.priority !== b.priority) return b.priority - a.priority;
+    return a.index - b.index;
+  });
+  const result = [];
+  while (queue.length > 0) {
+    const job = queue.shift();
+    result.push(job);
+    const neighbors = adjacency.get(job.id) || [];
+    for (const neighborId of neighbors) {
+      const newDegree = inDegree.get(neighborId) - 1;
+      inDegree.set(neighborId, newDegree);
+      if (newDegree === 0) {
+        const neighbor = jobMap.get(neighborId);
+        insertSorted(queue, neighbor);
+      }
+    }
+  }
+  if (result.length !== n) {
+    console.warn("[useFrame] Circular dependency detected in job constraints");
+    const resultIds = new Set(result.map((j) => j.id));
+    for (const job of jobs) {
+      if (!resultIds.has(job.id)) result.push(job);
+    }
+  }
+  return result;
+}
+function insertSorted(arr, job) {
+  let i = 0;
+  while (i < arr.length) {
+    const cmp = arr[i];
+    if (job.priority > cmp.priority || job.priority === cmp.priority && job.index < cmp.index) {
+      break;
+    }
+    i++;
+  }
+  arr.splice(i, 0, job);
+}
+
+function shouldRun(job, now) {
+  if (!job.enabled) return false;
+  if (!job.fps) return true;
+  const minInterval = 1e3 / job.fps;
+  const lastRun = job.lastRun ?? 0;
+  const elapsed = now - lastRun;
+  if (elapsed < minInterval - 1) return false;
+  if (job.drop) {
+    job.lastRun = now;
+  } else {
+    const steps = Math.floor(elapsed / minInterval);
+    job.lastRun = lastRun + steps * minInterval;
+    if (job.lastRun < now - minInterval) {
+      job.lastRun = now;
+    }
+  }
+  return true;
+}
+function resetJobTiming(job) {
+  job.lastRun = void 0;
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const hmrData = (() => {
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "test") return void 0;
+  if (typeof import_meta_hot !== "undefined") return import_meta_hot;
+  try {
+    return (0, eval)("import.meta.hot");
+  } catch {
+    return void 0;
+  }
+})();
+const _Scheduler = class _Scheduler {
+  //* Constructor ================================
+  constructor() {
+    //* Critical State ================================
+    __publicField(this, "roots", /* @__PURE__ */ new Map());
+    __publicField(this, "phaseGraph");
+    __publicField(this, "loopState", {
+      running: false,
+      rafHandle: null,
+      lastTime: null,
+      // null = uninitialized, 0+ = valid timestamp
+      frameCount: 0,
+      elapsedTime: 0,
+      createdAt: performance.now()
+    });
+    __publicField(this, "stoppedTime", 0);
+    //* Private State ================================
+    __publicField(this, "nextRootIndex", 0);
+    __publicField(this, "globalBeforeJobs", /* @__PURE__ */ new Map());
+    __publicField(this, "globalAfterJobs", /* @__PURE__ */ new Map());
+    __publicField(this, "nextGlobalIndex", 0);
+    __publicField(this, "idleCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "nextJobIndex", 0);
+    __publicField(this, "jobStateListeners", /* @__PURE__ */ new Map());
+    __publicField(this, "pendingFrames", 0);
+    __publicField(this, "_frameloop", "always");
+    //* Independent Mode & Error Handling State ================================
+    __publicField(this, "_independent", false);
+    __publicField(this, "errorHandler", null);
+    __publicField(this, "rootReadyCallbacks", /* @__PURE__ */ new Set());
+    //* Core Loop Execution Methods ================================
+    /**
+     * Main RAF loop callback.
+     * Executes frame, handles demand mode, and schedules next frame.
+     * @param {number} timestamp - RAF timestamp in milliseconds
+     * @returns {void}
+     * @private
+     */
+    __publicField(this, "loop", (timestamp) => {
+      if (!this.loopState.running) return;
+      this.executeFrame(timestamp);
+      if (this._frameloop === "demand") {
+        this.pendingFrames = Math.max(0, this.pendingFrames - 1);
+        if (this.pendingFrames === 0) {
+          this.notifyIdle(timestamp);
+          return this.stop();
+        }
+      }
+      this.loopState.rafHandle = requestAnimationFrame(this.loop);
+    });
+    this.phaseGraph = new PhaseGraph();
+  }
+  static get instance() {
+    return globalThis[_Scheduler.INSTANCE_KEY] ?? null;
+  }
+  static set instance(value) {
+    globalThis[_Scheduler.INSTANCE_KEY] = value;
+  }
+  /**
+   * Get the global scheduler instance (creates if doesn't exist).
+   * Uses HMR data to preserve instance across hot reloads.
+   * @returns {Scheduler} The singleton scheduler instance
+   */
+  static get() {
+    if (!_Scheduler.instance && hmrData?.data?.scheduler) {
+      _Scheduler.instance = hmrData.data.scheduler;
+    }
+    if (!_Scheduler.instance) {
+      _Scheduler.instance = new _Scheduler();
+      if (hmrData?.data) {
+        hmrData.data.scheduler = _Scheduler.instance;
+      }
+    }
+    return _Scheduler.instance;
+  }
+  /**
+   * Reset the singleton instance. Stops the loop and clears all state.
+   * Primarily used for testing to ensure clean state between tests.
+   * @returns {void}
+   */
+  static reset() {
+    if (_Scheduler.instance) {
+      _Scheduler.instance.stop();
+      _Scheduler.instance = null;
+    }
+    if (hmrData?.data) {
+      hmrData.data.scheduler = null;
+    }
+  }
+  //* Getters & Setters ================================
+  get phases() {
+    return this.phaseGraph.getOrderedPhases();
+  }
+  get frameloop() {
+    return this._frameloop;
+  }
+  set frameloop(mode) {
+    if (this._frameloop === mode) return;
+    const wasAlways = this._frameloop === "always";
+    this._frameloop = mode;
+    if (mode === "always" && !this.loopState.running && this.roots.size > 0) this.start();
+    else if (mode !== "always" && wasAlways) this.stop();
+  }
+  get isRunning() {
+    return this.loopState.running;
+  }
+  get isReady() {
+    return this.roots.size > 0;
+  }
+  get independent() {
+    return this._independent;
+  }
+  set independent(value) {
+    this._independent = value;
+    if (value) this.ensureDefaultRoot();
+  }
+  //* Root Management Methods ================================
+  /**
+   * Register a root (Canvas) with the scheduler.
+   * The first root to register starts the RAF loop (if frameloop='always').
+   * @param {string} id - Unique identifier for this root
+   * @param {RootOptions} [options] - Optional configuration with getState and onError callbacks
+   * @returns {() => void} Unsubscribe function to remove this root
+   */
+  registerRoot(id, options = {}) {
+    if (this.roots.has(id)) {
+      console.warn(`[Scheduler] Root "${id}" already registered`);
+      return () => this.unregisterRoot(id);
+    }
+    const entry = {
+      id,
+      getState: options.getState ?? (() => ({})),
+      jobs: /* @__PURE__ */ new Map(),
+      sortedJobs: [],
+      needsRebuild: false
+    };
+    if (options.onError) {
+      this.errorHandler = options.onError;
+    }
+    this.roots.set(id, entry);
+    if (this.roots.size === 1) {
+      this.notifyRootReady();
+      if (this._frameloop === "always") this.start();
+    }
+    return () => this.unregisterRoot(id);
+  }
+  /**
+   * Unregister a root from the scheduler.
+   * Cleans up all job state listeners for this root's jobs.
+   * The last root to unregister stops the RAF loop.
+   * @param {string} id - The root ID to unregister
+   * @returns {void}
+   */
+  unregisterRoot(id) {
+    const root = this.roots.get(id);
+    if (!root) return;
+    for (const jobId of root.jobs.keys()) {
+      this.jobStateListeners.delete(jobId);
+    }
+    this.roots.delete(id);
+    if (this.roots.size === 0) {
+      this.stop();
+      this.errorHandler = null;
+    }
+  }
+  /**
+   * Subscribe to be notified when a root becomes available.
+   * Fires immediately if a root already exists.
+   * @param {() => void} callback - Function called when first root registers
+   * @returns {() => void} Unsubscribe function
+   */
+  onRootReady(callback) {
+    if (this.roots.size > 0) {
+      callback();
+      return () => {
+      };
+    }
+    this.rootReadyCallbacks.add(callback);
+    return () => this.rootReadyCallbacks.delete(callback);
+  }
+  /**
+   * Notify all registered root-ready callbacks.
+   * Called when the first root registers.
+   * @returns {void}
+   * @private
+   */
+  notifyRootReady() {
+    for (const cb of this.rootReadyCallbacks) {
+      try {
+        cb();
+      } catch (error) {
+        console.error("[Scheduler] Error in root-ready callback:", error);
+      }
+    }
+    this.rootReadyCallbacks.clear();
+  }
+  /**
+   * Ensure a default root exists for independent mode.
+   * Creates a minimal root with no state provider.
+   * @returns {void}
+   * @private
+   */
+  ensureDefaultRoot() {
+    if (!this.roots.has("__default__")) {
+      this.registerRoot("__default__");
+    }
+  }
+  /**
+   * Trigger error handling for job errors.
+   * Uses the bound error handler if available, otherwise logs to console.
+   * @param {Error} error - The error to handle
+   * @returns {void}
+   */
+  triggerError(error) {
+    if (this.errorHandler) this.errorHandler(error);
+    else console.error("[Scheduler]", error);
+  }
+  //* Phase Management Methods ================================
+  /**
+   * Add a named phase to the scheduler's execution order.
+   * Marks all roots for rebuild to incorporate the new phase.
+   * @param {string} name - The phase name (e.g., 'physics', 'postprocess')
+   * @param {AddPhaseOptions} [options] - Positioning options (before/after other phases)
+   * @returns {void}
+   * @example
+   * scheduler.addPhase('physics', { before: 'update' });
+   * scheduler.addPhase('postprocess', { after: 'render' });
+   */
+  addPhase(name, options) {
+    this.phaseGraph.addPhase(name, options);
+    for (const root of this.roots.values()) {
+      root.needsRebuild = true;
+    }
+  }
+  /**
+   * Check if a phase exists in the scheduler.
+   * @param {string} name - The phase name to check
+   * @returns {boolean} True if the phase exists
+   */
+  hasPhase(name) {
+    return this.phaseGraph.hasPhase(name);
+  }
+  //* Global Job Registration Methods (Deprecated APIs) ================================
+  /**
+   * Register a global job that runs once per frame (not per-root).
+   * Used internally by deprecated addEffect/addAfterEffect APIs.
+   * @param {'before' | 'after'} phase - When to run: 'before' all roots or 'after' all roots
+   * @param {string} id - Unique identifier for this global job
+   * @param {(timestamp: number) => void} callback - Function called each frame with RAF timestamp
+   * @returns {() => void} Unsubscribe function to remove this global job
+   * @deprecated Use useFrame with phases instead
+   */
+  registerGlobal(phase, id, callback) {
+    const job = { id, callback };
+    if (phase === "before") {
+      this.globalBeforeJobs.set(id, job);
+    } else {
+      this.globalAfterJobs.set(id, job);
+    }
+    return () => {
+      if (phase === "before") this.globalBeforeJobs.delete(id);
+      else this.globalAfterJobs.delete(id);
+    };
+  }
+  //* Idle Callback Methods (Deprecated API) ================================
+  /**
+   * Register an idle callback that fires when the loop stops.
+   * Used internally by deprecated addTail API.
+   * @param {(timestamp: number) => void} callback - Function called when loop becomes idle
+   * @returns {() => void} Unsubscribe function to remove this idle callback
+   * @deprecated Use demand mode with invalidate() instead
+   */
+  onIdle(callback) {
+    this.idleCallbacks.add(callback);
+    return () => this.idleCallbacks.delete(callback);
+  }
+  /**
+   * Notify all registered idle callbacks.
+   * Called when the loop stops in demand mode.
+   * @param {number} timestamp - The RAF timestamp when idle occurred
+   * @returns {void}
+   * @private
+   */
+  notifyIdle(timestamp) {
+    for (const cb of this.idleCallbacks) {
+      try {
+        cb(timestamp);
+      } catch (error) {
+        console.error("[Scheduler] Error in idle callback:", error);
+      }
+    }
+  }
+  //* Job Registration & Management Methods ================================
+  /**
+   * Register a job (frame callback) with a specific root.
+   * This is the core registration method used by useFrame internally.
+   * @param {FrameNextCallback} callback - The function to call each frame
+   * @param {JobOptions & { rootId?: string; system?: boolean }} [options] - Job configuration
+   * @param {string} [options.rootId] - Target root ID (defaults to first registered root)
+   * @param {string} [options.id] - Unique job ID (auto-generated if not provided)
+   * @param {string} [options.phase] - Execution phase (defaults to 'update')
+   * @param {number} [options.priority] - Priority within phase (higher = earlier, default 0)
+   * @param {number} [options.fps] - FPS throttle limit
+   * @param {boolean} [options.drop] - Drop frames when behind (default true)
+   * @param {boolean} [options.enabled] - Whether job is active (default true)
+   * @param {boolean} [options.system] - Internal flag for system jobs (not user-facing)
+   * @returns {() => void} Unsubscribe function to remove this job
+   */
+  register(callback, options = {}) {
+    const rootId = options.rootId;
+    const root = rootId ? this.roots.get(rootId) : this.roots.values().next().value;
+    if (!root) {
+      console.warn("[Scheduler] No root registered. Is this inside a Canvas?");
+      return () => {
+      };
+    }
+    const id = options.id ?? this.generateJobId();
+    let phase = options.phase ?? "update";
+    if (!options.phase && (options.before || options.after)) {
+      phase = this.phaseGraph.resolveConstraintPhase(options.before, options.after);
+    }
+    const before = this.normalizeConstraints(options.before);
+    const after = this.normalizeConstraints(options.after);
+    const job = {
+      id,
+      callback,
+      phase,
+      before,
+      after,
+      priority: options.priority ?? 0,
+      index: this.nextJobIndex++,
+      fps: options.fps,
+      drop: options.drop ?? true,
+      enabled: options.enabled ?? true,
+      system: options.system ?? false
+    };
+    if (root.jobs.has(id)) {
+      console.warn(`[useFrame] Job with id "${id}" already exists, replacing`);
+    }
+    root.jobs.set(id, job);
+    root.needsRebuild = true;
+    return () => this.unregister(id, root.id);
+  }
+  /**
+   * Unregister a job by its ID.
+   * Searches all roots if rootId is not provided.
+   * @param {string} id - The job ID to unregister
+   * @param {string} [rootId] - Optional root ID to search (searches all if not provided)
+   * @returns {void}
+   */
+  unregister(id, rootId) {
+    const root = rootId ? this.roots.get(rootId) : Array.from(this.roots.values()).find((r) => r.jobs.has(id));
+    if (root?.jobs.delete(id)) {
+      root.needsRebuild = true;
+      this.jobStateListeners.delete(id);
+    }
+  }
+  /**
+   * Update a job's options dynamically.
+   * Searches all roots to find the job by ID.
+   * Phase/constraint changes trigger a rebuild of the sorted job list.
+   * @param {string} id - The job ID to update
+   * @param {Partial<JobOptions>} options - The options to update
+   * @returns {void}
+   */
+  updateJob(id, options) {
+    let job;
+    let root;
+    for (const r of this.roots.values()) {
+      job = r.jobs.get(id);
+      if (job) {
+        root = r;
+        break;
+      }
+    }
+    if (!job || !root) return;
+    if (options.priority !== void 0) job.priority = options.priority;
+    if (options.fps !== void 0) job.fps = options.fps;
+    if (options.drop !== void 0) job.drop = options.drop;
+    if (options.enabled !== void 0) {
+      const wasEnabled = job.enabled;
+      job.enabled = options.enabled;
+      if (!wasEnabled && job.enabled) resetJobTiming(job);
+      if (wasEnabled !== job.enabled) root.needsRebuild = true;
+    }
+    if (options.phase !== void 0 || options.before !== void 0 || options.after !== void 0) {
+      if (options.phase) job.phase = options.phase;
+      if (options.before !== void 0) job.before = this.normalizeConstraints(options.before);
+      if (options.after !== void 0) job.after = this.normalizeConstraints(options.after);
+      root.needsRebuild = true;
+    }
+  }
+  //* Job State Management Methods ================================
+  /**
+   * Check if a job is currently paused (disabled).
+   * @param {string} id - The job ID to check
+   * @returns {boolean} True if the job exists and is paused
+   */
+  isJobPaused(id) {
+    for (const root of this.roots.values()) {
+      const job = root.jobs.get(id);
+      if (job) return !job.enabled;
+    }
+    return false;
+  }
+  /**
+   * Subscribe to state changes for a specific job.
+   * Listener is called when job is paused or resumed.
+   * @param {string} id - The job ID to subscribe to
+   * @param {() => void} listener - Callback invoked on state changes
+   * @returns {() => void} Unsubscribe function
+   */
+  subscribeJobState(id, listener) {
+    if (!this.jobStateListeners.has(id)) {
+      this.jobStateListeners.set(id, /* @__PURE__ */ new Set());
+    }
+    this.jobStateListeners.get(id).add(listener);
+    return () => {
+      this.jobStateListeners.get(id)?.delete(listener);
+      if (this.jobStateListeners.get(id)?.size === 0) {
+        this.jobStateListeners.delete(id);
+      }
+    };
+  }
+  /**
+   * Notify all listeners that a job's state has changed.
+   * @param {string} id - The job ID that changed
+   * @returns {void}
+   * @private
+   */
+  notifyJobStateChange(id) {
+    this.jobStateListeners.get(id)?.forEach((listener) => listener());
+  }
+  /**
+   * Pause a job by ID (sets enabled=false).
+   * Notifies any subscribed state listeners.
+   * @param {string} id - The job ID to pause
+   * @returns {void}
+   */
+  pauseJob(id) {
+    this.updateJob(id, { enabled: false });
+    this.notifyJobStateChange(id);
+  }
+  /**
+   * Resume a paused job by ID (sets enabled=true).
+   * Resets job timing to prevent frame accumulation.
+   * Notifies any subscribed state listeners.
+   * @param {string} id - The job ID to resume
+   * @returns {void}
+   */
+  resumeJob(id) {
+    this.updateJob(id, { enabled: true });
+    this.notifyJobStateChange(id);
+  }
+  //* Frame Loop Control Methods ================================
+  /**
+   * Start the requestAnimationFrame loop.
+   * Resets timing state (elapsedTime, frameCount) on start.
+   * No-op if already running.
+   * @returns {void}
+   */
+  start() {
+    if (this.loopState.running) return;
+    const { elapsedTime, createdAt } = this.loopState;
+    let adjustedCreated = 0;
+    if (this.stoppedTime > 0) {
+      adjustedCreated = createdAt - (performance.now() - this.stoppedTime);
+      this.stoppedTime = 0;
+    }
+    Object.assign(this.loopState, {
+      running: true,
+      elapsedTime: elapsedTime ?? 0,
+      lastTime: performance.now(),
+      createdAt: adjustedCreated > 0 ? adjustedCreated : performance.now(),
+      frameCount: 0,
+      rafHandle: requestAnimationFrame(this.loop)
+    });
+  }
+  /**
+   * Stop the requestAnimationFrame loop.
+   * Cancels any pending RAF callback.
+   * No-op if not running.
+   * @returns {void}
+   */
+  stop() {
+    if (!this.loopState.running) return;
+    this.loopState.running = false;
+    if (this.loopState.rafHandle !== null) {
+      cancelAnimationFrame(this.loopState.rafHandle);
+      this.loopState.rafHandle = null;
+    }
+    this.stoppedTime = performance.now();
+  }
+  /**
+   * Request frames to be rendered in demand mode.
+   * Accumulates pending frames (capped at 60) and starts the loop if not running.
+   * No-op if frameloop is not 'demand'.
+   * @param {number} [frames=1] - Number of frames to request
+   * @param {boolean} [stackFrames=false] - Whether to add frames to existing pending count
+   *   - `false` (default): Sets pending frames to the specified value (replaces existing count)
+   *   - `true`: Adds frames to existing pending count (useful for accumulating invalidations)
+   * @returns {void}
+   * @example
+   * // Request a single frame render
+   * scheduler.invalidate();
+   *
+   * @example
+   * // Request 5 frames (e.g., for animations)
+   * scheduler.invalidate(5);
+   *
+   * @example
+   * // Set pending frames to exactly 3 (don't stack with existing)
+   * scheduler.invalidate(3, false);
+   *
+   * @example
+   * // Add 2 more frames to existing pending count
+   * scheduler.invalidate(2, true);
+   */
+  invalidate(frames = 1, stackFrames = false) {
+    if (this._frameloop !== "demand") return;
+    const baseFrames = stackFrames ? this.pendingFrames : 0;
+    this.pendingFrames = Math.min(60, baseFrames + frames);
+    if (!this.loopState.running && this.pendingFrames > 0) this.start();
+  }
+  /**
+   * Reset timing state for deterministic testing.
+   * Preserves jobs and roots but resets lastTime, frameCount, elapsedTime, etc.
+   * @returns {void}
+   */
+  resetTiming() {
+    this.loopState.lastTime = null;
+    this.loopState.frameCount = 0;
+    this.loopState.elapsedTime = 0;
+    this.loopState.createdAt = performance.now();
+  }
+  //* Manual Stepping Methods ================================
+  /**
+   * Manually execute a single frame for all roots.
+   * Useful for frameloop='never' mode or testing scenarios.
+   * @param {number} [timestamp] - Optional timestamp (defaults to performance.now())
+   * @returns {void}
+   * @example
+   * // Manual control mode
+   * scheduler.frameloop = 'never';
+   * scheduler.step(); // Execute one frame
+   */
+  step(timestamp) {
+    const now = timestamp ?? performance.now();
+    this.executeFrame(now);
+  }
+  /**
+   * Manually execute a single job by its ID.
+   * Useful for testing individual job callbacks in isolation.
+   * @param {string} id - The job ID to step
+   * @param {number} [timestamp] - Optional timestamp (defaults to performance.now())
+   * @returns {void}
+   */
+  stepJob(id, timestamp) {
+    let job;
+    let root;
+    for (const r of this.roots.values()) {
+      job = r.jobs.get(id);
+      if (job) {
+        root = r;
+        break;
+      }
+    }
+    if (!job || !root) {
+      console.warn(`[Scheduler] Job "${id}" not found`);
+      return;
+    }
+    const now = timestamp ?? performance.now();
+    const deltaMs = this.loopState.lastTime !== null ? now - this.loopState.lastTime : 0;
+    const delta = deltaMs / 1e3;
+    const elapsed = now - this.loopState.createdAt;
+    const providedState = root.getState?.() ?? {};
+    const frameState = {
+      ...providedState,
+      time: now,
+      delta,
+      elapsed,
+      frame: this.loopState.frameCount
+    };
+    try {
+      job.callback(frameState, delta);
+    } catch (error) {
+      console.error(`[Scheduler] Error in job "${job.id}":`, error);
+      this.triggerError(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Execute a single frame across all roots.
+   * Order: globalBefore → each root's jobs → globalAfter
+   * @param {number} timestamp - RAF timestamp in milliseconds
+   * @returns {void}
+   * @private
+   */
+  executeFrame(timestamp) {
+    const deltaMs = this.loopState.lastTime !== null ? timestamp - this.loopState.lastTime : 0;
+    const delta = deltaMs / 1e3;
+    this.loopState.lastTime = timestamp;
+    this.loopState.frameCount++;
+    this.loopState.elapsedTime += deltaMs;
+    this.runGlobalJobs(this.globalBeforeJobs, timestamp);
+    for (const root of this.roots.values()) {
+      this.tickRoot(root, timestamp, delta);
+    }
+    this.runGlobalJobs(this.globalAfterJobs, timestamp);
+  }
+  /**
+   * Run all global jobs from a job map.
+   * Catches and logs errors without stopping execution.
+   * @param {Map<string, GlobalJob>} jobs - The global jobs map to execute
+   * @param {number} timestamp - RAF timestamp in milliseconds
+   * @returns {void}
+   * @private
+   */
+  runGlobalJobs(jobs, timestamp) {
+    for (const job of jobs.values()) {
+      try {
+        job.callback(timestamp);
+      } catch (error) {
+        console.error(`[Scheduler] Error in global job "${job.id}":`, error);
+      }
+    }
+  }
+  /**
+   * Execute all jobs for a single root in sorted order.
+   * Rebuilds sorted job list if needed, then dispatches each job.
+   * Errors are caught and propagated via triggerError.
+   * @param {RootEntry} root - The root entry to tick
+   * @param {number} timestamp - RAF timestamp in milliseconds
+   * @param {number} delta - Time since last frame in seconds
+   * @returns {void}
+   * @private
+   */
+  tickRoot(root, timestamp, delta) {
+    if (root.needsRebuild) {
+      root.sortedJobs = rebuildSortedJobs(root.jobs, this.phaseGraph);
+      root.needsRebuild = false;
+    }
+    const providedState = root.getState?.() ?? {};
+    const frameState = {
+      ...providedState,
+      time: timestamp,
+      delta,
+      elapsed: this.loopState.elapsedTime / 1e3,
+      // Convert ms to seconds
+      frame: this.loopState.frameCount
+    };
+    for (const job of root.sortedJobs) {
+      if (!shouldRun(job, timestamp)) continue;
+      try {
+        job.callback(frameState, delta);
+      } catch (error) {
+        console.error(`[Scheduler] Error in job "${job.id}":`, error);
+        this.triggerError(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+  //* Debug & Inspection Methods ================================
+  /**
+   * Get the total number of registered jobs across all roots.
+   * Includes both per-root jobs and global before/after jobs.
+   * @returns {number} Total job count
+   */
+  getJobCount() {
+    let count = 0;
+    for (const root of this.roots.values()) {
+      count += root.jobs.size;
+    }
+    return count + this.globalBeforeJobs.size + this.globalAfterJobs.size;
+  }
+  /**
+   * Get all registered job IDs across all roots.
+   * Includes both per-root jobs and global before/after jobs.
+   * @returns {string[]} Array of all job IDs
+   */
+  getJobIds() {
+    const ids = [];
+    for (const root of this.roots.values()) {
+      ids.push(...root.jobs.keys());
+    }
+    ids.push(...this.globalBeforeJobs.keys());
+    ids.push(...this.globalAfterJobs.keys());
+    return ids;
+  }
+  /**
+   * Get the number of registered roots (Canvas instances).
+   * @returns {number} Number of registered roots
+   */
+  getRootCount() {
+    return this.roots.size;
+  }
+  /**
+   * Check if any user (non-system) jobs are registered in a specific phase.
+   * Used by the default render job to know if a user has taken over rendering.
+   *
+   * @param phase The phase to check
+   * @param rootId Optional root ID to check (checks all roots if not provided)
+   * @returns true if any user jobs exist in the phase
+   */
+  hasUserJobsInPhase(phase, rootId) {
+    const rootsToCheck = rootId ? [this.roots.get(rootId)].filter(Boolean) : Array.from(this.roots.values());
+    return rootsToCheck.some((root) => {
+      if (!root) return false;
+      for (const job of root.jobs.values()) {
+        if (job.phase === phase && !job.system && job.enabled) return true;
+      }
+      return false;
+    });
+  }
+  //* Utility Methods ================================
+  /**
+   * Generate a unique root ID for automatic root registration.
+   * @returns {string} A unique root ID in the format 'root_N'
+   */
+  generateRootId() {
+    return `root_${this.nextRootIndex++}`;
+  }
+  /**
+   * Generate a unique job ID.
+   * @returns {string} A unique job ID in the format 'job_N'
+   * @private
+   */
+  generateJobId() {
+    return `job_${this.nextJobIndex}`;
+  }
+  /**
+   * Normalize before/after constraints to a Set.
+   * Handles undefined, single string, or array inputs.
+   * @param {string | string[] | undefined} value - The constraint value(s)
+   * @returns {Set<string>} Normalized Set of constraint strings
+   * @private
+   */
+  normalizeConstraints(value) {
+    if (!value) return /* @__PURE__ */ new Set();
+    if (Array.isArray(value)) return new Set(value);
+    return /* @__PURE__ */ new Set([value]);
+  }
+};
+//* Static State & Methods (Singleton Usage) ================================
+//* Cross-Bundle Singleton Key ==============================
+// Use Symbol.for() to ensure scheduler is shared across bundle boundaries
+// This prevents issues when mixing imports from @react-three/fiber and @react-three/fiber/webgpu
+__publicField(_Scheduler, "INSTANCE_KEY", Symbol.for("@react-three/fiber.scheduler"));
+let Scheduler = _Scheduler;
+const getScheduler = () => Scheduler.get();
+if (hmrData) {
+  hmrData.accept?.();
+}
+
 const R3F_CONTEXT = Symbol.for("@react-three/fiber.context");
 const context = globalThis[R3F_CONTEXT] ?? (globalThis[R3F_CONTEXT] = React__namespace.createContext(null));
 const createStore = (invalidate, advance) => {
@@ -1758,7 +2789,7 @@ const createStore = (invalidate, advance) => {
                 size: newSize,
                 viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, newSize) }
               }));
-              scheduler.getScheduler().invalidate();
+              getScheduler().invalidate();
             }
           }
           return;
@@ -1773,7 +2804,7 @@ const createStore = (invalidate, advance) => {
           viewport: { ...s.viewport, ...getCurrentViewport(state2.camera, defaultTarget, size) },
           _sizeImperative: true
         }));
-        scheduler.getScheduler().invalidate();
+        getScheduler().invalidate();
       },
       setDpr: (dpr) => set((state2) => {
         const resolved = calculateDpr(dpr);
@@ -1981,7 +3012,7 @@ useLoader.loader = getLoader;
 function useFrame(callback, priorityOrOptions) {
   const store = React__namespace.useContext(context);
   const isInsideCanvas = store !== null;
-  const scheduler$1 = scheduler.getScheduler();
+  const scheduler = getScheduler();
   const optionsKey = typeof priorityOrOptions === "number" ? `p:${priorityOrOptions}` : priorityOrOptions ? JSON.stringify({
     id: priorityOrOptions.id,
     phase: priorityOrOptions.phase,
@@ -2029,7 +3060,7 @@ function useFrame(callback, priorityOrOptions) {
         };
         callbackRef.current?.(mergedState, delta);
       };
-      const unregister = scheduler$1.register(wrappedCallback, {
+      const unregister = scheduler.register(wrappedCallback, {
         id,
         rootId,
         ...options
@@ -2050,31 +3081,37 @@ function useFrame(callback, priorityOrOptions) {
         }
       };
     } else {
-      return scheduler$1.register(
-        (state, delta) => {
-          const frameState = state;
-          if (!frameState.renderer) return;
-          callbackRef.current?.(frameState, delta);
-        },
-        { id, ...options }
-      );
+      const registerOutside = () => {
+        return scheduler.register((state, delta) => callbackRef.current?.(state, delta), { id, ...options });
+      };
+      if (scheduler.independent || scheduler.isReady) {
+        return registerOutside();
+      }
+      let unregisterJob = null;
+      const unsubReady = scheduler.onRootReady(() => {
+        unregisterJob = registerOutside();
+      });
+      return () => {
+        unsubReady();
+        unregisterJob?.();
+      };
     }
-  }, [store, scheduler$1, id, optionsKey, isLegacyPriority, isInsideCanvas]);
+  }, [store, scheduler, id, optionsKey, isLegacyPriority, isInsideCanvas]);
   const isPaused = React__namespace.useSyncExternalStore(
     // Subscribe function
     React__namespace.useCallback(
       (onStoreChange) => {
-        return scheduler.getScheduler().subscribeJobState(id, onStoreChange);
+        return getScheduler().subscribeJobState(id, onStoreChange);
       },
       [id]
     ),
     // getSnapshot function
-    React__namespace.useCallback(() => scheduler.getScheduler().isJobPaused(id), [id]),
+    React__namespace.useCallback(() => getScheduler().isJobPaused(id), [id]),
     // getServerSnapshot function (SSR)
     React__namespace.useCallback(() => false, [])
   );
   const controls = React__namespace.useMemo(() => {
-    const scheduler2 = scheduler.getScheduler();
+    const scheduler2 = getScheduler();
     return {
       /** The job's unique ID */
       id,
@@ -2089,7 +3126,7 @@ function useFrame(callback, priorityOrOptions) {
        * @param timestamp Optional timestamp (defaults to performance.now())
        */
       step: (timestamp) => {
-        scheduler.getScheduler().stepJob(id, timestamp);
+        getScheduler().stepJob(id, timestamp);
       },
       /**
        * Manually step ALL jobs in the scheduler.
@@ -2097,20 +3134,20 @@ function useFrame(callback, priorityOrOptions) {
        * @param timestamp Optional timestamp (defaults to performance.now())
        */
       stepAll: (timestamp) => {
-        scheduler.getScheduler().step(timestamp);
+        getScheduler().step(timestamp);
       },
       /**
        * Pause this job (set enabled=false).
        * Job remains registered but won't run.
        */
       pause: () => {
-        scheduler.getScheduler().pauseJob(id);
+        getScheduler().pauseJob(id);
       },
       /**
        * Resume this job (set enabled=true).
        */
       resume: () => {
-        scheduler.getScheduler().resumeJob(id);
+        getScheduler().resumeJob(id);
       },
       /**
        * Reactive paused state - automatically updates when pause/resume is called.
@@ -2370,7 +3407,7 @@ function addEffect(callback) {
     link: "https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe"
   });
   const id = `legacy_effect_${effectId++}`;
-  return scheduler.getScheduler().registerGlobal("before", id, callback);
+  return getScheduler().registerGlobal("before", id, callback);
 }
 function addAfterEffect(callback) {
   notifyDepreciated({
@@ -2379,7 +3416,7 @@ function addAfterEffect(callback) {
     link: "https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe"
   });
   const id = `legacy_afterEffect_${effectId++}`;
-  return scheduler.getScheduler().registerGlobal("after", id, callback);
+  return getScheduler().registerGlobal("after", id, callback);
 }
 function addTail(callback) {
   notifyDepreciated({
@@ -2387,13 +3424,13 @@ function addTail(callback) {
     body: "Use scheduler.onIdle(callback) instead.\naddTail will be removed in a future version.",
     link: "https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe"
   });
-  return scheduler.getScheduler().onIdle(callback);
+  return getScheduler().onIdle(callback);
 }
 function invalidate(state, frames = 1, stackFrames = false) {
-  scheduler.getScheduler().invalidate(frames, stackFrames);
+  getScheduler().invalidate(frames, stackFrames);
 }
 function advance(timestamp) {
-  scheduler.getScheduler().step(timestamp);
+  getScheduler().step(timestamp);
 }
 
 const version = "10.0.0-alpha.2";
@@ -14438,15 +15475,15 @@ function createRoot(canvas) {
           applyProps(currentRenderer, rendererProps);
         }
       }
-      const scheduler$1 = scheduler.getScheduler();
+      const scheduler = getScheduler();
       const rootId = state.internal.rootId;
       if (!rootId) {
-        const newRootId = canvasId || scheduler$1.generateRootId();
-        const unregisterRoot = scheduler$1.registerRoot(newRootId, {
+        const newRootId = canvasId || scheduler.generateRootId();
+        const unregisterRoot = scheduler.registerRoot(newRootId, {
           getState: () => store.getState(),
           onError: (err) => store.getState().setError(err)
         });
-        const unregisterCanvasTarget = scheduler$1.register(
+        const unregisterCanvasTarget = scheduler.register(
           () => {
             const state2 = store.getState();
             if (state2.internal.isMultiCanvas && state2.internal.canvasTarget) {
@@ -14461,7 +15498,7 @@ function createRoot(canvas) {
             system: true
           }
         );
-        const unregisterEventsFlush = scheduler$1.register(
+        const unregisterEventsFlush = scheduler.register(
           () => {
             const state2 = store.getState();
             state2.events.flush?.();
@@ -14473,7 +15510,7 @@ function createRoot(canvas) {
             system: true
           }
         );
-        const unregisterFrustum = scheduler$1.register(
+        const unregisterFrustum = scheduler.register(
           () => {
             const state2 = store.getState();
             if (state2.autoUpdateFrustum && state2.camera) {
@@ -14487,7 +15524,7 @@ function createRoot(canvas) {
             system: true
           }
         );
-        const unregisterVisibility = scheduler$1.register(
+        const unregisterVisibility = scheduler.register(
           () => {
             const state2 = store.getState();
             checkVisibility(state2);
@@ -14500,11 +15537,11 @@ function createRoot(canvas) {
             after: `${newRootId}_frustum`
           }
         );
-        const unregisterRender = scheduler$1.register(
+        const unregisterRender = scheduler.register(
           () => {
             const state2 = store.getState();
             const renderer2 = state2.internal.actualRenderer;
-            const userHandlesRender = scheduler$1.hasUserJobsInPhase("render", newRootId);
+            const userHandlesRender = scheduler.hasUserJobsInPhase("render", newRootId);
             if (userHandlesRender || state2.internal.priority) return;
             try {
               if (state2.renderPipeline?.render) state2.renderPipeline.render();
@@ -14537,11 +15574,11 @@ function createRoot(canvas) {
               unregisterVisibility();
               unregisterRender();
             },
-            scheduler: scheduler$1
+            scheduler
           }
         }));
       }
-      scheduler$1.frameloop = frameloop;
+      scheduler.frameloop = frameloop;
       onCreated = onCreatedCallback;
       configured = true;
       resolve();
@@ -14998,8 +16035,6 @@ function Canvas(props) {
 
 extend(THREE);
 
-exports.Scheduler = scheduler.Scheduler;
-exports.getScheduler = scheduler.getScheduler;
 exports.Block = Block;
 exports.Canvas = Canvas;
 exports.Environment = Environment;
@@ -15015,6 +16050,7 @@ exports.R3F_BUILD_LEGACY = R3F_BUILD_LEGACY;
 exports.R3F_BUILD_WEBGPU = R3F_BUILD_WEBGPU;
 exports.REACT_INTERNAL_PROPS = REACT_INTERNAL_PROPS;
 exports.RESERVED_PROPS = RESERVED_PROPS;
+exports.Scheduler = Scheduler;
 exports.Texture = Texture;
 exports._roots = _roots;
 exports.act = act;
@@ -15044,6 +16080,7 @@ exports.getInstanceProps = getInstanceProps;
 exports.getPrimary = getPrimary;
 exports.getPrimaryIds = getPrimaryIds;
 exports.getRootState = getRootState;
+exports.getScheduler = getScheduler;
 exports.getUuidPrefix = getUuidPrefix;
 exports.hasConstructor = hasConstructor;
 exports.hasPrimary = hasPrimary;