@react-three/fiber 10.0.0-canary.9806389 → 10.0.0-canary.ac30da2

package/dist/index.d.cts

@@ -1,16 +1,18 @@
+import * as three_examples_jsm_inspector_Inspector_js from 'three/examples/jsm/inspector/Inspector.js';
 import * as three_webgpu from 'three/webgpu';
-import { RenderTarget, WebGPURenderer, Node, StorageTexture, Data3DTexture, CanvasTarget, ShaderNodeObject, Euler as Euler$2, Color as Color$2, ColorRepresentation as ColorRepresentation$1, Layers as Layers$1, Raycaster, Intersection as Intersection$1, BufferGeometry, Matrix4 as Matrix4$1, Quaternion as Quaternion$1, Vector2 as Vector2$1, Vector3 as Vector3$1, Vector4 as Vector4$1, Matrix3 as Matrix3$1, Loader as Loader$1, ColorSpace, Texture as Texture$1, CubeTexture, Scene, Object3D, Frustum, OrthographicCamera } from 'three/webgpu';
+import { CubeRenderTarget, RenderTarget, WebGPURenderer, Node, StorageTexture, Data3DTexture, CanvasTarget, ShaderNodeObject, Euler as Euler$2, Color as Color$2, ColorRepresentation as ColorRepresentation$1, Layers as Layers$1, Raycaster, Intersection as Intersection$1, BufferGeometry, Matrix4 as Matrix4$1, Quaternion as Quaternion$1, Vector2 as Vector2$1, Vector3 as Vector3$1, Vector4 as Vector4$1, Matrix3 as Matrix3$1, Loader as Loader$1, ColorSpace, Texture as Texture$1, CubeTexture, Scene, Object3D, Frustum, OrthographicCamera } from 'three/webgpu';
 import * as THREE$1 from 'three';
-import { WebGLRenderTarget, WebGLRenderer, Color as Color$1, ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1 } from 'three';
+import { WebGLCubeRenderTarget, WebGLRenderTarget, WebGLRenderer, Color as Color$1, ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1 } from 'three';
 import { WebGLRendererParameters } from 'three/src/renderers/WebGLRenderer.js';
 import { Inspector } from 'three/addons/inspector/Inspector.js';
 import * as React$1 from 'react';
 import { ReactNode, Component, RefObject, JSX } from 'react';
 import { StoreApi } from 'zustand';
 import { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
+import { FrameTimingState, FrameCallback as FrameCallback$1, SchedulerApi, UseFrameNextOptions, FrameNextControls } from '@pmndrs/scheduler';
+export { AddPhaseOptions, FrameControls, FrameNextControls, FrameTimingState, RootOptions, Scheduler, SchedulerApi, UseFrameNextOptions, UseFrameOptions, getScheduler } from '@pmndrs/scheduler';
 import { Options } from 'react-use-measure';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ThreeElement as ThreeElement$1, Euler as Euler$3 } from '@react-three/fiber';
 import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
 
 function _mergeNamespaces(n, m) {
@@ -46,15 +48,22 @@ function _mergeNamespaces(n, m) {
 declare const R3F_BUILD_LEGACY = true;
 declare const R3F_BUILD_WEBGPU = true;
 
+/** Lazily load the three Inspector. Keeps it out of the eager module graph — see note above. */
+declare function loadInspector(): Promise<typeof three_examples_jsm_inspector_Inspector_js.Inspector>;
+
 var THREE = /*#__PURE__*/_mergeNamespaces({
   __proto__: null,
+  CubeRenderTarget: CubeRenderTarget,
+  CubeRenderTargetCompat: CubeRenderTarget,
   Inspector: Inspector,
   R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
   R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
   RenderTargetCompat: RenderTarget,
+  WebGLCubeRenderTarget: WebGLCubeRenderTarget,
   WebGLRenderTarget: WebGLRenderTarget,
   WebGLRenderer: WebGLRenderer,
-  WebGLRendererParameters: WebGLRendererParameters
+  WebGLRendererParameters: WebGLRendererParameters,
+  loadInspector: loadInspector
 }, [three_webgpu]);
 
 //* Utility Types ==============================
@@ -292,228 +301,33 @@ interface VisibilityEntry {
 }
 
 //* Scheduler Types (useFrame) ==============================
+//
+// The generic, framework-agnostic scheduler types now live in @pmndrs/scheduler.
+// This file re-exports them and layers r3f's RootState-aware frame state on top,
+// so existing `#types` imports across the codebase keep resolving unchanged.
 
 
 
-// Public Options --------------------------------
+// Frame State (r3f-specific) --------------------------------
 
 /**
- * Options for useFrame hook
- */
-interface UseFrameNextOptions {
-  /** Optional stable id for the job. Auto-generated if not provided */
-  id?: string
-  /** Named phase to run in. Default: 'update' */
-  phase?: string
-  /** Run before this phase or job id */
-  before?: string | string[]
-  /** Run after this phase or job id */
-  after?: string | string[]
-  /** Priority within phase. Higher runs first. Default: 0 */
-  priority?: number
-  /** Max frames per second for this job */
-  fps?: number
-  /** If true, skip frames when behind. If false, try to catch up. Default: true */
-  drop?: boolean
-  /** Enable/disable without unregistering. Default: true */
-  enabled?: boolean
-}
-
-/** Alias for UseFrameNextOptions */
-type UseFrameOptions = UseFrameNextOptions
-
-/**
- * Options for addPhase
- */
-interface AddPhaseOptions {
-  /** Insert this phase before the specified phase */
-  before?: string
-  /** Insert this phase after the specified phase */
-  after?: string
-}
-
-// Frame State --------------------------------
-
-/**
- * Timing-only state for independent/outside mode (no RootState)
- */
-interface FrameTimingState {
-  /** High-resolution timestamp from RAF (ms) */
-  time: number
-  /** Time since last frame in seconds (for legacy compatibility with THREE.Clock) */
-  delta: number
-  /** Elapsed time since first frame in seconds (for legacy compatibility with THREE.Clock) */
-  elapsed: number
-  /** Incrementing frame counter */
-  frame: number
-}
-
-/**
- * State passed to useFrame callbacks (extends RootState with timing)
+ * State passed to useFrame callbacks (extends RootState with timing).
  */
 interface FrameNextState extends RootState, FrameTimingState {}
 
 /** Alias for FrameNextState */
 type FrameState = FrameNextState
 
-// Root Options --------------------------------
+// Callback Types (r3f-specific) --------------------------------
 
 /**
- * Options for registerRoot
+ * Callback function for useFrame. Receives the full r3f RootState plus timing.
  */
-interface RootOptions {
-  /** State provider for callbacks. Optional in independent mode. */
-  getState?: () => any
-  /** Error handler for job errors. Falls back to console.error if not provided. */
-  onError?: (error: Error) => void
-}
-
-// Callback Types --------------------------------
-
-/**
- * Callback function for useFrame
- */
-type FrameNextCallback = (state: FrameNextState, delta: number) => void
+type FrameNextCallback = FrameCallback$1<RootState>
 
 /** Alias for FrameNextCallback */
 type FrameCallback = FrameNextCallback
 
-// Controls returned from useFrame --------------------------------
-
-/**
- * Controls object returned from useFrame hook
- */
-interface FrameNextControls {
-  /** The job's unique ID */
-  id: string
-  /** Access to the global scheduler for frame loop control */
-  scheduler: SchedulerApi
-  /** Manually step this job only (bypasses FPS limiting) */
-  step(timestamp?: number): void
-  /** Manually step ALL jobs in the scheduler */
-  stepAll(timestamp?: number): void
-  /** Pause this job (set enabled=false) */
-  pause(): void
-  /** Resume this job (set enabled=true) */
-  resume(): void
-  /** Reactive paused state - automatically triggers re-render when changed */
-  isPaused: boolean
-}
-
-/** Alias for FrameNextControls */
-type FrameControls = FrameNextControls
-
-// Scheduler Interface --------------------------------
-
-/**
- * Public interface for the global Scheduler
- */
-interface SchedulerApi {
-  //* Phase Management --------------------------------
-
-  /** Add a named phase to the scheduler */
-  addPhase(name: string, options?: AddPhaseOptions): void
-  /** Get the ordered list of phase names */
-  readonly phases: string[]
-  /** Check if a phase exists */
-  hasPhase(name: string): boolean
-
-  //* Root Management --------------------------------
-
-  /** Register a root (Canvas) with the scheduler. Returns unsubscribe function. */
-  registerRoot(id: string, options?: RootOptions): () => void
-  /** Unregister a root */
-  unregisterRoot(id: string): void
-  /** Generate a unique root ID */
-  generateRootId(): string
-  /** Get the number of registered roots */
-  getRootCount(): number
-  /** Check if any root is registered and ready */
-  readonly isReady: boolean
-  /** Subscribe to root-ready event. Fires immediately if already ready. Returns unsubscribe. */
-  onRootReady(callback: () => void): () => void
-
-  //* Job Registration --------------------------------
-
-  /** Register a job with the scheduler (returns unsubscribe function) */
-  register(
-    callback: FrameNextCallback,
-    options?: {
-      id?: string
-      rootId?: string
-      phase?: string
-      before?: string | string[]
-      after?: string | string[]
-      priority?: number
-      fps?: number
-      drop?: boolean
-      enabled?: boolean
-    },
-  ): () => void
-  /** Update a job's options */
-  updateJob(
-    id: string,
-    options: {
-      priority?: number
-      fps?: number
-      drop?: boolean
-      enabled?: boolean
-      phase?: string
-      before?: string | string[]
-      after?: string | string[]
-    },
-  ): void
-  /** Unregister a job by ID */
-  unregister(id: string, rootId?: string): void
-  /** Get the number of registered jobs */
-  getJobCount(): number
-  /** Get all job IDs */
-  getJobIds(): string[]
-
-  //* Global Jobs (for legacy addEffect/addAfterEffect) --------------------------------
-
-  /** Register a global job (runs once per frame, not per-root). Returns unsubscribe function. */
-  registerGlobal(phase: 'before' | 'after', id: string, callback: (timestamp: number) => void): () => void
-
-  //* Idle Callbacks (for legacy addTail) --------------------------------
-
-  /** Register an idle callback (fires when loop stops). Returns unsubscribe function. */
-  onIdle(callback: (timestamp: number) => void): () => void
-
-  //* Frame Loop Control --------------------------------
-
-  /** Start the scheduler loop */
-  start(): void
-  /** Stop the scheduler loop */
-  stop(): void
-  /** Check if the scheduler is running */
-  readonly isRunning: boolean
-  /** Get/set the frameloop mode ('always', 'demand', 'never') */
-  frameloop: Frameloop
-  /** Independent mode - runs without Canvas, callbacks receive timing-only state */
-  independent: boolean
-
-  //* Manual Stepping --------------------------------
-
-  /** Manually step all jobs once (for frameloop='never' or testing) */
-  step(timestamp?: number): void
-  /** Manually step a single job by ID */
-  stepJob(id: string, timestamp?: number): void
-  /** Request frame(s) to be rendered (for frameloop='demand') */
-  invalidate(frames?: number): void
-
-  //* Per-Job Control --------------------------------
-
-  /** Check if a job is paused */
-  isJobPaused(id: string): boolean
-  /** Pause a job */
-  pauseJob(id: string): void
-  /** Resume a job */
-  resumeJob(id: string): void
-  /** Subscribe to job state changes (for reactive isPaused). Returns unsubscribe function. */
-  subscribeJobState(id: string, listener: () => void): () => void
-}
-
 //* Buffer Types (useBuffers) ========================================
 
 /**
@@ -687,9 +501,21 @@ interface InternalState {
    * @see https://threejs.org/docs/#api/en/renderers/common/CanvasTarget
    */
   canvasTarget?: CanvasTarget
+  /**
+   * Set when this root's canvas target has been resized and the backend's cached render pass
+   * descriptor (which holds a depth-stencil view built once per canvas) is therefore stale.
+   *
+   * Flushed by the canvas-target job in the `start` phase, which is the only place this root's
+   * target is guaranteed to be the renderer's active one — `backend.updateSize()` operates on
+   * whatever `getCanvasTarget()` returns, so calling it from the resize subscription would
+   * invalidate some other canvas's descriptor instead.
+   *
+   * @see https://github.com/pmndrs/react-three-fiber/issues/3847
+   */
+  canvasTargetSizeDirty?: boolean
   /**
    * Whether multi-canvas rendering is active.
-   * True when any canvas uses `target` prop to share a renderer.
+   * True when any canvas uses `renderer={{ primaryCanvas: 'id' }}` to share a renderer.
    * When true, setCanvasTarget is called before each render.
    */
   isMultiCanvas?: boolean
@@ -787,8 +613,8 @@ interface RootState {
   setSize: (width?: number, height?: number, top?: number, left?: number) => void
   /** Shortcut to manual setting the pixel ratio */
   setDpr: (dpr: Dpr) => void
-  /** Shortcut to setting frameloop flags */
-  setFrameloop: (frameloop: Frameloop) => void
+  /** Shortcut to setting frameloop flags. No args resets to 'always'. */
+  setFrameloop: (frameloop?: Frameloop) => void
   /** Set error state to propagate to error boundary */
   setError: (error: Error | null) => void
   /** Current error state (null when no error) */
@@ -806,7 +632,7 @@ interface RootState {
   /** Internal: refcount per texture key, driven by mounted useTexture consumers (registry enrollment is on by default) */
   _textureRefs: Map<string, number>
   /** WebGPU RenderPipeline instance - use useRenderPipeline() hook */
-  renderPipeline: any | null // THREE.PostProcessing (will be THREE.RenderPipeline in future Three.js release)
+  renderPipeline: ThreeRenderPipeline | null
   /** Global TSL pass nodes for render pipeline - use useRenderPipeline() hook */
   passes: Record<string, any>
   /** Internal version counter for HMR - incremented by rebuildNodes/rebuildUniforms to bust memoization */
@@ -1099,8 +925,6 @@ interface Instance<O = any> {
   attach?: AttachType<O>
   previousAttach?: any
   isHidden: boolean
-  /** Deferred ref props to apply in commitMount */
-  deferredRefs?: Array<{ prop: string; ref: React$1.RefObject<any> }>
   /** Set of props that have been applied via once() */
   appliedOnce?: Set<string>
 }
@@ -1337,10 +1161,21 @@ type RenderTargetOptions = RenderTargetOptions$1
 //* Global Types ==============================
 
 declare global {
-  /** Uniform node type - a Node with a value property (matches Three.js UniformNode) */
-  interface UniformNode<T = unknown> extends Node {
-    value: T
-  }
+  /**
+   * Uniform node type.
+   *
+   * This is three's own `UniformNode`, not a re-declaration of it. It previously was a
+   * hand-rolled `interface UniformNode<T> extends Node { value: T }`, which shadowed the real
+   * exported type globally — so R3F's ~58 references resolved to an approximation that was
+   * missing members three actually ships (`setName` among them) and had drifted to the wrong
+   * arity when three made `UniformNode` two-parameter.
+   *
+   * three's signature is `UniformNode<TNodeType, TValue>`. R3F only ever varies the value type,
+   * so the node type is fixed to `unknown` and the single parameter is kept for call-site
+   * ergonomics. The result is three's structural type, so members stay in sync with the
+   * installed three instead of needing to be mirrored by hand.
+   */
+  type UniformNode<T = unknown> = three_webgpu.UniformNode<unknown, T>
 
   /**
    * ShaderCallable - the return type of Fn()
@@ -1485,13 +1320,14 @@ declare module 'three/tsl' {
   ): ShaderCallable<R>
 }
 
-/**
- * RenderPipeline Types for useRenderPipeline hook (WebGPU only)
- */
-
-
-
 declare global {
+  /**
+   * three's own render pipeline type. Named here so the rest of R3F refers to three's shape
+   * rather than `any`. three r183 renamed `PostProcessing` to `RenderPipeline`; our peer floor
+   * is r185, so the new name is the only one.
+   */
+  type ThreeRenderPipeline = three_webgpu.RenderPipeline
+
   /** Pass record - stores TSL pass nodes for render pipeline */
   type PassRecord = Record<string, any>
 
@@ -1506,7 +1342,7 @@ declare global {
     /** Current passes from state */
     passes: PassRecord
     /** RenderPipeline instance (null if not initialized) */
-    renderPipeline: any | null // THREE.PostProcessing (will be THREE.RenderPipeline in future Three.js release)
+    renderPipeline: ThreeRenderPipeline | null
     /** Clear all passes from state */
     clearPasses: () => void
     /** Reset RenderPipeline entirely (clears PP + passes) */
@@ -1518,146 +1354,6 @@ declare global {
   }
 }
 
-//* useFrameNext Types ==============================
-
-
-
-//* Global Type Declarations ==============================
-
-declare global {
-  // Job --------------------------------
-
-  /**
-   * Internal job representation in the scheduler
-   */
-  interface Job {
-    /** Unique identifier */
-    id: string
-    /** The callback to execute */
-    callback: FrameNextCallback
-    /** Phase this job belongs to */
-    phase: string
-    /** Run before these phases/job ids */
-    before: Set<string>
-    /** Run after these phases/job ids */
-    after: Set<string>
-    /** Priority within phase (higher first) */
-    priority: number
-    /** Insertion order for deterministic tie-breaking */
-    index: number
-    /** Max FPS for this job (undefined = no limit) */
-    fps?: number
-    /** Drop frames when behind (true) or catch up (false) */
-    drop: boolean
-    /** Last run timestamp (ms) */
-    lastRun?: number
-    /** Whether job is enabled */
-    enabled: boolean
-    /** Internal flag: system jobs (like default render) don't block user render takeover */
-    system?: boolean
-  }
-
-  // Phase Graph --------------------------------
-
-  /**
-   * A node in the phase graph
-   */
-  interface PhaseNode {
-    /** Phase name */
-    name: string
-    /** Whether this was auto-generated from a before/after constraint */
-    isAutoGenerated: boolean
-  }
-
-  /**
-   * Options for creating a job from hook options
-   */
-  interface JobOptions {
-    id?: string
-    phase?: string
-    before?: string | string[]
-    after?: string | string[]
-    priority?: number
-    fps?: number
-    drop?: boolean
-    enabled?: boolean
-  }
-
-  // Frame Loop State --------------------------------
-
-  /**
-   * Internal frame loop state
-   */
-  interface FrameLoopState {
-    /** Whether the loop is running */
-    running: boolean
-    /** Current RAF handle */
-    rafHandle: number | null
-    /** Last frame timestamp in ms (null = uninitialized) */
-    lastTime: number | null
-    /** Frame counter */
-    frameCount: number
-    /** Elapsed time since first frame in ms */
-    elapsedTime: number
-    /** createdAt timestamp in ms */
-    createdAt: number
-  }
-
-  // Root Entry --------------------------------
-
-  /**
-   * Internal representation of a registered root (Canvas).
-   * Tracks jobs and manages rebuild state for this root.
-   * @internal
-   */
-  interface RootEntry {
-    /** Unique identifier for this root */
-    id: string
-    /** Function to get the root's current state. Returns any to support independent mode. */
-    getState: () => any
-    /** Map of job IDs to Job objects */
-    jobs: Map<string, Job>
-    /** Cached sorted job list for execution order */
-    sortedJobs: Job[]
-    /** Whether sortedJobs needs rebuilding */
-    needsRebuild: boolean
-  }
-
-  /**
-   * Internal representation of a global job (deprecated API).
-   * Global jobs run once per frame, not per-root.
-   * Used by legacy addEffect/addAfterEffect APIs.
-   * @internal
-   * @deprecated Use useFrame with phases instead
-   */
-  interface GlobalJob {
-    /** Unique identifier for this global job */
-    id: string
-    /** Callback invoked with RAF timestamp in ms */
-    callback: (timestamp: number) => void
-  }
-
-  // HMR Support --------------------------------
-
-  /**
-   * Hot Module Replacement data structure for preserving scheduler state
-   * @internal
-   */
-  interface HMRData {
-    /** Shared data object for storing values across reloads */
-    data: Record<string, any>
-    /** Optional function to accept HMR updates */
-    accept?: () => void
-  }
-
-  // Default Phases --------------------------------
-
-  /**
-   * Default phase names for the scheduler
-   */
-  type DefaultPhase = 'start' | 'input' | 'physics' | 'update' | 'render' | 'finish'
-}
-
 type MutableOrReadonlyParameters<T extends (...args: any) => any> = Parameters<T> | Readonly<Parameters<T>>
 
 interface MathRepresentation {
@@ -1827,7 +1523,7 @@ declare namespace three_d {
  * a single WebGPURenderer using Three.js CanvasTarget API.
  *
  * Primary canvas: Has `id` prop, creates its own renderer, registers here
- * Secondary canvas: Has `target="id"` prop, shares primary's renderer via CanvasTarget
+ * Secondary canvas: Has `renderer={{ primaryCanvas: 'id' }}`, shares primary's renderer via CanvasTarget
  */
 
 interface PrimaryCanvasEntry {
@@ -1895,12 +1591,23 @@ type EnvironmentLoaderProps = {
  * const texture = useEnvironment({ preset: 'sunset' })
  * ```
  */
-declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<unknown> | CubeTexture;
+declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<unknown, THREE$1.TextureEventMap> | CubeTexture<unknown>;
 declare namespace useEnvironment {
     var preload: (preloadOptions?: EnvironmentLoaderPreloadOptions) => void;
     var clear: (clearOptions?: EnvironmentLoaderClearOptions) => void;
 }
-type EnvironmentLoaderPreloadOptions = Omit<EnvironmentLoaderProps, 'encoding'>;
+/**
+ * Options accepted by `useEnvironment.preload`.
+ *
+ * `colorSpace` is deliberately omitted: preload only warms the loader cache, and colorSpace is
+ * applied to the texture by `useEnvironment()` at use time, per consumer. Accepting it here would
+ * advertise an option this function silently ignores.
+ *
+ * This previously read `Omit<…, 'encoding'>` — omitting a key that does not exist on
+ * `EnvironmentLoaderProps`, a leftover from three's pre-`colorSpace` `encoding` API. That made the
+ * type equivalent to the full props, so `colorSpace` was accepted and then dropped on the floor.
+ */
+type EnvironmentLoaderPreloadOptions = Omit<EnvironmentLoaderProps, 'colorSpace'>;
 type EnvironmentLoaderClearOptions = Pick<EnvironmentLoaderProps, 'files' | 'preset'>;
 
 /**
@@ -1944,9 +1651,9 @@ type EnvironmentProps = {
     blur?: number;
     backgroundBlurriness?: number;
     backgroundIntensity?: number;
-    backgroundRotation?: Euler$3;
+    backgroundRotation?: Euler;
     environmentIntensity?: number;
-    environmentRotation?: Euler$3;
+    environmentRotation?: Euler;
     map?: Texture$1;
     preset?: PresetsType;
     scene?: Scene | React$1.RefObject<Scene>;
@@ -2030,7 +1737,7 @@ declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness
 declare function EnvironmentPortal({ children, near, far, resolution, frames, map, background, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, scene, files, path, preset, extensions, }: EnvironmentProps): react_jsx_runtime.JSX.Element;
 declare module '@react-three/fiber' {
     interface ThreeElements {
-        groundProjectedEnvImpl: ThreeElement$1<typeof GroundedSkybox>;
+        groundProjectedEnvImpl: ThreeElement<typeof GroundedSkybox>;
     }
 }
 /**
@@ -2130,6 +1837,24 @@ declare module '@react-three/fiber' {
  */
 declare function Environment(props: EnvironmentProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Moves every trace of interactivity from one object to its replacement, for reconstruction.
+ *
+ * When `args` or a `primitive`'s `object` changes, R3F builds a new three object and keeps the same
+ * instance. Removing the old object from the interaction state and registering the new one from
+ * scratch makes events *work* again (#3778), but it forgets what was in flight: a pointer resting on
+ * the object fires a second `onPointerEnter` without ever having left, and an active pointer capture
+ * is dropped mid-drag. Rewriting the references instead keeps the interaction continuous across a
+ * swap the user never asked to see (#3744).
+ *
+ * Captures are re-keyed rather than released, so the DOM-level capture on `captureData.target` is
+ * left alone — releasing and re-acquiring it is precisely the glitch being avoided.
+ *
+ * Visibility handlers are deliberately not transferred: that registry is keyed by `object.uuid`, so
+ * the replacement re-registers itself through `applyProps`. The old entry is dropped here so it
+ * cannot outlive the object it described.
+ */
+declare function swapInteractivity(store: RootStore, object: Object3D, newObject: Object3D): void;
 declare function removeInteractivity(store: RootStore, object: Object3D): void;
 declare function createEvents(store: RootStore): {
     handlePointer: (name: string) => (event: DomEvent) => void;
@@ -2150,383 +1875,21 @@ declare function getLoader<L extends LoaderLike | ConstructorRepresentation<Load
  * Note: this hook's caller must be wrapped with `React.Suspense`
  * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useloader
  */
-declare function useLoader<I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void): I extends any[] ? LoaderResult<L>[] : LoaderResult<L>;
+declare function useLoader<I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void, cacheKey?: InputLike): I extends any[] ? LoaderResult<L>[] : LoaderResult<L>;
 declare namespace useLoader {
-    var preload: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void) => void;
-    var clear: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I) => void;
+    var preload: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void, cacheKey?: InputLike) => void;
+    var clear: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, cacheKey?: InputLike) => void;
     var loader: typeof getLoader;
 }
 
-/**
- * Global Singleton Scheduler - manages the frame loop and job execution for ALL R3F roots.
- *
- * Features:
- * - Single RAF loop for entire application
- * - Root registration (multiple Canvas support)
- * - Global phases for addEffect/addAfterEffect (deprecated)
- * - Per-root job management with phases, priorities, FPS throttling
- * - onIdle callbacks for addTail (deprecated)
- * - Demand mode support via invalidate()
- */
-declare class Scheduler {
-    private static readonly INSTANCE_KEY;
-    private static get instance();
-    private static set instance(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(): Scheduler;
-    /**
-     * 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(): void;
-    private roots;
-    private phaseGraph;
-    private loopState;
-    private stoppedTime;
-    private nextRootIndex;
-    private globalBeforeJobs;
-    private globalAfterJobs;
-    private nextGlobalIndex;
-    private idleCallbacks;
-    private nextJobIndex;
-    private jobStateListeners;
-    private pendingFrames;
-    private _frameloop;
-    private _independent;
-    private errorHandler;
-    private rootReadyCallbacks;
-    get phases(): string[];
-    get frameloop(): Frameloop;
-    set frameloop(mode: Frameloop);
-    get isRunning(): boolean;
-    get isReady(): boolean;
-    get independent(): boolean;
-    set independent(value: boolean);
-    constructor();
-    /**
-     * 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: string, options?: RootOptions): () => void;
-    /**
-     * 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: string): void;
-    /**
-     * 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: () => void): () => void;
-    /**
-     * Notify all registered root-ready callbacks.
-     * Called when the first root registers.
-     * @returns {void}
-     * @private
-     */
-    private notifyRootReady;
-    /**
-     * Ensure a default root exists for independent mode.
-     * Creates a minimal root with no state provider.
-     * @returns {void}
-     * @private
-     */
-    private ensureDefaultRoot;
-    /**
-     * 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: Error): void;
-    /**
-     * 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: string, options?: AddPhaseOptions): void;
-    /**
-     * 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: string): boolean;
-    /**
-     * 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: 'before' | 'after', id: string, callback: (timestamp: number) => void): () => void;
-    /**
-     * 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: (timestamp: number) => void): () => void;
-    /**
-     * 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
-     */
-    private notifyIdle;
-    /**
-     * 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: FrameNextCallback, options?: JobOptions & {
-        rootId?: string;
-        system?: boolean;
-    }): () => void;
-    /**
-     * 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: string, rootId?: string): void;
-    /**
-     * 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: string, options: Partial<JobOptions>): void;
-    /**
-     * 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: string): boolean;
-    /**
-     * 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: string, listener: () => void): () => void;
-    /**
-     * Notify all listeners that a job's state has changed.
-     * @param {string} id - The job ID that changed
-     * @returns {void}
-     * @private
-     */
-    private notifyJobStateChange;
-    /**
-     * 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: string): void;
-    /**
-     * 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: string): void;
-    /**
-     * Start the requestAnimationFrame loop.
-     * Resets timing state (elapsedTime, frameCount) on start.
-     * No-op if already running.
-     * @returns {void}
-     */
-    start(): void;
-    /**
-     * Stop the requestAnimationFrame loop.
-     * Cancels any pending RAF callback.
-     * No-op if not running.
-     * @returns {void}
-     */
-    stop(): void;
-    /**
-     * 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?: number, stackFrames?: boolean): void;
-    /**
-     * Reset timing state for deterministic testing.
-     * Preserves jobs and roots but resets lastTime, frameCount, elapsedTime, etc.
-     * @returns {void}
-     */
-    resetTiming(): void;
-    /**
-     * 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?: number): void;
-    /**
-     * 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: string, timestamp?: number): void;
-    /**
-     * Main RAF loop callback.
-     * Executes frame, handles demand mode, and schedules next frame.
-     * @param {number} timestamp - RAF timestamp in milliseconds
-     * @returns {void}
-     * @private
-     */
-    private loop;
-    /**
-     * Execute a single frame across all roots.
-     * Order: globalBefore → each root's jobs → globalAfter
-     * @param {number} timestamp - RAF timestamp in milliseconds
-     * @returns {void}
-     * @private
-     */
-    private executeFrame;
-    /**
-     * 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
-     */
-    private runGlobalJobs;
-    /**
-     * 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
-     */
-    private tickRoot;
-    /**
-     * 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(): number;
-    /**
-     * 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(): string[];
-    /**
-     * Get the number of registered roots (Canvas instances).
-     * @returns {number} Number of registered roots
-     */
-    getRootCount(): number;
-    /**
-     * 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: string, rootId?: string): boolean;
-    /**
-     * Generate a unique root ID for automatic root registration.
-     * @returns {string} A unique root ID in the format 'root_N'
-     */
-    generateRootId(): string;
-    /**
-     * Generate a unique job ID.
-     * @returns {string} A unique job ID in the format 'job_N'
-     * @private
-     */
-    private generateJobId;
-    /**
-     * 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
-     */
-    private normalizeConstraints;
-}
-/**
- * Get the global scheduler instance.
- * Creates one if it doesn't exist.
- */
-declare const getScheduler: () => Scheduler;
-
 /**
  * Frame hook with phase-based ordering, priority, and FPS throttling.
  *
- * Works both inside and outside Canvas context:
- * - Inside Canvas: Full RootState (gl, scene, camera, etc.)
- * - Outside Canvas (waiting mode): Waits for Canvas to mount, then gets full state
- * - Outside Canvas (independent mode): Fires immediately with timing-only state
+ * Always delivers full RootState — works both inside and outside Canvas context:
+ * - Inside Canvas: Full RootState (renderer, scene, camera, etc.)
+ * - Outside Canvas: The job registers immediately but the callback is held until a
+ *   Canvas adopts it, then runs with full RootState. For hostless / standalone
+ *   frame loops with no Canvas, use `@pmndrs/scheduler` directly.
  *
  * Returns a controls object for manual stepping, pausing, and resuming.
  *
@@ -2543,16 +1906,16 @@ declare const getScheduler: () => Scheduler;
  * useFrame((state, delta) => { ... }, { phase: 'physics' })
  *
  * @example
- * // Outside Canvas - waits for Canvas to mount
+ * // Outside Canvas - callback waits for a Canvas, then always has full state
  * function UI() {
  *   useFrame((state, delta) => { syncUI(state.camera) });
  *   return <button>...</button>;
  * }
  *
  * @example
- * // Independent mode - no Canvas needed
- * getScheduler().independent = true;
- * useFrame((state, delta) => { updateGame(delta) });
+ * // Hostless / standalone loop (no Canvas) - use @pmndrs/scheduler directly
+ * import { getScheduler } from '@pmndrs/scheduler'
+ * getScheduler().register((state, delta) => { updateGame(delta) })
  *
  * @example
  * // Scheduler-only access (no callback)
@@ -3917,11 +3280,6 @@ declare function flushSync<R>(fn: () => R): R;
 declare const context: React$1.Context<RootStore>;
 declare const createStore: (invalidate: (state?: RootState, frames?: number, stackFrames?: boolean) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame) => void) => RootStore;
 
-/**
- * Safely flush async effects when testing, simulating a legacy root.
- * @deprecated Import from React instead. import { act } from 'react'
- */
-declare const act: typeof React$1.act;
 /**
  * An SSR-friendly useLayoutEffect.
  *
@@ -4405,5 +3763,5 @@ declare function isOnce(value: unknown): value is {
  */
 declare function Canvas(props: CanvasProps): react_jsx_runtime.JSX.Element;
 
-export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Scheduler, Texture, _roots, act, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getScheduler, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
-export type { Act, AddPhaseOptions, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, Bridge, BufferLike, BufferRecord, BufferStore, Camera, CameraProps, CanvasProps, CanvasSchedulerConfig, Catalogue, Color, ColorManagementConfig, ComputeFunction, ConstructorRepresentation, DefaultGLProps, DefaultRendererProps, Disposable, DisposeOptions, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameControls, FrameNextCallback, FrameNextControls, FrameNextState, FrameState, FrameTimingState, Frameloop, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeProps, NonFunctionKeys, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootOptions, RootState, RootStore, SchedulerApi, SetBlock, Size, StorageLike, StorageRecord, StorageStore, Subscription, TSLNodeInput, TextureInput, TextureResult, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UseFrameNextOptions, UseFrameOptions, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, XRManager, XRPointerConfig };
+export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, swapInteractivity, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
+export type { Act, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, Bridge, BufferLike, BufferRecord, BufferStore, Camera, CameraProps, CanvasProps, CanvasSchedulerConfig, Catalogue, Color, ColorManagementConfig, ComputeFunction, ConstructorRepresentation, DefaultGLProps, DefaultRendererProps, Disposable, DisposeOptions, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameNextCallback, FrameNextState, FrameState, Frameloop, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeProps, NonFunctionKeys, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootState, RootStore, SetBlock, Size, StorageLike, StorageRecord, StorageStore, Subscription, TSLNodeInput, TextureInput, TextureResult, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, XRManager, XRPointerConfig };