@react-three/fiber 10.0.0-canary.b0fafc8 → 10.0.0-canary.b86abaa

package/dist/webgpu/index.d.mts

@@ -1,4474 +1,105 @@
-import * as three_webgpu from 'three/webgpu';
-import { RenderTarget, WebGPURenderer, CanvasTarget, Node, 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, WebGPURendererParameters } from 'three/webgpu';
-import { Inspector } from 'three/addons/inspector/Inspector.js';
-import * as THREE$1 from 'three';
-import { Color as Color$1, ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1 } from 'three';
-import * as React$1 from 'react';
-import { ReactNode, Component, RefObject, JSX } from 'react';
+import * as ThreeWebGPU from 'three/webgpu';
+import { WebGPURenderer, WebGPURendererParameters, RenderTarget } from 'three/webgpu';
+import { M as MutableOrReadonlyParameters$1, a as MathRepresentation$1, V as VectorRepresentation$1, b as MathTypes$1, c as MathType$1, d as MathProps$1, e as Vector2$1, f as Vector3$1, g as Vector4$1, C as Color$1, L as Layers$1, Q as Quaternion$1, E as Euler$1, h as Matrix3$1, i as Matrix4$1, R as RaycastableRepresentation$1, j as EventProps$1, G as GeometryTransformProps$1, k as GeometryProps$1, T as TSLNodeInput$1, N as NodeProps$1, l as ReactProps$1, m as ElementProps$1, n as ThreeElement$1, o as ThreeToJSXElements$1, O as Object3DMethod$1, p as ThreeElementsOf$1, q as ElementOf$1, z as RendererFactory, B as BaseRendererProps, t as CanvasProps, s as ReconcilerRoot, r as RenderTargetOptions } from '../shared/fiber.Cu2hX1IM.mjs';
+export { Z as BackgroundConfig, _ as BackgroundProp, aZ as Block, S as CameraProps, J as CanvasSchedulerConfig, D as ColorManagementConfig, F as DefaultGLProps, I as DefaultRendererProps, aD as DisposeOptions, an as Environment, al as EnvironmentCube, aG as EnvironmentLoaderProps, ak as EnvironmentMap, am as EnvironmentPortal, aj as EnvironmentProps, a_ as ErrorBoundary, a5 as Extensions, bs as FROM_REF, bt as FromRefMarker, H as GLProps, a1 as GLTFLike, Y as GlobalEffectType, X as GlobalRenderCallback, a3 as InferLoadResult, W as InjectState, $ as InputLike, aw as IsObject, aa as LegacyInternalState, a9 as LegacyRenderer, ab as LegacyRootState, a2 as LoaderInstance, a0 as LoaderLike, a4 as LoaderResult, ax as MappedTextureType, bw as ONCE, y as OffscreenCanvas, by as OnceValue, aT as Portal, ap as PresetsType, ac as PrimaryCanvasEntry, a$ as REACT_INTERNAL_PROPS, b7 as RESERVED_PROPS, U as RenderProps, A as Renderer, K as RendererConfigExtended, P as RendererProps, aA as Texture, aB as TextureInput, aC as TextureResult, ay as UseTextureOptions, aE as UseTexturesReturn, a6 as WebGLDefaultProps, a7 as WebGLProps, a8 as WebGLShadowConfig, aQ as _roots, aJ as addAfterEffect, aI as addEffect, aK as addTail, aM as advance, bc as applyProps, b9 as attach, b2 as buildGraph, bd as calculateDpr, as as createEvents, u as createPointerEvents, aS as createPortal, aV as createStore, ba as detach, bb as diffProps, b3 as dispose, u as events, aN as extend, b0 as findInitialRoot, aU as flushSync, bu as fromRef, b4 as getInstanceProps, ae as getPrimary, ai as getPrimaryIds, b1 as getRootState, v as getThree, be as getUuidPrefix, br as hasConstructor, ag as hasPrimary, w as hasThree, aL as invalidate, b6 as invalidateInstance, bh as is, bk as isColorRepresentation, bq as isCopyable, bv as isFromRef, bn as isLayers, bl as isObject3D, bz as isOnce, bi as isOrthographicCamera, bj as isRef, aP as isRenderer, bm as isTexture, bo as isUniform, bp as isVectorLike, bx as once, b5 as prepare, ao as presetsObj, aO as reconciler, ad as registerPrimary, ar as removeInteractivity, b8 as resolve, aq as swapInteractivity, aR as unmountComponentAtNode, ah as unregisterPrimary, bf as updateCamera, bg as updateFrustum, aY as useBridge, aH as useEnvironment, au as useGraph, at as useInstanceHandle, aW as useIsomorphicLayoutEffect, av as useLoader, aX as useMutableCallback, az as useTexture, aF as useTextures, af as waitForPrimary, x as whenThree } from '../shared/fiber.Cu2hX1IM.mjs';
+import { C as ConstructorRepresentation, f as RootState, I as InternalState, J as Properties } from '../shared/fiber.I5Q4dVvl.mjs';
+export { U as Act, y as Args, z as ArgsProp, A as AttachFnType, w as AttachType, W as Bridge, i as Camera, x as Catalogue, n as ComputeFunction, a0 as Disposable, k as DomEvent, D as Dpr, $ as EquConfig, l as EventHandlers, p as EventManager, E as Events, u as FiberRoot, m as FilterFunction, ae as ForRegisteredRenderer, a4 as FrameCallback, a3 as FrameNextCallback, a1 as FrameNextState, a2 as FrameState, F as Frameloop, H as HostConfig, G as Instance, B as InstanceProps, h as Intersection, j as IntersectionEvent, L as IsAllOptional, K as IsOptional, M as Mutable, N as NonFunctionKeys, _ as ObjectMap, a7 as OcclusionSupport, O as Overwrite, e as Performance, q as PointerCaptureTarget, P as PointerState, R as R3FRenderTarget, af as R3FRendererSupport, ac as Register, ad as RegisteredRenderer, d as RenderCallback, ab as RendererProvider, aa as RendererSupport, v as Root, a as RootExtension, g as RootStore, Y as SetBlock, c as Size, S as Subscription, Q as ThreeCamera, a6 as ThreeCore, T as ThreeEvent, a5 as ThreeNamespace, Z as UnblockProps, V as Viewport, t as VisibilityEntry, a8 as WebGLSupport, a9 as WebGPUSupport, X as XRManager, o as XRPointerConfig, ai as context, r as registerRootExtension, s as setRenderOverride, ag as useStore } from '../shared/fiber.I5Q4dVvl.mjs';
+import { Texture } from 'three';
 import { StoreApi } from 'zustand';
-import { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
-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) {
-  m.forEach(function (e) {
-    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-      if (k !== 'default' && !(k in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  });
-  return Object.freeze(n);
-}
-
-/**
- * @fileoverview Internal Three.js re-exports - WEBGPU ONLY ENTRY
- *
- * Pure WebGPU path - no WebGL legacy.
- * Use this for the explicit webgpu import path: @react-three/fiber/webgpu
- *
- * This is for apps that want ONLY WebGPU with no legacy fallback.
- * Attempting to use WebGLRenderer will cause type/runtime errors (intentional).
- */
-declare const R3F_BUILD_LEGACY = false;
-declare const R3F_BUILD_WEBGPU = true;
-
-declare const WebGLRenderer: {
-    new (): {};
-};
-type WebGLRendererParameters = never;
-type WebGLShadowMap = never;
-
-declare const WebGLRenderTarget: any;
-
-var THREE = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  Inspector: Inspector,
-  R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
-  R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
-  RenderTargetCompat: RenderTarget,
-  WebGLRenderTarget: WebGLRenderTarget,
-  WebGLRenderer: WebGLRenderer,
-  WebGLRendererParameters: WebGLRendererParameters,
-  WebGLShadowMap: WebGLShadowMap
-}, [three_webgpu]);
-
-//* Utility Types ==============================
-
-type NonFunctionKeys<P> = { [K in keyof P]-?: P[K] extends Function ? never : K }[keyof P]
-type Overwrite<P, O> = Omit<P, NonFunctionKeys<O>> & O
-type Properties<T> = Pick<T, NonFunctionKeys<T>>
-type Mutable<P> = { -readonly [K in keyof P]: P[K] }
-type IsOptional<T> = undefined extends T ? true : false
-type IsAllOptional<T extends any[]> = T extends [infer First, ...infer Rest]
-  ? IsOptional<First> extends true
-    ? IsAllOptional<Rest>
-    : false
-  : true
-
-//* Camera Types ==============================
-
-type ThreeCamera = (THREE$1.OrthographicCamera | THREE$1.PerspectiveCamera) & { manual?: boolean }
-
-//* Act Type ==============================
-
-type Act = <T = any>(cb: () => Promise<T>) => Promise<T>
-
-//* Bridge & Block Types ==============================
-
-type Bridge = React$1.FC<{ children?: React$1.ReactNode }>
-
-type SetBlock = false | Promise<null> | null
-type UnblockProps = { set: React$1.Dispatch<React$1.SetStateAction<SetBlock>>; children: React$1.ReactNode }
-
-//* Object Map Type ==============================
-
-/* Original version
-export interface ObjectMap {
-  nodes: { [name: string]: THREE.Object3D }
-  materials: { [name: string]: THREE.Material }
-  meshes: { [name: string]: THREE.Mesh }
-}
-*/
-/* This version is an expansion found in a PR by itsdouges that seems abandoned but looks useful.
-It allows expansion but falls back to the original shape. (deleted due to stale, but If it doesnt conflict
-I will keep the use here)
-https://github.com/pmndrs/react-three-fiber/commits/generic-object-map/
-His description is:
-The object map type is now generic and can optionally declare the available properties for nodes, materials, and meshes.
-*/
-interface ObjectMap<
-  T extends { nodes?: string; materials?: string; meshes?: string } = {
-    nodes: string
-    materials: string
-    meshes: string
-  },
-> {
-  nodes: Record<T['nodes'] extends string ? T['nodes'] : string, THREE$1.Object3D>
-  materials: Record<T['materials'] extends string ? T['materials'] : string, THREE$1.Material>
-  meshes: Record<T['meshes'] extends string ? T['meshes'] : string, THREE$1.Mesh>
-}
-
-//* Equality Config ==============================
-
-interface EquConfig {
-  /** Compare arrays by reference equality a === b (default), or by shallow equality */
-  arrays?: 'reference' | 'shallow'
-  /** Compare objects by reference equality a === b (default), or by shallow equality */
-  objects?: 'reference' | 'shallow'
-  /** If true the keys in both a and b must match 1:1 (default), if false a's keys must intersect b's */
-  strict?: boolean
-}
-
-//* Disposable Type ==============================
-
-interface Disposable {
-  type?: string
-  dispose?: () => void
-}
-
-//* Event-related Types =====================================
-
-interface Intersection extends THREE$1.Intersection {
-  /** The event source (the object which registered the handler) */
-  eventObject: THREE$1.Object3D
-}
-
-type Camera = THREE$1.OrthographicCamera | THREE$1.PerspectiveCamera
-
-interface IntersectionEvent<TSourceEvent> extends Intersection {
-  /** The event source (the object which registered the handler) */
-  eventObject: THREE$1.Object3D
-  /** An array of intersections */
-  intersections: Intersection[]
-  /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
-  unprojectedPoint: THREE$1.Vector3
-  /** Normalized event coordinates */
-  pointer: THREE$1.Vector2
-  /** Delta between first click and this event */
-  delta: number
-  /** The ray that pierced it */
-  ray: THREE$1.Ray
-  /** The camera that was used by the raycaster */
-  camera: Camera
-  /** stopPropagation will stop underlying handlers from firing */
-  stopPropagation: () => void
-  /** The original host event */
-  nativeEvent: TSourceEvent
-  /** If the event was stopped by calling stopPropagation */
-  stopped: boolean
-}
-
-type ThreeEvent<TEvent> = IntersectionEvent<TEvent> & Properties<TEvent>
-type DomEvent = PointerEvent | MouseEvent | WheelEvent
-
-/** DOM event handlers registered on the canvas element */
-interface Events {
-  onClick: EventListener
-  onContextMenu: EventListener
-  onDoubleClick: EventListener
-  onWheel: EventListener
-  onPointerDown: EventListener
-  onPointerUp: EventListener
-  onPointerLeave: EventListener
-  onPointerMove: EventListener
-  onPointerCancel: EventListener
-  onLostPointerCapture: EventListener
-  onDragEnter: EventListener
-  onDragLeave: EventListener
-  onDragOver: EventListener
-  onDrop: EventListener
-}
-
-/** Event handlers that can be attached to R3F objects (meshes, groups, etc.) */
-interface EventHandlers {
-  onClick?: (event: ThreeEvent<MouseEvent>) => void
-  onContextMenu?: (event: ThreeEvent<MouseEvent>) => void
-  onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void
-  /** Fires continuously while dragging over the object */
-  onDragOver?: (event: ThreeEvent<DragEvent>) => void
-  /** Fires once when drag enters the object */
-  onDragOverEnter?: (event: ThreeEvent<DragEvent>) => void
-  /** Fires once when drag leaves the object */
-  onDragOverLeave?: (event: ThreeEvent<DragEvent>) => void
-  /** Fires when drag misses this object (for objects that have drag handlers) */
-  onDragOverMissed?: (event: DragEvent) => void
-  /** Fires when a drop occurs on this object */
-  onDrop?: (event: ThreeEvent<DragEvent>) => void
-  /** Fires when a drop misses this object (for objects that have drop handlers) */
-  onDropMissed?: (event: DragEvent) => void
-  onPointerUp?: (event: ThreeEvent<PointerEvent>) => void
-  onPointerDown?: (event: ThreeEvent<PointerEvent>) => void
-  onPointerOver?: (event: ThreeEvent<PointerEvent>) => void
-  onPointerOut?: (event: ThreeEvent<PointerEvent>) => void
-  onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void
-  onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void
-  onPointerMove?: (event: ThreeEvent<PointerEvent>) => void
-  onPointerMissed?: (event: MouseEvent) => void
-  onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void
-  onWheel?: (event: ThreeEvent<WheelEvent>) => void
-  onLostPointerCapture?: (event: ThreeEvent<PointerEvent>) => void
-
-  //* Visibility Events --------------------------------
-  /** Fires when object enters/exits camera frustum. Receives true when in view, false when out. */
-  onFramed?: (inView: boolean) => void
-  /** Fires when object occlusion state changes (WebGPU only, requires occlusionTest=true on object) */
-  onOccluded?: (occluded: boolean) => void
-  /** Fires when combined visibility changes (frustum + occlusion + visible prop) */
-  onVisible?: (visible: boolean) => void
-}
-
-type FilterFunction = (items: THREE$1.Intersection[], state: RootState) => THREE$1.Intersection[]
-type ComputeFunction = (event: DomEvent, root: RootState, previous?: RootState) => void
-
-interface EventManager<TTarget> {
-  /** Determines if the event layer is active */
-  enabled: boolean
-  /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
-  priority: number
-  /** The compute function needs to set up the raycaster and an xy- pointer  */
-  compute?: ComputeFunction
-  /** The filter can re-order or re-structure the intersections  */
-  filter?: FilterFunction
-  /** The target node the event layer is tied to */
-  connected?: TTarget
-  /** All the pointer event handlers through which the host forwards native events */
-  handlers?: Events
-  /** Allows re-connecting to another target */
-  connect?: (target: TTarget) => void
-  /** Removes all existing events handlers from the target */
-  disconnect?: () => void
-  /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
-   *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
-   */
-  update?: () => void
-}
-
-interface PointerCaptureTarget {
-  intersection: Intersection
-  target: Element
-}
-
-//* Visibility System Types =====================================
-
-/** Entry in the visibility registry for tracking object visibility state */
-interface VisibilityEntry {
-  object: THREE$1.Object3D
-  handlers: Pick<EventHandlers, 'onFramed' | 'onOccluded' | 'onVisible'>
-  lastFramedState: boolean | null
-  lastOccludedState: boolean | null
-  lastVisibleState: boolean | null
-}
-
-//* Scheduler Types (useFrame) ==============================
-
-
-
-// Public Options --------------------------------
-
-/**
- * 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)
- */
-interface FrameNextState extends RootState, FrameTimingState {}
-
-/** Alias for FrameNextState */
-type FrameState = FrameNextState
-
-// Root Options --------------------------------
-
-/**
- * Options for registerRoot
- */
-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
-
-/** 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
-}
-
-//* Renderer Types ========================================
-
-/** Default renderer type - union of WebGL and WebGPU renderers */
-type R3FRenderer = THREE$1.WebGLRenderer | WebGPURenderer
-
-//* Core Store Types ========================================
-
-type Subscription = {
-  ref: React$1.RefObject<RenderCallback>
-  priority: number
-  store: RootStore
-}
-
-type Dpr = number | [min: number, max: number]
-
-interface Size {
-  width: number
-  height: number
-  top: number
-  left: number
-}
-
-type Frameloop = 'always' | 'demand' | 'never'
-
-interface Viewport extends Size {
-  /** The initial pixel ratio */
-  initialDpr: number
-  /** Current pixel ratio */
-  dpr: number
-  /** size.width / viewport.width */
-  factor: number
-  /** Camera distance */
-  distance: number
-  /** Camera aspect ratio: width / height */
-  aspect: number
-}
-
-type RenderCallback = (state: RootState, delta: number, frame?: XRFrame) => void
-
-interface Performance {
-  /** Current performance normal, between min and max */
-  current: number
-  /** How low the performance can go, between 0 and max */
-  min: number
-  /** How high the performance can go, between min and max */
-  max: number
-  /** Time until current returns to max in ms */
-  debounce: number
-  /** Sets current to min, puts the system in regression */
-  regress: () => void
-}
-
-interface InternalState {
-  interaction: THREE$1.Object3D[]
-  hovered: Map<string, ThreeEvent<DomEvent>>
-  subscribers: Subscription[]
-  capturedMap: Map<number, Map<THREE$1.Object3D, PointerCaptureTarget>>
-  initialClick: [x: number, y: number]
-  initialHits: THREE$1.Object3D[]
-  lastEvent: React$1.RefObject<DomEvent | null>
-  /** Visibility event registry (onFramed, onOccluded, onVisible) */
-  visibilityRegistry: Map<string, VisibilityEntry>
-  /** Whether occlusion queries are enabled (WebGPU only) */
-  occlusionEnabled: boolean
-  /** Reference to the invisible occlusion observer mesh */
-  occlusionObserver: THREE$1.Mesh | null
-  /** Cached occlusion results from render pass - keyed by Object3D */
-  occlusionCache: Map<THREE$1.Object3D, boolean | null>
-  /** Internal helper group for R3F system objects (occlusion observer, etc.) */
-  helperGroup: THREE$1.Group | null
-  active: boolean
-  priority: number
-  frames: number
-  subscribe: (callback: React$1.RefObject<RenderCallback>, priority: number, store: RootStore) => () => void
-  /** Internal renderer storage - use state.renderer or state.gl to access */
-  actualRenderer: R3FRenderer
-  /** Global scheduler reference (for useFrame hook) */
-  scheduler: SchedulerApi | null
-  /** This root's unique ID in the global scheduler */
-  rootId?: string
-  /** Function to unregister this root from the global scheduler */
-  unregisterRoot?: () => void
-  /** Container for child attachment (scene for root, original container for portals) */
-  container?: THREE$1.Object3D
-  /**
-   * CanvasTarget for multi-canvas WebGPU rendering.
-   * Created for all WebGPU canvases to support renderer sharing.
-   * @see https://threejs.org/docs/#api/en/renderers/common/CanvasTarget
-   */
-  canvasTarget?: CanvasTarget
-  /**
-   * Whether multi-canvas rendering is active.
-   * True when any canvas uses `target` prop to share a renderer.
-   * When true, setCanvasTarget is called before each render.
-   */
-  isMultiCanvas?: boolean
-  /**
-   * Whether this canvas is a secondary canvas sharing another's renderer.
-   * True when `target` prop is used.
-   */
-  isSecondary?: boolean
-  /**
-   * The id of the primary canvas this secondary canvas targets.
-   * Only set when isSecondary is true.
-   */
-  targetId?: string
-  /**
-   * Function to unregister this primary canvas from the registry.
-   * Only set when this canvas has an `id` prop.
-   */
-  unregisterPrimary?: () => void
-  /** Whether canvas dimensions are forced to even numbers */
-  forceEven?: boolean
-}
-
-interface XRManager {
-  connect: () => void
-  disconnect: () => void
-}
-
-//* Root State Interface ====================================
-
-interface RootState {
-  /** Set current state */
-  set: StoreApi<RootState>['setState']
-  /** Get current state */
-  get: StoreApi<RootState>['getState']
-  /**
-   * Reference to the authoritative store for shared TSL resources (uniforms, nodes, etc).
-   * - For primary/independent canvases: points to its own store (self-reference)
-   * - For secondary canvases: points to the primary canvas's store
-   *
-   * Hooks like useNodes/useUniforms should read from primaryStore to ensure
-   * consistent shared state across all canvases sharing a renderer.
-   */
-  primaryStore: RootStore
-  /** @deprecated Use `renderer` instead. The instance of the renderer (typed as WebGLRenderer for backwards compat) */
-  gl: THREE$1.WebGLRenderer
-  /** The renderer instance - type depends on entry point (WebGPU, Legacy, or union for default) */
-  renderer: R3FRenderer
-  /** Inspector of the webGPU Renderer. Init in the canvas */
-  inspector: any // Inspector type from three/webgpu
-
-  /** Default camera */
-  camera: ThreeCamera
-  /** Camera frustum for visibility checks - auto-updated each frame when autoUpdateFrustum is true */
-  frustum: THREE$1.Frustum
-  /** Whether to automatically update the frustum each frame (default: true) */
-  autoUpdateFrustum: boolean
-  /** Default scene (may be overridden in portals to point to the portal container) */
-  scene: THREE$1.Scene
-  /** The actual root THREE.Scene - always points to the true scene, even inside portals */
-  rootScene: THREE$1.Scene
-  /** Default raycaster */
-  raycaster: THREE$1.Raycaster
-  /** Event layer interface, contains the event handler and the node they're connected to */
-  events: EventManager<any>
-  /** XR interface */
-  xr: XRManager
-  /** Currently used controls */
-  controls: THREE$1.EventDispatcher | null
-  /** Normalized event coordinates */
-  pointer: THREE$1.Vector2
-  /** @deprecated Normalized event coordinates, use "pointer" instead! */
-  mouse: THREE$1.Vector2
-  /** Color space assigned to 8-bit input textures (color maps). Most textures are authored in sRGB. */
-  textureColorSpace: THREE$1.ColorSpace
-  /** Render loop flags */
-  frameloop: Frameloop
-  performance: Performance
-  /** Reactive pixel-size of the canvas */
-  size: Size
-  /** Reactive size of the viewport in threejs units */
-  viewport: Viewport & {
-    getCurrentViewport: (
-      camera?: ThreeCamera,
-      target?: THREE$1.Vector3 | Parameters<THREE$1.Vector3['set']>,
-      size?: Size,
-    ) => Omit<Viewport, 'dpr' | 'initialDpr'>
-  }
-  /** Flags the canvas for render, but doesn't render in itself */
-  invalidate: (frames?: number, stackFrames?: boolean) => void
-  /** Advance (render) one step */
-  advance: (timestamp: number, runGlobalEffects?: boolean) => void
-  /** Shortcut to setting the event layer */
-  setEvents: (events: Partial<EventManager<any>>) => void
-  /** Shortcut to manual sizing. No args resets to props/container. Single arg creates square. */
-  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
-  /** Set error state to propagate to error boundary */
-  setError: (error: Error | null) => void
-  /** Current error state (null when no error) */
-  error: Error | null
-  /** Global TSL uniform nodes - root-level uniforms + scoped sub-objects. Use useUniforms() hook */
-  uniforms: UniformStore
-  /** Global TSL nodes - root-level nodes + scoped sub-objects. Use useNodes() hook */
-  nodes: Record<string, any>
-  /** Global TSL texture nodes - use useTextures() hook for operations */
-  textures: Map<string, any>
-  /** WebGPU PostProcessing instance - use usePostProcessing() hook */
-  postProcessing: any | null // THREE.PostProcessing when available
-  /** Global TSL pass nodes for post-processing - use usePostProcessing() hook */
-  passes: Record<string, any>
-  /** Internal version counter for HMR - incremented by rebuildNodes/rebuildUniforms to bust memoization */
-  _hmrVersion: number
-  /** Internal: whether setSize() has taken ownership of canvas dimensions */
-  _sizeImperative: boolean
-  /** Internal: stored size props from Canvas for reset functionality */
-  _sizeProps: { width?: number; height?: number } | null
-  /** When the canvas was clicked but nothing was hit */
-  onPointerMissed?: (event: MouseEvent) => void
-  /** When a dragover event has missed any target */
-  onDragOverMissed?: (event: DragEvent) => void
-  /** When a drop event has missed any target */
-  onDropMissed?: (event: DragEvent) => void
-  /** If this state model is layered (via createPortal) then this contains the previous layer */
-  previousRoot?: RootStore
-  /** Internals */
-  internal: InternalState
-  // flags for triggers
-  // if we are using the webGl renderer, this will be true
-  isLegacy: boolean
-  // regardless of renderer, if the system supports webGpu, this will be true
-  webGPUSupported: boolean
-  //if we are on native
-  isNative: boolean
-}
-
-type RootStore = UseBoundStoreWithEqualityFn<StoreApi<RootState>>
-
-//* Base Renderer Types =====================================
-
-// Shim for OffscreenCanvas since it was removed from DOM types
-interface OffscreenCanvas$1 extends EventTarget {}
-
-interface BaseRendererProps {
-  canvas: HTMLCanvasElement | OffscreenCanvas$1
-  powerPreference?: 'high-performance' | 'low-power' | 'default'
-  antialias?: boolean
-  alpha?: boolean
-}
-
-type RendererFactory<TRenderer, TParams> =
-  | TRenderer
-  | ((defaultProps: TParams) => TRenderer)
-  | ((defaultProps: TParams) => Promise<TRenderer>)
-
-interface Renderer {
-  render: (scene: THREE$1.Scene, camera: THREE$1.Camera) => any
-}
-
-//* WebGL Renderer Props ==============================
-
-type DefaultGLProps = Omit<THREE$1.WebGLRendererParameters, 'canvas'> & {
-  canvas: HTMLCanvasElement | OffscreenCanvas$1
-}
-
-type GLProps =
-  | Renderer
-  | ((defaultProps: DefaultGLProps) => Renderer)
-  | ((defaultProps: DefaultGLProps) => Promise<Renderer>)
-  | Partial<Properties<THREE$1.WebGLRenderer> | THREE$1.WebGLRendererParameters>
-
-//* WebGPU Renderer Props ==============================
-
-type DefaultRendererProps = {
-  canvas: HTMLCanvasElement | OffscreenCanvas$1
-  [key: string]: any
-}
-
-/**
- * Canvas-level scheduler configuration.
- * Controls render timing relative to other canvases.
- */
-interface CanvasSchedulerConfig {
-  /**
-   * Render this canvas after another canvas completes.
-   * Pass the `id` of another canvas.
-   */
-  after?: string
-  /**
-   * Limit this canvas's render rate (frames per second).
-   */
-  fps?: number
-}
-
-/**
- * Extended renderer configuration for multi-canvas support.
- */
-interface RendererConfigExtended {
-  /** Share renderer from another canvas (WebGPU only) */
-  primaryCanvas?: string
-  /** Canvas-level scheduler options */
-  scheduler?: CanvasSchedulerConfig
-}
-
-type RendererProps =
-  | any // WebGPURenderer
-  | ((defaultProps: DefaultRendererProps) => any)
-  | ((defaultProps: DefaultRendererProps) => Promise<any>)
-  | (Partial<Properties<any> | Record<string, any>> & RendererConfigExtended)
-
-//* Camera Props ==============================
-
-type CameraProps = (
-  | THREE$1.Camera
-  | Partial<
-      ThreeElement<typeof THREE$1.Camera> &
-        ThreeElement<typeof THREE$1.PerspectiveCamera> &
-        ThreeElement<typeof THREE$1.OrthographicCamera>
-    >
-) & {
-  /** Flags the camera as manual, putting projection into your own hands */
-  manual?: boolean
-}
-
-//* Render Props ==============================
-
-interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas$1> {
-  /**
-   * Unique identifier for multi-canvas renderer sharing.
-   * Makes this canvas targetable by other canvases using the `primaryCanvas` prop.
-   * Also sets the HTML `id` attribute on the canvas element.
-   * @example <Canvas id="main-viewer">...</Canvas>
-   */
-  id?: string
-  /**
-   * Share the renderer from another canvas instead of creating a new one.
-   * Pass the `id` of the primary canvas to share its WebGPURenderer.
-   * Only available with WebGPU (not legacy WebGL).
-   *
-   * Note: This is extracted from `renderer={{ primaryCanvas: "id" }}` by Canvas.
-   * @internal
-   */
-  primaryCanvas?: string
-  /**
-   * Canvas-level scheduler options. Controls render timing relative to other canvases.
-   *
-   * Note: This is extracted from `renderer={{ scheduler: {...} }}` by Canvas.
-   * @internal
-   */
-  scheduler?: CanvasSchedulerConfig
-  /** A threejs renderer instance or props that go into the default renderer */
-  gl?: GLProps
-  /** A WebGPU renderer instance or props that go into the default renderer */
-  renderer?: RendererProps
-  /** Dimensions to fit the renderer to. Will measure canvas dimensions if omitted */
-  size?: Size
-  /**
-   * Enables shadows (by default PCFsoft). Can accept `gl.shadowMap` options for fine-tuning,
-   * but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.
-   * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
-   */
-  shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE$1.WebGLShadowMap>
-  /** Color space assigned to 8-bit input textures (color maps). Defaults to sRGB. Most textures are authored in sRGB. */
-  textureColorSpace?: THREE$1.ColorSpace
-  /** Creates an orthographic camera */
-  orthographic?: boolean
-  /**
-   * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.
-   * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
-   */
-  frameloop?: Frameloop
-  /**
-   * R3F performance options for adaptive performance.
-   * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression
-   */
-  performance?: Partial<Omit<Performance, 'regress'>>
-  /** Target pixel ratio. Can clamp between a range: `[min, max]` */
-  dpr?: Dpr
-  /** Props that go into the default raycaster */
-  raycaster?: Partial<THREE$1.Raycaster>
-  /** A `THREE.Scene` instance or props that go into the default scene */
-  scene?: THREE$1.Scene | Partial<THREE$1.Scene>
-  /** A `THREE.Camera` instance or props that go into the default camera */
-  camera?: CameraProps
-  /** An R3F event manager to manage elements' pointer events */
-  events?: (store: RootStore) => EventManager<HTMLElement>
-  /** Callback after the canvas has rendered (but not yet committed) */
-  onCreated?: (state: RootState) => void
-  /** Response for pointer clicks that have missed any target */
-  onPointerMissed?: (event: MouseEvent) => void
-  /** Response for dragover events that have missed any target */
-  onDragOverMissed?: (event: DragEvent) => void
-  /** Response for drop events that have missed any target */
-  onDropMissed?: (event: DragEvent) => void
-  /** Whether to automatically update the frustum each frame (default: true) */
-  autoUpdateFrustum?: boolean
-  /**
-   * Enable WebGPU occlusion queries for onOccluded/onVisible events.
-   * Auto-enabled when any object uses onOccluded or onVisible handlers.
-   * Only works with WebGPU renderer - WebGL will log a warning.
-   */
-  occlusion?: boolean
-  /** Internal: stored size props from Canvas for reset functionality */
-  _sizeProps?: { width?: number; height?: number } | null
-  /** Force canvas dimensions to even numbers (fixes Safari rendering issues with odd/fractional sizes) */
-  forceEven?: boolean
-}
-
-//* Reconciler Root ==============================
-
-interface ReconcilerRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas$1> {
-  configure: (config?: RenderProps<TCanvas>) => Promise<ReconcilerRoot<TCanvas>>
-  render: (element: ReactNode) => RootStore
-  unmount: () => void
-}
-
-//* Inject State ==============================
-
-type InjectState = Partial<
-  Omit<RootState, 'events'> & {
-    events?: {
-      enabled?: boolean
-      priority?: number
-      compute?: ComputeFunction
-      connected?: any
-    }
-    /**
-     * When true (default), injects a THREE.Scene between container and children if container isn't already a Scene.
-     * This ensures state.scene is always a real THREE.Scene with proper properties (background, environment, fog).
-     * Set to false to use the container directly as scene (anti-pattern, but supported for edge cases).
-     */
-    injectScene?: boolean
-  }
->
-
-//* Reconciler Types ==============================
-
-// FiberRoot is an opaque internal React type - we define it locally
-// to avoid bundling @types/react-reconciler which causes absolute path issues
-type FiberRoot = any
-
-interface Root {
-  fiber: FiberRoot
-  store: RootStore
-}
-
-type AttachFnType<O = any> = (parent: any, self: O) => () => void
-type AttachType<O = any> = string | AttachFnType<O>
-
-type ConstructorRepresentation<T = any> = new (...args: any[]) => T
-
-interface Catalogue {
-  [name: string]: ConstructorRepresentation
-}
-
-// TODO: handle constructor overloads
-// https://github.com/pmndrs/react-three-fiber/pull/2931
-// https://github.com/microsoft/TypeScript/issues/37079
-type Args<T> = T extends ConstructorRepresentation
-  ? T extends typeof Color$1
-    ? [r: number, g: number, b: number] | [color: ColorRepresentation]
-    : ConstructorParameters<T>
-  : any[]
-
-type ArgsProp<P> = P extends ConstructorRepresentation
-  ? IsAllOptional<ConstructorParameters<P>> extends true
-    ? { args?: Args<P> }
-    : { args: Args<P> }
-  : { args: unknown[] }
-
-type InstanceProps<T = any, P = any> = ArgsProp<P> & {
-  object?: T
-  dispose?: null
-  attach?: AttachType<T>
-  onUpdate?: (self: T) => void
-}
-
-interface Instance<O = any> {
-  root: RootStore
-  type: string
-  parent: Instance | null
-  children: Instance[]
-  props: InstanceProps<O> & Record<string, unknown>
-  object: O & { __r3f?: Instance<O> }
-  eventCount: number
-  handlers: Partial<EventHandlers>
-  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>
-}
-
-interface HostConfig {
-  type: string
-  props: Instance['props']
-  container: RootStore
-  instance: Instance
-  textInstance: void
-  suspenseInstance: Instance
-  hydratableInstance: never
-  formInstance: never
-  publicInstance: Instance['object']
-  hostContext: {}
-  childSet: never
-  timeoutHandle: number | undefined
-  noTimeout: -1
-  TransitionStatus: null
-}
-declare global {
-  var IS_REACT_ACT_ENVIRONMENT: boolean | undefined
-}
-
-//* Loop Types ==============================
-
-type GlobalRenderCallback = (timestamp: number) => void
-
-type GlobalEffectType = 'before' | 'after' | 'tail'
-
-declare const presetsObj: {
-    apartment: string;
-    city: string;
-    dawn: string;
-    forest: string;
-    lobby: string;
-    night: string;
-    park: string;
-    studio: string;
-    sunset: string;
-    warehouse: string;
-};
-type PresetsType = keyof typeof presetsObj;
-
-//* Background Types ==============================
-
-/**
- * Expanded object form for background configuration.
- * Allows separate textures for background (visual backdrop) and environment (PBR lighting).
- */
-interface BackgroundConfig {
-  /** HDRI preset name: 'apartment', 'city', 'dawn', 'forest', 'lobby', 'night', 'park', 'studio', 'sunset', 'warehouse' */
-  preset?: PresetsType
-  /** Files for cube texture (6 faces) or single HDR/EXR */
-  files?: string | string[]
-  /** Separate files for scene.background (visual backdrop) */
-  backgroundMap?: string | string[]
-  backgroundRotation?: Euler$1 | [number, number, number]
-  backgroundBlurriness?: number
-  backgroundIntensity?: number
-  /** Separate files for scene.environment (PBR lighting/reflections) */
-  envMap?: string | string[]
-  environmentRotation?: Euler$1 | [number, number, number]
-  environmentIntensity?: number
-  path?: string
-  extensions?: (loader: Loader) => void
-}
-
-/**
- * Background prop type for Canvas.
- *
- * String detection priority:
- * 1. Preset - exact match against known presets (apartment, city, dawn, forest, lobby, night, park, studio, sunset, warehouse)
- * 2. URL - starts with /, ./, ../, http://, https://, OR has image extension
- * 3. Color - default fallback (CSS color names, hex values, rgb(), etc.)
- *
- * @example Color
- * ```tsx
- * <Canvas background="red" />
- * <Canvas background="#ff0000" />
- * <Canvas background={0xff0000} />
- * ```
- *
- * @example Preset
- * ```tsx
- * <Canvas background="city" />
- * ```
- *
- * @example URL
- * ```tsx
- * <Canvas background="/path/to/env.hdr" />
- * <Canvas background="./sky.jpg" />
- * ```
- *
- * @example Object form
- * ```tsx
- * <Canvas background={{
- *   files: ['px.png', 'nx.png', 'py.png', 'ny.png', 'pz.png', 'nz.png'],
- *   backgroundMap: 'path/to/sky.jpg',
- *   envMap: 'path/to/lighting.hdr',
- *   backgroundBlurriness: 0.5,
- * }} />
- * ```
- */
-type BackgroundProp =
-  | ColorRepresentation // "red", "#ff0000", 0xff0000
-  | string // URL or preset
-  | BackgroundConfig // Expanded object form
-
-//* Canvas Types ==============================
-
-interface CanvasProps
-  extends
-    Omit<RenderProps<HTMLCanvasElement>, 'size' | 'primaryCanvas' | 'scheduler'>,
-    React$1.HTMLAttributes<HTMLDivElement> {
-  children?: React$1.ReactNode
-  ref?: React$1.Ref<HTMLCanvasElement>
-  /** Canvas fallback content, similar to img's alt prop */
-  fallback?: React$1.ReactNode
-  /**
-   * Options to pass to useMeasure.
-   * @see https://github.com/pmndrs/react-use-measure#api
-   */
-  resize?: Options
-  /** The target where events are being subscribed to, default: the div that wraps canvas */
-  eventSource?: HTMLElement | React$1.RefObject<HTMLElement>
-  /** The event prefix that is cast into canvas pointer x/y events, default: "offset" */
-  eventPrefix?: 'offset' | 'client' | 'page' | 'layer' | 'screen'
-  /** Enable/disable automatic HMR refresh for TSL nodes and uniforms, default: true in dev */
-  hmr?: boolean
-  /** Canvas resolution width in pixels. If omitted, uses container width. */
-  width?: number
-  /** Canvas resolution height in pixels. If omitted, uses container height. */
-  height?: number
-  /** Force canvas dimensions to even numbers (fixes Safari rendering issues with odd/fractional sizes) */
-  forceEven?: boolean
-  /**
-   * Scene background configuration.
-   * Accepts colors, URLs, presets, or an expanded object for separate background/environment.
-   * @see BackgroundProp for full documentation and examples
-   */
-  background?: BackgroundProp
-}
-
-//* Loader Types ==============================
-
-type InputLike = string | string[] | string[][] | Readonly<string | string[] | string[][]>
-
-// Define a loader-like interface that matches THREE.Loader's load signature
-// This works for both generic and non-generic THREE.Loader instances
-interface LoaderLike {
-  load(
-    url: InputLike,
-    onLoad?: (result: any) => void,
-    onProgress?: (event: ProgressEvent<EventTarget>) => void,
-    onError?: (error: unknown) => void,
-  ): any
-}
-
-type GLTFLike = { scene: THREE$1.Object3D }
-
-type LoaderInstance<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> =
-  T extends ConstructorRepresentation<LoaderLike> ? InstanceType<T> : T
-
-// Infer result type from the load method's callback parameter
-type InferLoadResult<T> = T extends {
-  load(url: any, onLoad?: (result: infer R) => void, ...args: any[]): any
-}
-  ? R
-  : T extends ConstructorRepresentation<any>
-    ? InstanceType<T> extends {
-        load(url: any, onLoad?: (result: infer R) => void, ...args: any[]): any
-      }
-      ? R
-      : any
-    : any
-
-type LoaderResult<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> =
-  InferLoadResult<LoaderInstance<T>> extends infer R ? (R extends GLTFLike ? R & ObjectMap : R) : never
-
-type Extensions<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> = (
-  loader: LoaderInstance<T>,
-) => void
-
-//* Renderer Props ========================================
-
-type WebGLDefaultProps = Omit<THREE$1.WebGLRendererParameters, 'canvas'> & BaseRendererProps
-
-type WebGLProps =
-  | RendererFactory<THREE$1.WebGLRenderer, WebGLDefaultProps>
-  | Partial<Properties<THREE$1.WebGLRenderer> | THREE$1.WebGLRendererParameters>
-
-interface WebGLShadowConfig {
-  shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE$1.WebGLShadowMap>
-}
-
-//* Legacy-specific Types ========================================
-
-/** Legacy (WebGL) renderer type - re-exported as R3FRenderer from @react-three/fiber/legacy */
-type LegacyRenderer = THREE$1.WebGLRenderer
-
-/** Legacy internal state with narrowed renderer type */
-interface LegacyInternalState extends Omit<InternalState, 'actualRenderer'> {
-  actualRenderer: THREE$1.WebGLRenderer
-}
-
-/**
- * Legacy-specific RootState with narrowed renderer type.
- * Automatically used when importing from `@react-three/fiber/legacy`.
- *
- * @example
- * ```tsx
- * import { useThree } from '@react-three/fiber/legacy'
- *
- * function MyComponent() {
- *   const { renderer } = useThree()
- *   // renderer is typed as THREE.WebGLRenderer
- *   renderer.shadowMap.enabled = true
- * }
- * ```
- */
-interface LegacyRootState extends Omit<RootState, 'renderer' | 'internal'> {
-  /** The WebGL renderer instance */
-  renderer: THREE$1.WebGLRenderer
-  /** Internals with WebGL renderer */
-  internal: LegacyInternalState
-}
-
-//* RenderTarget Types ==============================
-
-
-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
-  }
-
-  /**
-   * ShaderCallable - the return type of Fn()
-   * A callable shader function node that can be invoked with parameters.
-   * The function returns a ShaderNodeObject when called.
-   *
-   * @example
-   * ```tsx
-   * // Define a shader function
-   * const blendColorFn = Fn(([color1, color2, factor]) => {
-   *   return mix(color1, color2, factor)
-   * })
-   *
-   * // Type when retrieving from nodes store
-   * const { blendColorFn } = nodes as { blendColorFn: ShaderCallable }
-   *
-   * // Or with specific return type
-   * const { myFn } = nodes as { myFn: ShaderCallable<THREE.Node> }
-   * ```
-   */
-  type ShaderCallable<R extends Node = Node> = ((...params: unknown[]) => ShaderNodeObject<R>) & Node
-
-  /**
-   * ShaderNodeRef - a ShaderNodeObject wrapper around a Node
-   * This is the common return type for TSL operations (add, mul, sin, etc.)
-   *
-   * @example
-   * ```tsx
-   * const { wobble } = nodes as { wobble: ShaderNodeRef }
-   * ```
-   */
-  type ShaderNodeRef<T extends Node = Node> = ShaderNodeObject<T>
-
-  /**
-   * TSLNodeType - Union of all common TSL node types
-   * Used by ScopedStore to properly type node access from the store.
-   *
-   * Includes:
-   * - Node: base Three.js node type
-   * - ShaderCallable: function nodes created with Fn()
-   * - ShaderNodeObject: wrapped nodes from TSL operations (sin, mul, mix, etc.)
-   *
-   * @example
-   * ```tsx
-   * // In useLocalNodes, nodes are typed as TSLNodeType
-   * const { positionNode, blendColorFn } = useLocalNodes(({ nodes }) => ({
-   *   positionNode: nodes.myPosition,      // Works - Node is in union
-   *   blendColorFn: nodes.myFn,            // Works - ShaderCallable is in union
-   * }))
-   *
-   * // Can narrow with type guard or assertion when needed
-   * if (typeof blendColorFn === 'function') {
-   *   blendColorFn(someColor, 0.5)
-   * }
-   * ```
-   */
-  type TSLNodeType = Node | ShaderCallable<Node> | ShaderNodeObject<Node>
-
-  /** Flat record of uniform nodes (no nested scopes) */
-  type UniformRecord<T extends UniformNode = UniformNode> = Record<string, T>
-
-  /**
-   * Uniform store that can contain both root-level uniforms and scoped uniform objects
-   * Used by state.uniforms which has structure like:
-   * { uTime: UniformNode, player: { uHealth: UniformNode }, enemy: { uHealth: UniformNode } }
-   */
-  type UniformStore = Record<string, UniformNode | UniformRecord>
-
-  /**
-   * Helper to safely access a uniform node from the store.
-   * Use this when accessing state.uniforms to get proper typing.
-   * @example
-   * const uTime = uniforms.uTime as UniformNode<number>
-   * const uColor = uniforms.uColor as UniformNode<import('three/webgpu').Color>
-   */
-  type GetUniform<T = unknown> = UniformNode<T>
-
-  /**
-   * Acceptable input values for useUniforms - raw values that get converted to UniformNodes
-   * Supports:
-   * - Primitives: number, string (color), boolean
-   * - Three.js types: Color, Vector2/3/4, Matrix3/4, Euler, Quaternion
-   * - Plain objects: { x, y, z, w } converted to vectors
-   * - TSL nodes: color(), vec3(), float() for type casting
-   * - UniformNode: existing uniforms (reused as-is)
-   */
-  type UniformValue =
-    | number
-    | string
-    | boolean
-    | three_webgpu.Color
-    | three_webgpu.Vector2
-    | three_webgpu.Vector3
-    | three_webgpu.Vector4
-    | three_webgpu.Matrix3
-    | three_webgpu.Matrix4
-    | three_webgpu.Euler
-    | three_webgpu.Quaternion
-    | { x: number; y?: number; z?: number; w?: number } // Plain objects converted to vectors
-    | Node // TSL nodes like color(), vec3(), float() for type casting
-    | UniformNode
-
-  /** Input record for useUniforms - accepts raw values or UniformNodes */
-  type UniformInputRecord = Record<string, UniformValue>
-}
-
-//* Module Augmentation ==============================
-
-declare module 'three/tsl' {
-  /**
-   * Fn with array parameter destructuring
-   * @example Fn(([uv, skew]) => { ... })
-   */
-  export function Fn<R extends Node = Node>(
-    jsFunc: (inputs: ShaderNodeObject<Node>[]) => ShaderNodeObject<R>,
-  ): ShaderCallable<R>
-
-  /**
-   * Fn with object parameter destructuring
-   * @example Fn(({ color, intensity }) => { ... })
-   */
-  export function Fn<T extends Record<string, unknown>, R extends Node = Node>(
-    jsFunc: (inputs: T) => ShaderNodeObject<R>,
-  ): ShaderCallable<R>
-
-  /**
-   * Fn with array params + layout
-   * @example Fn(([a, b]) => { ... }, { layout: [...] })
-   */
-  export function Fn<R extends Node = Node>(
-    jsFunc: (inputs: ShaderNodeObject<Node>[]) => ShaderNodeObject<R>,
-    layout: { layout?: unknown },
-  ): ShaderCallable<R>
-
-  /**
-   * Fn with object params + layout
-   */
-  export function Fn<T extends Record<string, unknown>, R extends Node = Node>(
-    jsFunc: (inputs: T) => ShaderNodeObject<R>,
-    layout: { layout?: unknown },
-  ): ShaderCallable<R>
-}
-
-/**
- * PostProcessing Types for usePostProcessing hook (WebGPU only)
- */
-
-
-
-declare global {
-  /** Pass record - stores TSL pass nodes for post-processing */
-  type PassRecord = Record<string, any>
-
-  /** Setup callback - runs first to configure MRT, create additional passes */
-  type PostProcessingSetupCallback = (state: RootState) => PassRecord | void
-
-  /** Main callback - runs second to configure outputNode, create effect passes */
-  type PostProcessingMainCallback = (state: RootState) => PassRecord | void
-
-  /** Return type for usePostProcessing hook */
-  interface UsePostProcessingReturn {
-    /** Current passes from state */
-    passes: PassRecord
-    /** PostProcessing instance (null if not initialized) */
-    postProcessing: any | null // THREE.PostProcessing
-    /** Clear all passes from state */
-    clearPasses: () => void
-    /** Reset PostProcessing entirely (clears PP + passes) */
-    reset: () => void
-    /** Re-run setup/main callbacks with current closure values */
-    rebuild: () => void
-    /** True when PostProcessing is configured and ready */
-    isReady: boolean
-  }
-}
-
-//* 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 {
-  set(...args: number[]): any
-}
-interface VectorRepresentation extends MathRepresentation {
-  setScalar(value: number): any
-}
-type MathTypes = MathRepresentation | Euler$2 | Color$2
-
-type MathType<T extends MathTypes> = T extends Color$2
-  ? Args<typeof Color$2> | ColorRepresentation$1
-  : T extends VectorRepresentation | Layers$1 | Euler$2
-    ? T | MutableOrReadonlyParameters<T['set']> | number
-    : T | MutableOrReadonlyParameters<T['set']>
-
-type MathProps<P> = {
-  [K in keyof P as P[K] extends MathTypes ? K : never]: P[K] extends MathTypes ? MathType<P[K]> : never
-}
-
-type Vector2 = MathType<Vector2$1>
-type Vector3 = MathType<Vector3$1>
-type Vector4 = MathType<Vector4$1>
-type Color = MathType<Color$2>
-type Layers = MathType<Layers$1>
-type Quaternion = MathType<Quaternion$1>
-type Euler = MathType<Euler$2>
-type Matrix3 = MathType<Matrix3$1>
-type Matrix4 = MathType<Matrix4$1>
-
-interface RaycastableRepresentation {
-  raycast(raycaster: Raycaster, intersects: Intersection$1[]): void
-}
-type EventProps<P> = P extends RaycastableRepresentation ? Partial<EventHandlers> : {}
-
-/**
- * Props for geometry transform methods that can be called with `once()`.
- * These methods modify the geometry in-place and only make sense to call once on mount.
- *
- * @example
- * import { once } from '@react-three/fiber'
- *
- * <boxGeometry args={[1, 1, 1]} rotateX={once(Math.PI / 2)} />
- * <planeGeometry args={[10, 10]} translate={once(0, 0, 5)} />
- * <bufferGeometry applyMatrix4={once(matrix)} center={once()} />
- */
-interface GeometryTransformProps {
-  /** Rotate the geometry about the X axis (radians). Use with once(). */
-  rotateX?: number
-  /** Rotate the geometry about the Y axis (radians). Use with once(). */
-  rotateY?: number
-  /** Rotate the geometry about the Z axis (radians). Use with once(). */
-  rotateZ?: number
-  /** Translate the geometry (x, y, z). Use with once(). */
-  translate?: [x: number, y: number, z: number]
-  /** Scale the geometry (x, y, z). Use with once(). */
-  scale?: [x: number, y: number, z: number]
-  /** Center the geometry based on bounding box. Use with once(). */
-  center?: true
-  /** Apply a Matrix4 transformation. Use with once(). */
-  applyMatrix4?: Matrix4$1
-  /** Apply a Quaternion rotation. Use with once(). */
-  applyQuaternion?: Quaternion$1
-}
-
-type GeometryProps<P> = P extends BufferGeometry ? GeometryTransformProps : {}
-
-/**
- * Workaround for @types/three TSL node type issues.
- * The Node base class has properties that subclasses (OperatorNode, ConstNode, etc.) don't inherit.
- * This transforms `Node | null` properties to accept any object with node-like shape.
- */
-type TSLNodeInput = { nodeType?: string | null; uuid?: string } | null
-
-/**
- * For node material properties (colorNode, positionNode, etc.), accept broader types
- * since @types/three has broken inheritance for TSL node subclasses.
- */
-type NodeProps<P> = {
-  [K in keyof P as P[K] extends Node | null ? K : never]?: TSLNodeInput
-}
-
-interface ReactProps<P> {
-  children?: React.ReactNode
-  ref?: React.Ref<P>
-  key?: React.Key
-}
-
-type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = Partial<
-  Overwrite<P, MathProps<P> & ReactProps<P> & EventProps<P> & GeometryProps<P> & NodeProps<P>>
->
-
-type ThreeElement<T extends ConstructorRepresentation> = Mutable<
-  Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>
->
-
-type ThreeToJSXElements<T extends Record<string, any>> = {
-  [K in keyof T & string as Uncapitalize<K>]: T[K] extends ConstructorRepresentation ? ThreeElement<T[K]> : never
-}
-
-type ThreeExports = typeof THREE
-type ThreeElementsImpl = ThreeToJSXElements<ThreeExports>
-
-interface ThreeElements extends Omit<ThreeElementsImpl, 'audio' | 'source' | 'line' | 'path'> {
-  primitive: Omit<ThreeElement<any>, 'args'> & { object: object }
-  // Conflicts with DOM types can be accessed through a three* prefix
-  threeAudio: ThreeElementsImpl['audio']
-  threeSource: ThreeElementsImpl['source']
-  threeLine: ThreeElementsImpl['line']
-  threePath: ThreeElementsImpl['path']
-}
-
-declare module 'react' {
-  namespace JSX {
-    interface IntrinsicElements extends ThreeElements {}
-  }
-}
-
-declare module 'react/jsx-runtime' {
-  namespace JSX {
-    interface IntrinsicElements extends ThreeElements {}
-  }
-}
-
-declare module 'react/jsx-dev-runtime' {
-  namespace JSX {
-    interface IntrinsicElements extends ThreeElements {}
-  }
-}
-
-type three_d_Color = Color;
-type three_d_ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = ElementProps<T, P>;
-type three_d_Euler = Euler;
-type three_d_EventProps<P> = EventProps<P>;
-type three_d_GeometryProps<P> = GeometryProps<P>;
-type three_d_GeometryTransformProps = GeometryTransformProps;
-type three_d_Layers = Layers;
-type three_d_MathProps<P> = MathProps<P>;
-type three_d_MathRepresentation = MathRepresentation;
-type three_d_MathType<T extends MathTypes> = MathType<T>;
-type three_d_MathTypes = MathTypes;
-type three_d_Matrix3 = Matrix3;
-type three_d_Matrix4 = Matrix4;
-type three_d_MutableOrReadonlyParameters<T extends (...args: any) => any> = MutableOrReadonlyParameters<T>;
-type three_d_NodeProps<P> = NodeProps<P>;
-type three_d_Quaternion = Quaternion;
-type three_d_RaycastableRepresentation = RaycastableRepresentation;
-type three_d_ReactProps<P> = ReactProps<P>;
-type three_d_TSLNodeInput = TSLNodeInput;
-type three_d_ThreeElement<T extends ConstructorRepresentation> = ThreeElement<T>;
-type three_d_ThreeElements = ThreeElements;
-type three_d_ThreeElementsImpl = ThreeElementsImpl;
-type three_d_ThreeExports = ThreeExports;
-type three_d_ThreeToJSXElements<T extends Record<string, any>> = ThreeToJSXElements<T>;
-type three_d_Vector2 = Vector2;
-type three_d_Vector3 = Vector3;
-type three_d_Vector4 = Vector4;
-type three_d_VectorRepresentation = VectorRepresentation;
-declare namespace three_d {
-  export type { three_d_Color as Color, three_d_ElementProps as ElementProps, three_d_Euler as Euler, three_d_EventProps as EventProps, three_d_GeometryProps as GeometryProps, three_d_GeometryTransformProps as GeometryTransformProps, three_d_Layers as Layers, three_d_MathProps as MathProps, three_d_MathRepresentation as MathRepresentation, three_d_MathType as MathType, three_d_MathTypes as MathTypes, three_d_Matrix3 as Matrix3, three_d_Matrix4 as Matrix4, three_d_MutableOrReadonlyParameters as MutableOrReadonlyParameters, three_d_NodeProps as NodeProps, three_d_Quaternion as Quaternion, three_d_RaycastableRepresentation as RaycastableRepresentation, three_d_ReactProps as ReactProps, three_d_TSLNodeInput as TSLNodeInput, three_d_ThreeElement as ThreeElement, three_d_ThreeElements as ThreeElements, three_d_ThreeElementsImpl as ThreeElementsImpl, three_d_ThreeExports as ThreeExports, three_d_ThreeToJSXElements as ThreeToJSXElements, three_d_Vector2 as Vector2, three_d_Vector3 as Vector3, three_d_Vector4 as Vector4, three_d_VectorRepresentation as VectorRepresentation };
-}
-
-/**
- * @fileoverview Registry for primary canvases that can be targeted by secondary canvases
- *
- * Enables multi-canvas WebGPU rendering where multiple Canvas components share
- * 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
- */
-
-interface PrimaryCanvasEntry {
-    /** The WebGPURenderer instance owned by this primary canvas */
-    renderer: WebGPURenderer;
-    /** The zustand store for this canvas */
-    store: RootStore;
-}
-/**
- * Register a primary canvas that can be targeted by secondary canvases.
- *
- * @param id - Unique identifier for this primary canvas
- * @param renderer - The WebGPURenderer owned by this canvas
- * @param store - The zustand store for this canvas
- * @returns Cleanup function to unregister on unmount
- */
-declare function registerPrimary(id: string, renderer: WebGPURenderer, store: RootStore): () => void;
-/**
- * Get a registered primary canvas by id.
- *
- * @param id - The id of the primary canvas to look up
- * @returns The primary canvas entry or undefined if not found
- */
-declare function getPrimary(id: string): PrimaryCanvasEntry | undefined;
-/**
- * Wait for a primary canvas to be registered.
- * Returns immediately if already registered, otherwise waits.
- *
- * @param id - The id of the primary canvas to wait for
- * @param timeout - Optional timeout in ms (default: 5000)
- * @returns Promise that resolves with the primary canvas entry
- */
-declare function waitForPrimary(id: string, timeout?: number): Promise<PrimaryCanvasEntry>;
-/**
- * Check if a primary canvas with the given id exists.
- *
- * @param id - The id to check
- * @returns True if a primary canvas with this id is registered
- */
-declare function hasPrimary(id: string): boolean;
-/**
- * Unregister a primary canvas. Called on unmount.
- *
- * @param id - The id of the primary canvas to unregister
- */
-declare function unregisterPrimary(id: string): void;
-/**
- * Get all registered primary canvas ids. Useful for debugging.
- */
-declare function getPrimaryIds(): string[];
-
-type EnvironmentLoaderProps = {
-    files?: string | string[];
-    path?: string;
-    preset?: PresetsType;
-    extensions?: (loader: Loader$1) => void;
-    colorSpace?: ColorSpace;
-};
-/**
- * Loads environment textures for reflections and lighting.
- * Supports HDR files, presets, and cubemaps.
- *
- * @example Basic usage
- * ```jsx
- * const texture = useEnvironment({ preset: 'sunset' })
- * ```
- */
-declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<unknown> | CubeTexture;
-declare namespace useEnvironment {
-    var preload: (preloadOptions?: EnvironmentLoaderPreloadOptions) => void;
-    var clear: (clearOptions?: EnvironmentLoaderClearOptions) => void;
-}
-type EnvironmentLoaderPreloadOptions = Omit<EnvironmentLoaderProps, 'encoding'>;
-type EnvironmentLoaderClearOptions = Pick<EnvironmentLoaderProps, 'files' | 'preset'>;
-
-/**
- * Props for Environment component that sets up global cubemap for PBR materials and backgrounds.
- *
- * @property children - React children to render into custom environment portal
- * @property frames - Number of frames to render the environment. Use 1 for static, Infinity for animated (default: 1)
- * @property near - Near clipping plane for cube camera (default: 0.1)
- * @property far - Far clipping plane for cube camera (default: 1000)
- * @property resolution - Resolution of the cube render target (default: 256)
- * @property background - Whether to set scene.background. Can be true, false, or "only" (which only sets background) (default: false)
- *
- * @property blur - @deprecated Use backgroundBlurriness instead
- * @property backgroundBlurriness - Blur factor between 0 and 1 for background (default: 0, requires three.js 0.146+)
- * @property backgroundIntensity - Intensity factor for background (default: 1, requires three.js 0.163+)
- * @property backgroundRotation - Rotation for background as Euler angles (default: [0,0,0], requires three.js 0.163+)
- * @property environmentIntensity - Intensity factor for environment lighting (default: 1, requires three.js 0.163+)
- * @property environmentRotation - Rotation for environment as Euler angles (default: [0,0,0], requires three.js 0.163+)
- *
- * @property map - Pre-existing texture to use as environment map
- * @property preset - HDRI Haven preset: 'apartment', 'city', 'dawn', 'forest', 'lobby', 'night', 'park', 'studio', 'sunset', 'warehouse'. Not for production use.
- * @property scene - Custom THREE.Scene or ref to apply environment to (default: uses default scene)
- * @property ground - Ground projection settings. Use true for defaults or object with:
- *   - height: Height of camera used to create env map (default: 15)
- *   - radius: Radius of the world (default: 60)
- *   - scale: Scale of backside projected sphere (default: 1000)
- *
- * Additional loader props:
- * @property files - File path(s) for environment. Supports .hdr, .exr, gainmap .jpg/.webp, or array of 6 cube faces
- * @property path - Base path for file loading
- * @property extensions - Texture extensions override
- */
-type EnvironmentProps = {
-    children?: React$1.ReactNode;
-    frames?: number;
-    near?: number;
-    far?: number;
-    resolution?: number;
-    background?: boolean | 'only';
-    /** deprecated, use backgroundBlurriness */
-    blur?: number;
-    backgroundBlurriness?: number;
-    backgroundIntensity?: number;
-    backgroundRotation?: Euler$3;
-    environmentIntensity?: number;
-    environmentRotation?: Euler$3;
-    map?: Texture$1;
-    preset?: PresetsType;
-    scene?: Scene | React$1.RefObject<Scene>;
-    ground?: boolean | {
-        radius?: number;
-        height?: number;
-        scale?: number;
-    };
-    /** Solid color for background (alternative to files/preset) */
-    color?: ColorRepresentation$1;
-    /** Separate files for background (when different from environment files) */
-    backgroundFiles?: string | string[];
-} & EnvironmentLoaderProps;
-/**
- * Internal component that applies a pre-existing texture as environment map.
- * Sets scene.environment and optionally scene.background.
- *
- * @example
- * ```jsx
- * <CubeCamera>{(texture) => <EnvironmentMap map={texture} />}</CubeCamera>
- * ```
- */
-declare function EnvironmentMap({ scene, background, map, ...config }: EnvironmentProps): null;
-/**
- * Internal component that loads environment textures from files or presets.
- * Uses HDRLoader for .hdr, EXRLoader for .exr, UltraHDRLoader for .jpg/.jpeg HDR,
- * GainMapLoader for gainmap .webp, or CubeTextureLoader for arrays of images.
- *
- * @example With preset
- * ```jsx
- * <EnvironmentCube preset="sunset" />
- * ```
- *
- * @example From HDR file
- * ```jsx
- * <EnvironmentCube files="environment.hdr" />
- * ```
- *
- * @example From gainmap (smallest footprint)
- * ```jsx
- * <EnvironmentCube files={['file.webp', 'file-gainmap.webp', 'file.json']} />
- * ```
- *
- * @example From cube faces
- * ```jsx
- * <EnvironmentCube files={['px.png', 'nx.png', 'py.png', 'ny.png', 'pz.png', 'nz.png']} />
- * ```
- */
-declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, ...rest }: EnvironmentProps): null;
-/**
- * Internal component that renders custom environment using a portal and cube camera.
- * Renders children into an off-buffer and films with a cube camera to create environment map.
- * Can be static (frames=1) or animated (frames=Infinity).
- *
- * @example Custom environment with sphere
- * ```jsx
- * <EnvironmentPortal background near={1} far={1000} resolution={256}>
- *   <mesh scale={100}>
- *     <sphereGeometry args={[1, 64, 64]} />
- *     <meshBasicMaterial map={texture} side={THREE.BackSide} />
- *   </mesh>
- * </EnvironmentPortal>
- * ```
- *
- * @example Animated environment
- * ```jsx
- * <EnvironmentPortal frames={Infinity} resolution={256}>
- *   <Float>
- *     <mesh />
- *   </Float>
- * </EnvironmentPortal>
- * ```
- *
- * @example Mixed with preset
- * ```jsx
- * <EnvironmentPortal preset="warehouse">
- *   <mesh />
- * </EnvironmentPortal>
- * ```
- */
-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>;
-    }
-}
-/**
- * Sets up a global environment map for PBR materials and backgrounds.
- * Affects scene.environment and optionally scene.background unless a custom scene is passed.
- *
- * Supports multiple input methods:
- * - **Presets**: Selection of HDRI Haven assets (apartment, city, dawn, forest, lobby, night, park, studio, sunset, warehouse)
- * - **Files**: HDR (.hdr), EXR (.exr), gainmap JPEG (.jpg), gainmap WebP (.webp), or cube faces (array of 6 images)
- * - **Texture**: Pre-existing cube texture via `map` prop
- * - **Custom Scene**: Render children into environment using portal and cube camera
- * - **Ground Projection**: Project environment onto ground plane
- *
- * @remarks
- * - Preset property is NOT meant for production and may fail (relies on CDNs)
- * - Gainmap format has the smallest file footprint
- * - Use `frames={Infinity}` for animated environments with low resolution for performance
- * - Ground projection places models on the "ground" within the environment map
- * - Supports self-hosting with @pmndrs/assets using dynamic imports
- *
- * @example Basic preset usage
- * ```jsx
- * <Environment preset="sunset" />
- * ```
- *
- * @example From HDR file
- * ```jsx
- * <Environment files="/hdr/environment.hdr" />
- * ```
- *
- * @example From gainmap (smallest footprint)
- * ```jsx
- * <Environment files={['file.webp', 'file-gainmap.webp', 'file.json']} />
- * ```
- *
- * @example With self-hosted assets
- * ```jsx
- * import { suspend } from 'suspend-react'
- * const city = import('@pmndrs/assets/hdri/city.exr').then(m => m.default)
- *
- * <Environment files={suspend(city)} />
- * ```
- *
- * @example From existing texture
- * ```jsx
- * <CubeCamera>{(texture) => <Environment map={texture} />}</CubeCamera>
- * ```
- *
- * @example Custom environment scene
- * ```jsx
- * <Environment background near={1} far={1000} resolution={256}>
- *   <mesh scale={100}>
- *     <sphereGeometry args={[1, 64, 64]} />
- *     <meshBasicMaterial map={texture} side={THREE.BackSide} />
- *   </mesh>
- * </Environment>
- * ```
- *
- * @example Animated environment
- * ```jsx
- * <Environment frames={Infinity} resolution={256}>
- *   <Float>
- *     <mesh />
- *   </Float>
- * </Environment>
- * ```
- *
- * @example Mixed custom scene with preset
- * ```jsx
- * <Environment background preset="warehouse">
- *   <mesh />
- * </Environment>
- * ```
- *
- * @example With ground projection
- * ```jsx
- * <Environment ground={{ height: 15, radius: 60 }} preset="city" />
- * ```
- *
- * @example As background only
- * ```jsx
- * <Environment background="only" preset="sunset" />
- * ```
- *
- * @example With rotation and intensity
- * ```jsx
- * <Environment
- *   background
- *   backgroundBlurriness={0.5}
- *   backgroundIntensity={0.8}
- *   backgroundRotation={[0, Math.PI / 2, 0]}
- *   environmentIntensity={1.2}
- *   environmentRotation={[0, Math.PI / 4, 0]}
- *   preset="studio"
- * />
- * ```
- */
-declare function Environment(props: EnvironmentProps): react_jsx_runtime.JSX.Element;
-
-declare function removeInteractivity(store: RootStore, object: Object3D): void;
-declare function createEvents(store: RootStore): {
-    handlePointer: (name: string) => (event: DomEvent) => void;
-};
-/** Default R3F event manager for web */
-declare function createPointerEvents(store: RootStore): EventManager<HTMLElement>;
-
-/**
- * Gets or creates a memoized loader instance from a loader constructor or returns the loader if it's already an instance.
- * This allows external code to access loader methods like abort().
- */
-declare function getLoader<L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(Proto: L): L extends ConstructorRepresentation<infer T> ? T : L;
-/**
- * Synchronously loads and caches assets with a three loader.
- *
- * 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 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 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
- *
- * Returns a controls object for manual stepping, pausing, and resuming.
- *
- * @param callback - Function called each frame with (state, delta). Optional if you only need scheduler access.
- * @param priorityOrOptions - Either a priority number (backwards compat) or options object
- * @returns Controls object with step(), stepAll(), pause(), resume(), isPaused, id, scheduler
- *
- * @example
- * // Simple priority (backwards compat)
- * useFrame((state, delta) => { ... }, 5)
- *
- * @example
- * // With phase-based ordering
- * useFrame((state, delta) => { ... }, { phase: 'physics' })
- *
- * @example
- * // Outside Canvas - waits for Canvas to mount
- * 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) });
- *
- * @example
- * // Scheduler-only access (no callback)
- * const { scheduler } = useFrame()
- * scheduler.pauseJob('some-job-id')
- *
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe
- */
-declare function useFrame(callback?: FrameNextCallback, priorityOrOptions?: number | UseFrameNextOptions): FrameNextControls;
-
-declare const IsObject: (url: unknown) => url is Record<string, string>;
-type TextureArray<T> = T extends string[] ? Texture$1[] : never;
-type TextureRecord<T> = T extends Record<string, string> ? {
-    [key in keyof T]: Texture$1;
-} : never;
-type SingleTexture<T> = T extends string ? Texture$1 : never;
-type MappedTextureType<T extends string[] | string | Record<string, string>> = TextureArray<T> | TextureRecord<T> | SingleTexture<T>;
-/** Options for useTexture hook */
-type UseTextureOptions<Url extends string[] | string | Record<string, string>> = {
-    /** Callback when texture(s) finish loading */
-    onLoad?: (texture: MappedTextureType<Url>) => void;
-    /**
-     * Cache the texture in R3F's global state for access via useTextures().
-     * When true:
-     * - Textures persist until explicitly disposed
-     * - Returns existing cached textures if available (preserving modifications like colorSpace)
-     * @default false
-     */
-    cache?: boolean;
-};
-/**
- * Load texture(s) using Three's TextureLoader with Suspense support.
- *
- * @param input - URL string, array of URLs, or object mapping keys to URLs
- * @param optionsOrOnLoad - Options object or legacy onLoad callback
- *
- * @example
- * ```tsx
- * // Single texture
- * const diffuse = useTexture('/textures/diffuse.png')
- *
- * // Multiple textures (array)
- * const [diffuse, normal] = useTexture(['/diffuse.png', '/normal.png'])
- *
- * // Named textures (object)
- * const { diffuse, normal } = useTexture({
- *   diffuse: '/diffuse.png',
- *   normal: '/normal.png'
- * })
- *
- * // With caching - returns same texture object across components
- * // Modifications (colorSpace, wrapS, etc.) are preserved
- * const diffuse = useTexture('/diffuse.png', { cache: true })
- * diffuse.colorSpace = THREE.SRGBColorSpace
- *
- * // Another component gets the SAME texture with colorSpace already set
- * const sameDiffuse = useTexture('/diffuse.png', { cache: true })
- *
- * // Access cache directly
- * const { get } = useTextures()
- * const cached = get('/diffuse.png')
- * ```
- */
-declare function useTexture<Url extends string[] | string | Record<string, string>>(input: Url, optionsOrOnLoad?: UseTextureOptions<Url> | ((texture: MappedTextureType<Url>) => void)): MappedTextureType<Url>;
-declare namespace useTexture {
-    var preload: (url: string | string[]) => void;
-    var clear: (input: string | string[]) => void;
-}
-declare const Texture: ({ children, input, onLoad, cache, }: {
-    children?: (texture: ReturnType<typeof useTexture>) => ReactNode;
-    input: Parameters<typeof useTexture>[0];
-    onLoad?: Parameters<typeof useTexture>[1];
-    cache?: boolean;
-}) => react_jsx_runtime.JSX.Element;
-
-type TextureEntry = Texture$1 | {
-    value: Texture$1;
-    [key: string]: any;
-};
-interface UseTexturesReturn {
-    /** Map of all textures currently in cache */
-    textures: Map<string, TextureEntry>;
-    /** Get a specific texture by key (usually URL) */
-    get: (key: string) => TextureEntry | undefined;
-    /** Check if a texture exists in cache */
-    has: (key: string) => boolean;
-    /** Add a texture to the cache */
-    add: (key: string, value: TextureEntry) => void;
-    /** Add multiple textures to the cache */
-    addMultiple: (items: Map<string, TextureEntry> | Record<string, TextureEntry>) => void;
-    /** Remove a texture from cache (does NOT dispose GPU resources) */
-    remove: (key: string) => void;
-    /** Remove multiple textures from cache */
-    removeMultiple: (keys: string[]) => void;
-    /** Dispose a texture's GPU resources and remove from cache */
-    dispose: (key: string) => void;
-    /** Dispose multiple textures */
-    disposeMultiple: (keys: string[]) => void;
-    /** Dispose ALL cached textures - use with caution */
-    disposeAll: () => void;
-}
-/**
- * Hook for managing the global texture cache in R3F state.
- *
- * Textures are stored in a Map with URL/path keys for efficient lookup.
- * Useful for sharing texture references across materials and components.
- *
- * @example
- * ```tsx
- * const { textures, add, get, remove, has, dispose } = useTextures()
- *
- * // Check if texture is already cached
- * if (!has('/textures/diffuse.png')) {
- *   // Load with useTexture and cache: true, or manually add
- *   const tex = useTexture('/textures/diffuse.png', { cache: true })
- * }
- *
- * // Access cached texture from anywhere
- * const diffuse = get('/textures/diffuse.png')
- * if (diffuse) material.map = diffuse
- *
- * // Remove from cache only (texture still in GPU memory)
- * remove('/textures/old.png')
- *
- * // Fully dispose (frees GPU memory + removes from cache)
- * dispose('/textures/unused.png')
- *
- * // Nuclear option - dispose everything
- * disposeAll()
- * ```
- */
-declare function useTextures(): UseTexturesReturn;
-
-/**
- * Creates a render target compatible with the current renderer.
- *
- * - Legacy build: Returns WebGLRenderTarget
- * - WebGPU build: Returns RenderTarget
- * - Default build: Returns whichever matches the active renderer
- *
- * @example
- * ```tsx
- * // Use canvas size
- * const fbo = useRenderTarget()
- *
- * // Use canvas size with options
- * const fbo = useRenderTarget({ samples: 4 })
- *
- * // Square render target
- * const fbo = useRenderTarget(512)
- *
- * // Square render target with options
- * const fbo = useRenderTarget(512, { depthBuffer: true })
- *
- * // Explicit dimensions
- * const fbo = useRenderTarget(512, 256)
- *
- * // Explicit dimensions with options
- * const fbo = useRenderTarget(512, 256, { samples: 4 })
- * ```
- */
-declare function useRenderTarget(options?: RenderTargetOptions): RenderTarget | WebGLRenderTarget;
-declare function useRenderTarget(size: number, options?: RenderTargetOptions): RenderTarget | WebGLRenderTarget;
-declare function useRenderTarget(width: number, height: number, options?: RenderTargetOptions): RenderTarget | WebGLRenderTarget;
-
-/**
- * Returns the R3F Canvas' Zustand store. Useful for [transient updates](https://github.com/pmndrs/zustand#transient-updates-for-often-occurring-state-changes).
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usestore
- */
-declare function useStore(): RootStore;
-/**
- * Accesses R3F's internal state, containing renderer, canvas, scene, etc.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usethree
- */
-declare function useThree<T = RootState>(selector?: (state: RootState) => T, equalityFn?: <T>(state: T, newState: T) => boolean): T;
-/**
- * Exposes an object's {@link Instance}.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useInstanceHandle
- *
- * **Note**: this is an escape hatch to react-internal fields. Expect this to change significantly between versions.
- */
-declare function useInstanceHandle<T>(ref: React.RefObject<T>): React.RefObject<Instance<T>>;
-/**
- * Returns a node graph of an object with named nodes & materials.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usegraph
- */
-declare function useGraph(object: Object3D): ObjectMap;
-
-/**
- * Adds a global render callback which is called each frame BEFORE rendering.
- *
- * @deprecated Use `useFrame(callback, { phase: 'start' })` instead.
- * This function will be removed in a future version.
- *
- * @param callback - Function called each frame with timestamp
- * @returns Unsubscribe function
- *
- * @example
- * // OLD (deprecated)
- * const unsub = addEffect((timestamp) => { ... })
- *
- * // NEW
- * useFrame((state, delta) => { ... }, { phase: 'start' })
- *
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
- */
-declare function addEffect(callback: GlobalRenderCallback): () => void;
-/**
- * Adds a global after-render callback which is called each frame AFTER rendering.
- *
- * @deprecated Use `useFrame(callback, { phase: 'finish' })` instead.
- * This function will be removed in a future version.
- *
- * @param callback - Function called each frame with timestamp
- * @returns Unsubscribe function
- *
- * @example
- * // OLD (deprecated)
- * const unsub = addAfterEffect((timestamp) => { ... })
- *
- * // NEW
- * useFrame((state, delta) => { ... }, { phase: 'finish' })
- *
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
- */
-declare function addAfterEffect(callback: GlobalRenderCallback): () => void;
-/**
- * Adds a global callback which is called when rendering stops.
- *
- * @deprecated Use `scheduler.onIdle(callback)` instead.
- * This function will be removed in a future version.
- *
- * @param callback - Function called when rendering stops
- * @returns Unsubscribe function
- *
- * @example
- * // OLD (deprecated)
- * const unsub = addTail((timestamp) => { ... })
- *
- * // NEW
- * const { scheduler } = useFrame()
- * const unsub = scheduler.onIdle((timestamp) => { ... })
- *
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
- */
-declare function addTail(callback: GlobalRenderCallback): () => void;
-/**
- * Invalidates the view, requesting a frame to be rendered.
- * In demand mode, this triggers the scheduler to run frames.
- *
- * @param state - Optional root state (ignored in new scheduler, kept for backwards compat)
- * @param frames - Number of frames to request (default: 1)
- * @param stackFrames - If false, sets pendingFrames to frames. If true, adds to existing pendingFrames (default: false)
- *
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
- */
-declare function invalidate(state?: RootState, frames?: number, stackFrames?: boolean): void;
-/**
- * Advances the frameloop and runs render effects.
- * Useful for when manually rendering via `frameloop="never"`.
- *
- * @param timestamp - The timestamp to use for this frame
- * @param runGlobalEffects - Ignored (kept for backwards compat, global effects always run)
- * @param state - Ignored (kept for backwards compat)
- * @param frame - Ignored (kept for backwards compat)
- *
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
- */
-declare function advance(timestamp: number): void;
-
-/* eslint-disable @definitelytyped/no-unnecessary-generics */
-declare function ReactReconciler<
-    Type,
-    Props,
-    Container,
-    Instance,
-    TextInstance,
-    SuspenseInstance,
-    HydratableInstance,
-    FormInstance,
-    PublicInstance,
-    HostContext,
-    ChildSet,
-    TimeoutHandle,
-    NoTimeout,
-    TransitionStatus,
->(
-    /* eslint-enable @definitelytyped/no-unnecessary-generics */
-    config: ReactReconciler.HostConfig<
-        Type,
-        Props,
-        Container,
-        Instance,
-        TextInstance,
-        SuspenseInstance,
-        HydratableInstance,
-        FormInstance,
-        PublicInstance,
-        HostContext,
-        ChildSet,
-        TimeoutHandle,
-        NoTimeout,
-        TransitionStatus
-    >,
-): ReactReconciler.Reconciler<Container, Instance, TextInstance, SuspenseInstance, FormInstance, PublicInstance>;
-
-declare namespace ReactReconciler {
-    interface HostConfig<
-        Type,
-        Props,
-        Container,
-        Instance,
-        TextInstance,
-        SuspenseInstance,
-        HydratableInstance,
-        FormInstance,
-        PublicInstance,
-        HostContext,
-        ChildSet,
-        TimeoutHandle,
-        NoTimeout,
-        TransitionStatus,
-    > {
-        // -------------------
-        //        Modes
-        // -------------------
-        /**
-         * The reconciler has two modes: mutation mode and persistent mode. You must specify one of them.
-         *
-         * If your target platform is similar to the DOM and has methods similar to `appendChild`, `removeChild`, and so on, you'll want to use the **mutation mode**. This is the same mode used by React DOM, React ART, and the classic React Native renderer.
-         *
-         * ```js
-         * const HostConfig = {
-         *   // ...
-         *   supportsMutation: true,
-         *   // ...
-         * }
-         * ```
-         *
-         * Depending on the mode, the reconciler will call different methods on your host config.
-         *
-         * If you're not sure which one you want, you likely need the mutation mode.
-         */
-        supportsMutation: boolean;
-
-        /**
-         * The reconciler has two modes: mutation mode and persistent mode. You must specify one of them.
-         *
-         * If your target platform has immutable trees, you'll want the **persistent mode** instead. In that mode, existing nodes are never mutated, and instead every change clones the parent tree and then replaces the whole parent tree at the root. This is the node used by the new React Native renderer, codenamed "Fabric".
-         *
-         * ```js
-         * const HostConfig = {
-         *   // ...
-         *   supportsPersistence: true,
-         *   // ...
-         * }
-         * ```
-         *
-         * Depending on the mode, the reconciler will call different methods on your host config.
-         *
-         * If you're not sure which one you want, you likely need the mutation mode.
-         */
-        supportsPersistence: boolean;
-
-        // -------------------
-        //    Core Methods
-        // -------------------
-
-        /**
-         * This method should return a newly created node. For example, the DOM renderer would call `document.createElement(type)` here and then set the properties from `props`.
-         *
-         * You can use `rootContainer` to access the root container associated with that tree. For example, in the DOM renderer, this is useful to get the correct `document` reference that the root belongs to.
-         *
-         * The `hostContext` parameter lets you keep track of some information about your current place in the tree. To learn more about it, see `getChildHostContext` below.
-         *
-         * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal fields, be aware that it may change significantly between versions. You're taking on additional maintenance risk by reading from it, and giving up all guarantees if you write something to it.
-         *
-         * This method happens **in the render phase**. It can (and usually should) mutate the node it has just created before returning it, but it must not modify any other nodes. It must not register any event handlers on the parent tree. This is because an instance being created doesn't guarantee it would be placed in the tree — it could be left unused and later collected by GC. If you need to do something when an instance is definitely in the tree, look at `commitMount` instead.
-         */
-        createInstance(
-            type: Type,
-            props: Props,
-            rootContainer: Container,
-            hostContext: HostContext,
-            internalHandle: OpaqueHandle,
-        ): Instance;
-
-        /**
-         * Same as `createInstance`, but for text nodes. If your renderer doesn't support text nodes, you can throw here.
-         */
-        createTextInstance(
-            text: string,
-            rootContainer: Container,
-            hostContext: HostContext,
-            internalHandle: OpaqueHandle,
-        ): TextInstance;
-
-        /**
-         * This method should mutate the `parentInstance` and add the child to its list of children. For example, in the DOM this would translate to a `parentInstance.appendChild(child)` call.
-         *
-         * This method happens **in the render phase**. It can mutate `parentInstance` and `child`, but it must not modify any other nodes. It's called while the tree is still being built up and not connected to the actual tree on the screen.
-         */
-        appendInitialChild(parentInstance: Instance, child: Instance | TextInstance): void;
-
-        /**
-         * In this method, you can perform some final mutations on the `instance`. Unlike with `createInstance`, by the time `finalizeInitialChildren` is called, all the initial children have already been added to the `instance`, but the instance itself has not yet been connected to the tree on the screen.
-         *
-         * This method happens **in the render phase**. It can mutate `instance`, but it must not modify any other nodes. It's called while the tree is still being built up and not connected to the actual tree on the screen.
-         *
-         * There is a second purpose to this method. It lets you specify whether there is some work that needs to happen when the node is connected to the tree on the screen. If you return `true`, the instance will receive a `commitMount` call later. See its documentation below.
-         *
-         * If you don't want to do anything here, you should return `false`.
-         */
-        finalizeInitialChildren(
-            instance: Instance,
-            type: Type,
-            props: Props,
-            rootContainer: Container,
-            hostContext: HostContext,
-        ): boolean;
-
-        /**
-         * Some target platforms support setting an instance's text content without manually creating a text node. For example, in the DOM, you can set `node.textContent` instead of creating a text node and appending it.
-         *
-         * If you return `true` from this method, React will assume that this node's children are text, and will not create nodes for them. It will instead rely on you to have filled that text during `createInstance`. This is a performance optimization. For example, the DOM renderer returns `true` only if `type` is a known text-only parent (like `'textarea'`) or if `props.children` has a `'string'` type. If you return `true`, you will need to implement `resetTextContent` too.
-         *
-         * If you don't want to do anything here, you should return `false`.
-         *
-         * This method happens **in the render phase**. Do not mutate the tree from it.
-         */
-        shouldSetTextContent(type: Type, props: Props): boolean;
-
-        /**
-         * This method lets you return the initial host context from the root of the tree. See `getChildHostContext` for the explanation of host context.
-         *
-         * If you don't intend to use host context, you can return `null`.
-         *
-         * This method happens **in the render phase**. Do not mutate the tree from it.
-         */
-        getRootHostContext(rootContainer: Container): HostContext | null;
-
-        /**
-         * Host context lets you track some information about where you are in the tree so that it's available inside `createInstance` as the `hostContext` parameter. For example, the DOM renderer uses it to track whether it's inside an HTML or an SVG tree, because `createInstance` implementation needs to be different for them.
-         *
-         * If the node of this `type` does not influence the context you want to pass down, you can return `parentHostContext`. Alternatively, you can return any custom object representing the information you want to pass down.
-         *
-         * If you don't want to do anything here, return `parentHostContext`.
-         *
-         * This method happens **in the render phase**. Do not mutate the tree from it.
-         */
-        getChildHostContext(parentHostContext: HostContext, type: Type, rootContainer: Container): HostContext;
-
-        /**
-         * Determines what object gets exposed as a ref. You'll likely want to return the `instance` itself. But in some cases it might make sense to only expose some part of it.
-         *
-         * If you don't want to do anything here, return `instance`.
-         */
-        getPublicInstance(instance: Instance | TextInstance): PublicInstance;
-
-        /**
-         * This method lets you store some information before React starts making changes to the tree on the screen. For example, the DOM renderer stores the current text selection so that it can later restore it. This method is mirrored by `resetAfterCommit`.
-         *
-         * Even if you don't want to do anything here, you need to return `null` from it.
-         */
-        prepareForCommit(containerInfo: Container): Record<string, any> | null;
-
-        /**
-         * This method is called right after React has performed the tree mutations. You can use it to restore something you've stored in `prepareForCommit` — for example, text selection.
-         *
-         * You can leave it empty.
-         */
-        resetAfterCommit(containerInfo: Container): void;
-
-        /**
-         * This method is called for a container that's used as a portal target. Usually you can leave it empty.
-         */
-        preparePortalMount(containerInfo: Container): void;
-
-        /**
-         * You can proxy this to `setTimeout` or its equivalent in your environment.
-         */
-        scheduleTimeout(fn: (...args: unknown[]) => unknown, delay?: number): TimeoutHandle;
-
-        /**
-         * You can proxy this to `clearTimeout` or its equivalent in your environment.
-         */
-        cancelTimeout(id: TimeoutHandle): void;
-
-        /**
-         * This is a property (not a function) that should be set to something that can never be a valid timeout ID. For example, you can set it to `-1`.
-         */
-        noTimeout: NoTimeout;
-
-        /**
-         * Set this to true to indicate that your renderer supports `scheduleMicrotask`. We use microtasks as part of our discrete event implementation in React DOM. If you're not sure if your renderer should support this, you probably should. The option to not implement `scheduleMicrotask` exists so that platforms with more control over user events, like React Native, can choose to use a different mechanism.
-         */
-        supportsMicrotasks?: boolean;
-
-        /**
-         * Optional. You can proxy this to `queueMicrotask` or its equivalent in your environment.
-         */
-        scheduleMicrotask?(fn: () => unknown): void;
-
-        /**
-         * This is a property (not a function) that should be set to `true` if your renderer is the main one on the page. For example, if you're writing a renderer for the Terminal, it makes sense to set it to `true`, but if your renderer is used *on top of* React DOM or some other existing renderer, set it to `false`.
-         */
-        isPrimaryRenderer: boolean;
-
-        /**
-         * Whether the renderer shouldn't trigger missing `act()` warnings
-         */
-        warnsIfNotActing?: boolean;
-
-        getInstanceFromNode(node: any): Fiber | null | undefined;
-
-        beforeActiveInstanceBlur(): void;
-
-        afterActiveInstanceBlur(): void;
-
-        prepareScopeUpdate(scopeInstance: any, instance: any): void;
-
-        getInstanceFromScope(scopeInstance: any): null | Instance;
-
-        detachDeletedInstance(node: Instance): void;
-
-        // -------------------
-        //  Mutation Methods
-        //    (optional)
-        //  If you're using React in mutation mode (you probably do), you'll need to implement a few more methods.
-        // -------------------
-
-        /**
-         * This method should mutate the `parentInstance` and add the child to its list of children. For example, in the DOM this would translate to a `parentInstance.appendChild(child)` call.
-         *
-         * Although this method currently runs in the commit phase, you still should not mutate any other nodes in it. If you need to do some additional work when a node is definitely connected to the visible tree, look at `commitMount`.
-         */
-        appendChild?(parentInstance: Instance, child: Instance | TextInstance): void;
-
-        /**
-         * Same as `appendChild`, but for when a node is attached to the root container. This is useful if attaching to the root has a slightly different implementation, or if the root container nodes are of a different type than the rest of the tree.
-         */
-        appendChildToContainer?(container: Container, child: Instance | TextInstance): void;
-
-        /**
-         * This method should mutate the `parentInstance` and place the `child` before `beforeChild` in the list of its children. For example, in the DOM this would translate to a `parentInstance.insertBefore(child, beforeChild)` call.
-         *
-         * Note that React uses this method both for insertions and for reordering nodes. Similar to DOM, it is expected that you can call `insertBefore` to reposition an existing child. Do not mutate any other parts of the tree from it.
-         */
-        insertBefore?(
-            parentInstance: Instance,
-            child: Instance | TextInstance,
-            beforeChild: Instance | TextInstance | SuspenseInstance,
-        ): void;
-
-        /**
-         * Same as `insertBefore`, but for when a node is attached to the root container. This is useful if attaching to the root has a slightly different implementation, or if the root container nodes are of a different type than the rest of the tree.
-         */
-        insertInContainerBefore?(
-            container: Container,
-            child: Instance | TextInstance,
-            beforeChild: Instance | TextInstance | SuspenseInstance,
-        ): void;
-
-        /**
-         * This method should mutate the `parentInstance` to remove the `child` from the list of its children.
-         *
-         * React will only call it for the top-level node that is being removed. It is expected that garbage collection would take care of the whole subtree. You are not expected to traverse the child tree in it.
-         */
-        removeChild?(parentInstance: Instance, child: Instance | TextInstance | SuspenseInstance): void;
-
-        /**
-         * Same as `removeChild`, but for when a node is detached from the root container. This is useful if attaching to the root has a slightly different implementation, or if the root container nodes are of a different type than the rest of the tree.
-         */
-        removeChildFromContainer?(container: Container, child: Instance | TextInstance | SuspenseInstance): void;
-
-        /**
-         * If you returned `true` from `shouldSetTextContent` for the previous props, but returned `false` from `shouldSetTextContent` for the next props, React will call this method so that you can clear the text content you were managing manually. For example, in the DOM you could set `node.textContent = ''`.
-         *
-         * If you never return `true` from `shouldSetTextContent`, you can leave it empty.
-         */
-        resetTextContent?(instance: Instance): void;
-
-        /**
-         * This method should mutate the `textInstance` and update its text content to `nextText`.
-         *
-         * Here, `textInstance` is a node created by `createTextInstance`.
-         */
-        commitTextUpdate?(textInstance: TextInstance, oldText: string, newText: string): void;
-
-        /**
-         * This method is only called if you returned `true` from `finalizeInitialChildren` for this instance.
-         *
-         * It lets you do some additional work after the node is actually attached to the tree on the screen for the first time. For example, the DOM renderer uses it to trigger focus on nodes with the `autoFocus` attribute.
-         *
-         * Note that `commitMount` does not mirror `removeChild` one to one because `removeChild` is only called for the top-level removed node. This is why ideally `commitMount` should not mutate any nodes other than the `instance` itself. For example, if it registers some events on some node above, it will be your responsibility to traverse the tree in `removeChild` and clean them up, which is not ideal.
-         *
-         * The `internalHandle` data structure is meant to be opaque. If you bend the rules and rely on its internal fields, be aware that it may change significantly between versions. You're taking on additional maintenance risk by reading from it, and giving up all guarantees if you write something to it.
-         *
-         * If you never return `true` from `finalizeInitialChildren`, you can leave it empty.
-         */
-        commitMount?(instance: Instance, type: Type, props: Props, internalInstanceHandle: OpaqueHandle): void;
-
-        /**
-         * This method should mutate the instance to match nextProps.
-         *
-         * The internalHandle data structure is meant to be opaque. If you bend the rules and rely on its internal fields, be aware that it may change significantly between versions. You're taking on additional maintenance risk by reading from it, and giving up all guarantees if you write something to it.
-         */
-        commitUpdate?(
-            instance: Instance,
-            type: Type,
-            prevProps: Props,
-            nextProps: Props,
-            internalHandle: OpaqueHandle,
-        ): void;
-
-        /**
-         * This method should make the `instance` invisible without removing it from the tree. For example, it can apply visual styling to hide it. It is used by Suspense to hide the tree while the fallback is visible.
-         */
-        hideInstance?(instance: Instance): void;
-
-        /**
-         * Same as `hideInstance`, but for nodes created by `createTextInstance`.
-         */
-        hideTextInstance?(textInstance: TextInstance): void;
-
-        /**
-         * This method should make the `instance` visible, undoing what `hideInstance` did.
-         */
-        unhideInstance?(instance: Instance, props: Props): void;
-
-        /**
-         * Same as `unhideInstance`, but for nodes created by `createTextInstance`.
-         */
-        unhideTextInstance?(textInstance: TextInstance, text: string): void;
-
-        /**
-         * This method should mutate the `container` root node and remove all children from it.
-         */
-        clearContainer?(container: Container): void;
-
-        // -------------------
-        // Persistence Methods
-        //    (optional)
-        //  If you use the persistent mode instead of the mutation mode, you would still need the "Core Methods". However, instead of the Mutation Methods above you will implement a different set of methods that performs cloning nodes and replacing them at the root level. You can find a list of them in the "Persistence" section [listed in this file](https://github.com/facebook/react/blob/master/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js). File an issue if you need help.
-        // -------------------
-        cloneInstance?(
-            instance: Instance,
-            type: Type,
-            oldProps: Props,
-            newProps: Props,
-            keepChildren: boolean,
-            recyclableInstance: null | Instance,
-        ): Instance;
-        createContainerChildSet?(container: Container): ChildSet;
-        appendChildToContainerChildSet?(childSet: ChildSet, child: Instance | TextInstance): void;
-        finalizeContainerChildren?(container: Container, newChildren: ChildSet): void;
-        replaceContainerChildren?(container: Container, newChildren: ChildSet): void;
-        cloneHiddenInstance?(
-            instance: Instance,
-            type: Type,
-            props: Props,
-            internalInstanceHandle: OpaqueHandle,
-        ): Instance;
-        cloneHiddenTextInstance?(instance: Instance, text: Type, internalInstanceHandle: OpaqueHandle): TextInstance;
-
-        // -------------------
-        // Hydration Methods
-        //    (optional)
-        // You can optionally implement hydration to "attach" to the existing tree during the initial render instead of creating it from scratch. For example, the DOM renderer uses this to attach to an HTML markup.
-        //
-        // To support hydration, you need to declare `supportsHydration: true` and then implement the methods in the "Hydration" section [listed in this file](https://github.com/facebook/react/blob/master/packages/react-reconciler/src/forks/ReactFiberConfig.custom.js). File an issue if you need help.
-        // -------------------
-        supportsHydration: boolean;
-
-        canHydrateInstance?(instance: HydratableInstance, type: Type, props: Props): null | Instance;
-
-        canHydrateTextInstance?(instance: HydratableInstance, text: string): null | TextInstance;
-
-        canHydrateSuspenseInstance?(instance: HydratableInstance): null | SuspenseInstance;
-
-        isSuspenseInstancePending?(instance: SuspenseInstance): boolean;
-
-        isSuspenseInstanceFallback?(instance: SuspenseInstance): boolean;
-
-        registerSuspenseInstanceRetry?(instance: SuspenseInstance, callback: () => void): void;
-
-        getNextHydratableSibling?(instance: HydratableInstance): null | HydratableInstance;
-
-        getFirstHydratableChild?(parentInstance: Container | Instance): null | HydratableInstance;
-
-        hydrateInstance?(
-            instance: Instance,
-            type: Type,
-            props: Props,
-            rootContainerInstance: Container,
-            hostContext: HostContext,
-            internalInstanceHandle: any,
-        ): null | any[];
-
-        hydrateTextInstance?(textInstance: TextInstance, text: string, internalInstanceHandle: any): boolean;
-
-        hydrateSuspenseInstance?(suspenseInstance: SuspenseInstance, internalInstanceHandle: any): void;
-
-        getNextHydratableInstanceAfterSuspenseInstance?(suspenseInstance: SuspenseInstance): null | HydratableInstance;
-
-        // Returns the SuspenseInstance if this node is a direct child of a
-        // SuspenseInstance. I.e. if its previous sibling is a Comment with
-        // SUSPENSE_x_START_DATA. Otherwise, null.
-        getParentSuspenseInstance?(targetInstance: any): null | SuspenseInstance;
-
-        commitHydratedContainer?(container: Container): void;
-
-        commitHydratedSuspenseInstance?(suspenseInstance: SuspenseInstance): void;
-
-        didNotMatchHydratedContainerTextInstance?(
-            parentContainer: Container,
-            textInstance: TextInstance,
-            text: string,
-        ): void;
-
-        didNotMatchHydratedTextInstance?(
-            parentType: Type,
-            parentProps: Props,
-            parentInstance: Instance,
-            textInstance: TextInstance,
-            text: string,
-        ): void;
-
-        didNotHydrateContainerInstance?(parentContainer: Container, instance: HydratableInstance): void;
-
-        didNotHydrateInstance?(
-            parentType: Type,
-            parentProps: Props,
-            parentInstance: Instance,
-            instance: HydratableInstance,
-        ): void;
-
-        didNotFindHydratableContainerInstance?(parentContainer: Container, type: Type, props: Props): void;
-
-        didNotFindHydratableContainerTextInstance?(parentContainer: Container, text: string): void;
-
-        didNotFindHydratableContainerSuspenseInstance?(parentContainer: Container): void;
-
-        didNotFindHydratableInstance?(
-            parentType: Type,
-            parentProps: Props,
-            parentInstance: Instance,
-            type: Type,
-            props: Props,
-        ): void;
-
-        didNotFindHydratableTextInstance?(
-            parentType: Type,
-            parentProps: Props,
-            parentInstance: Instance,
-            text: string,
-        ): void;
-
-        didNotFindHydratableSuspenseInstance?(parentType: Type, parentProps: Props, parentInstance: Instance): void;
-
-        errorHydratingContainer?(parentContainer: Container): void;
-
-        // Undocumented
-        // https://github.com/facebook/react/pull/26722
-        NotPendingTransition: TransitionStatus | null;
-        HostTransitionContext: ReactContext<TransitionStatus>;
-
-        // https://github.com/facebook/react/pull/28751
-        setCurrentUpdatePriority(newPriority: EventPriority): void;
-        getCurrentUpdatePriority(): EventPriority;
-        resolveUpdatePriority(): EventPriority;
-
-        // https://github.com/facebook/react/pull/28804
-        resetFormInstance(form: FormInstance): void;
-
-        // https://github.com/facebook/react/pull/25105
-        requestPostPaintCallback(callback: (time: number) => void): void;
-
-        // https://github.com/facebook/react/pull/26025
-        shouldAttemptEagerTransition(): boolean;
-
-        // https://github.com/facebook/react/pull/31528
-        trackSchedulerEvent(): void;
-
-        // https://github.com/facebook/react/pull/31008
-        resolveEventType(): null | string;
-        resolveEventTimeStamp(): number;
-
-        /**
-         * This method is called during render to determine if the Host Component type and props require some kind of loading process to complete before committing an update.
-         */
-        maySuspendCommit(type: Type, props: Props): boolean;
-
-        /**
-         * This method may be called during render if the Host Component type and props might suspend a commit. It can be used to initiate any work that might shorten the duration of a suspended commit.
-         */
-        preloadInstance(type: Type, props: Props): boolean;
-
-        /**
-         * This method is called just before the commit phase. Use it to set up any necessary state while any Host Components that might suspend this commit are evaluated to determine if the commit must be suspended.
-         */
-        startSuspendingCommit(): void;
-
-        /**
-         * This method is called after `startSuspendingCommit` for each Host Component that indicated it might suspend a commit.
-         */
-        suspendInstance(type: Type, props: Props): void;
-
-        /**
-         * This method is called after all `suspendInstance` calls are complete.
-         *
-         * Return `null` if the commit can happen immediately.
-         *
-         * Return `(initiateCommit: Function) => Function` if the commit must be suspended. The argument to this callback will initiate the commit when called. The return value is a cancellation function that the Reconciler can use to abort the commit.
-         */
-        waitForCommitToBeReady():
-            | ((initiateCommit: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown)
-            | null;
-    }
-
-    interface Thenable<T> {
-        then(resolve: () => T, reject?: () => T): T;
-    }
-
-    type RootTag = 0 | 1 | 2;
-
-    type WorkTag =
-        | 0
-        | 1
-        | 2
-        | 3
-        | 4
-        | 5
-        | 6
-        | 7
-        | 8
-        | 9
-        | 10
-        | 11
-        | 12
-        | 13
-        | 14
-        | 15
-        | 16
-        | 17
-        | 18
-        | 19
-        | 20
-        | 21
-        | 22
-        | 23
-        | 24;
-
-    type HookType =
-        | "useState"
-        | "useReducer"
-        | "useContext"
-        | "useRef"
-        | "useEffect"
-        | "useLayoutEffect"
-        | "useCallback"
-        | "useMemo"
-        | "useImperativeHandle"
-        | "useDebugValue"
-        | "useDeferredValue"
-        | "useTransition"
-        | "useMutableSource"
-        | "useOpaqueIdentifier"
-        | "useCacheRefresh";
-
-    interface Source {
-        fileName: string;
-        lineNumber: number;
-    }
-
-    // TODO: Ideally these types would be opaque but that doesn't work well with
-    // our reconciler fork infra, since these leak into non-reconciler packages.
-    type LanePriority = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17;
-
-    type Lanes = number;
-    type Lane = number;
-
-    type Flags = number;
-
-    type TypeOfMode = number;
-
-    type EventPriority = number;
-
-    interface ReactProvider<T> {
-        $$typeof: symbol | number;
-        type: ReactProviderType<T>;
-        key: null | string;
-        ref: null;
-        props: {
-            value: T;
-            children?: ReactNode;
-        };
-    }
-
-    interface ReactProviderType<T> {
-        $$typeof: symbol | number;
-        _context: ReactContext<T>;
-    }
-
-    interface ReactConsumer<T> {
-        $$typeof: symbol | number;
-        type: ReactContext<T>;
-        key: null | string;
-        ref: null;
-        props: {
-            children: (value: T) => ReactNode;
-            unstable_observedBits?: number;
-        };
-    }
-
-    interface ReactContext<T> {
-        $$typeof: symbol | number;
-        Consumer: ReactContext<T>;
-        Provider: ReactProviderType<T>;
-        _currentValue: T;
-        _currentValue2: T;
-        _threadCount: number;
-        // DEV only
-        _currentRenderer?: {
-            [key: string]: any;
-        } | null;
-        _currentRenderer2?: {
-            [key: string]: any;
-        } | null;
-        // This value may be added by application code
-        // to improve DEV tooling display names
-        displayName?: string;
-    }
-
-    interface ReactPortal {
-        $$typeof: symbol | number;
-        key: null | string;
-        containerInfo: any;
-        children: ReactNode;
-        // TODO: figure out the API for cross-renderer implementation.
-        implementation: any;
-    }
-
-    interface RefObject {
-        current: any;
-    }
-
-    interface ContextDependency<T> {
-        context: ReactContext<T>;
-        observedBits: number;
-        next: ContextDependency<unknown> | null;
-    }
-
-    interface Dependencies {
-        lanes: Lanes;
-        firstContext: ContextDependency<unknown> | null;
-    }
-
-    interface Fiber {
-        // These first fields are conceptually members of an Instance. This used to
-        // be split into a separate type and intersected with the other Fiber fields,
-        // but until Flow fixes its intersection bugs, we've merged them into a
-        // single type.
-
-        // An Instance is shared between all versions of a component. We can easily
-        // break this out into a separate object to avoid copying so much to the
-        // alternate versions of the tree. We put this on a single object for now to
-        // minimize the number of objects created during the initial render.
-
-        // Tag identifying the type of fiber.
-        tag: WorkTag;
-
-        // Unique identifier of this child.
-        key: null | string;
-
-        // The value of element.type which is used to preserve the identity during
-        // reconciliation of this child.
-        elementType: any;
-
-        // The resolved function/class/ associated with this fiber.
-        type: any;
-
-        // The local state associated with this fiber.
-        stateNode: any;
-
-        // Conceptual aliases
-        // parent : Instance -> return The parent happens to be the same as the
-        // return fiber since we've merged the fiber and instance.
-
-        // Remaining fields belong to Fiber
-
-        // The Fiber to return to after finishing processing this one.
-        // This is effectively the parent, but there can be multiple parents (two)
-        // so this is only the parent of the thing we're currently processing.
-        // It is conceptually the same as the return address of a stack frame.
-        return: Fiber | null;
-
-        // Singly Linked List Tree Structure.
-        child: Fiber | null;
-        sibling: Fiber | null;
-        index: number;
-
-        // The ref last used to attach this node.
-        // I'll avoid adding an owner field for prod and model that as functions.
-        ref:
-            | null
-            | (((handle: unknown) => void) & {
-                _stringRef?: string | null;
-            })
-            | RefObject;
-
-        // Input is the data coming into process this fiber. Arguments. Props.
-        pendingProps: any; // This type will be more specific once we overload the tag.
-        memoizedProps: any; // The props used to create the output.
-
-        // A queue of state updates and callbacks.
-        updateQueue: unknown;
-
-        // The state used to create the output
-        memoizedState: any;
-
-        // Dependencies (contexts, events) for this fiber, if it has any
-        dependencies: Dependencies | null;
-
-        // Bitfield that describes properties about the fiber and its subtree. E.g.
-        // the ConcurrentMode flag indicates whether the subtree should be async-by-
-        // default. When a fiber is created, it inherits the mode of its
-        // parent. Additional flags can be set at creation time, but after that the
-        // value should remain unchanged throughout the fiber's lifetime, particularly
-        // before its child fibers are created.
-        mode: TypeOfMode;
-
-        // Effect
-        flags: Flags;
-        subtreeFlags: Flags;
-        deletions: Fiber[] | null;
-
-        // Singly linked list fast path to the next fiber with side-effects.
-        nextEffect: Fiber | null;
-
-        // The first and last fiber with side-effect within this subtree. This allows
-        // us to reuse a slice of the linked list when we reuse the work done within
-        // this fiber.
-        firstEffect: Fiber | null;
-        lastEffect: Fiber | null;
-
-        lanes: Lanes;
-        childLanes: Lanes;
-
-        // This is a pooled version of a Fiber. Every fiber that gets updated will
-        // eventually have a pair. There are cases when we can clean up pairs to save
-        // memory if we need to.
-        alternate: Fiber | null;
-
-        // Time spent rendering this Fiber and its descendants for the current update.
-        // This tells us how well the tree makes use of sCU for memoization.
-        // It is reset to 0 each time we render and only updated when we don't bailout.
-        // This field is only set when the enableProfilerTimer flag is enabled.
-        actualDuration?: number;
-
-        // If the Fiber is currently active in the "render" phase,
-        // This marks the time at which the work began.
-        // This field is only set when the enableProfilerTimer flag is enabled.
-        actualStartTime?: number;
-
-        // Duration of the most recent render time for this Fiber.
-        // This value is not updated when we bailout for memoization purposes.
-        // This field is only set when the enableProfilerTimer flag is enabled.
-        selfBaseDuration?: number;
-
-        // Sum of base times for all descendants of this Fiber.
-        // This value bubbles up during the "complete" phase.
-        // This field is only set when the enableProfilerTimer flag is enabled.
-        treeBaseDuration?: number;
-
-        // Conceptual aliases
-        // workInProgress : Fiber ->  alternate The alternate used for reuse happens
-        // to be the same as work in progress.
-        // __DEV__ only
-        _debugID?: number;
-        _debugSource?: Source | null;
-        _debugOwner?: Fiber | null;
-        _debugIsCurrentlyTiming?: boolean;
-        _debugNeedsRemount?: boolean;
-
-        // Used to verify that the order of hooks does not change between renders.
-        _debugHookTypes?: HookType[] | null;
-    }
-
-    type FiberRoot = any;
-
-    // Concurrent related struct
-    type MutableSource = any;
-
-    type OpaqueHandle = any;
-    type OpaqueRoot = any;
-
-    // 0 is PROD, 1 is DEV.
-    // Might add PROFILE later.
-    type BundleType = 0 | 1;
-
-    interface DevToolsConfig<Instance, TextInstance, RendererInspectionConfig> {
-        bundleType: BundleType;
-        version: string;
-        rendererPackageName: string;
-        // Note: this actually *does* depend on Fiber internal fields.
-        // Used by "inspect clicked DOM element" in React DevTools.
-        findFiberByHostInstance?: (instance: Instance | TextInstance) => Fiber | null;
-        rendererConfig?: RendererInspectionConfig;
-    }
-
-    interface SuspenseHydrationCallbacks<SuspenseInstance> {
-        onHydrated?: (suspenseInstance: SuspenseInstance) => void;
-        onDeleted?: (suspenseInstance: SuspenseInstance) => void;
-    }
-
-    interface TransitionTracingCallbacks {
-        onTransitionStart?: (transitionName: string, startTime: number) => void;
-        onTransitionProgress?: (
-            transitionName: string,
-            startTime: number,
-            currentTime: number,
-            pending: Array<{ name: null | string }>,
-        ) => void;
-        onTransitionIncomplete?: (
-            transitionName: string,
-            startTime: number,
-            deletions: Array<{
-                type: string;
-                name?: string;
-                newName?: string;
-                endTime: number;
-            }>,
-        ) => void;
-        onTransitionComplete?: (transitionName: string, startTime: number, endTime: number) => void;
-        onMarkerProgress?: (
-            transitionName: string,
-            marker: string,
-            startTime: number,
-            currentTime: number,
-            pending: Array<{ name: null | string }>,
-        ) => void;
-        onMarkerIncomplete?: (
-            transitionName: string,
-            marker: string,
-            startTime: number,
-            deletions: Array<{
-                type: string;
-                name?: string;
-                newName?: string;
-                endTime: number;
-            }>,
-        ) => void;
-        onMarkerComplete?: (transitionName: string, marker: string, startTime: number, endTime: number) => void;
-    }
-
-    interface ComponentSelector {
-        $$typeof: symbol | number;
-        value: React$AbstractComponent<never, unknown>;
-    }
-
-    interface HasPseudoClassSelector {
-        $$typeof: symbol | number;
-        value: Selector[];
-    }
-
-    interface RoleSelector {
-        $$typeof: symbol | number;
-        value: string;
-    }
-
-    interface TextSelector {
-        $$typeof: symbol | number;
-        value: string;
-    }
-
-    interface TestNameSelector {
-        $$typeof: symbol | number;
-        value: string;
-    }
-
-    type Selector = ComponentSelector | HasPseudoClassSelector | RoleSelector | TextSelector | TestNameSelector;
-
-    // TODO can not find React$AbstractComponent def
-    type React$AbstractComponent<Config, Instance = any> = any;
-
-    interface BoundingRect {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    }
-
-    type IntersectionObserverOptions = any;
-
-    interface BaseErrorInfo {
-        componentStack?: string;
-    }
-
-    interface Reconciler<Container, Instance, TextInstance, SuspenseInstance, FormInstance, PublicInstance> {
-        createContainer(
-            containerInfo: Container,
-            tag: RootTag,
-            hydrationCallbacks: null | SuspenseHydrationCallbacks<SuspenseInstance>,
-            isStrictMode: boolean,
-            concurrentUpdatesByDefaultOverride: null | boolean,
-            identifierPrefix: string,
-            onUncaughtError: (error: Error, info: BaseErrorInfo & { errorBoundary?: Component }) => void,
-            onCaughtError: (error: Error, info: BaseErrorInfo) => void,
-            onRecoverableError: (error: Error, info: BaseErrorInfo) => void,
-            onDefaultTransitionIndicator: () => void,
-            transitionCallbacks: null | TransitionTracingCallbacks,
-        ): OpaqueRoot;
-
-        createPortal(
-            children: ReactNode,
-            containerInfo: any, // TODO: figure out the API for cross-renderer implementation.
-            implementation: any,
-            key?: string | null,
-        ): ReactPortal;
-
-        registerMutableSourceForHydration(root: FiberRoot, mutableSource: MutableSource): void;
-
-        createComponentSelector(component: React$AbstractComponent<never, unknown>): ComponentSelector;
-
-        createHasPseudoClassSelector(selectors: Selector[]): HasPseudoClassSelector;
-
-        createRoleSelector(role: string): RoleSelector;
-
-        createTextSelector(text: string): TextSelector;
-
-        createTestNameSelector(id: string): TestNameSelector;
-
-        getFindAllNodesFailureDescription(hostRoot: Instance, selectors: Selector[]): string | null;
-
-        findAllNodes(hostRoot: Instance, selectors: Selector[]): Instance[];
-
-        findBoundingRects(hostRoot: Instance, selectors: Selector[]): BoundingRect[];
-
-        focusWithin(hostRoot: Instance, selectors: Selector[]): boolean;
-
-        observeVisibleRects(
-            hostRoot: Instance,
-            selectors: Selector[],
-            callback: (intersections: Array<{ ratio: number; rect: BoundingRect }>) => void,
-            options?: IntersectionObserverOptions,
-        ): { disconnect: () => void };
-
-        createHydrationContainer(
-            initialChildren: ReactNode,
-            callback: (() => void) | null | undefined,
-            containerInfo: Container,
-            tag: RootTag,
-            hydrationCallbacks: null | SuspenseHydrationCallbacks<SuspenseInstance>,
-            isStrictMode: boolean,
-            concurrentUpdatesByDefaultOverride: null | boolean,
-            identifierPrefix: string,
-            onRecoverableError: (error: Error) => void,
-            transitionCallbacks: null | TransitionTracingCallbacks,
-        ): OpaqueRoot;
-
-        updateContainer(
-            element: ReactNode,
-            container: OpaqueRoot,
-            parentComponent?: Component<any, any> | null,
-            callback?: (() => void) | null,
-        ): Lane;
-
-        batchedUpdates<A, R>(fn: (a: A) => R, a: A): R;
-
-        deferredUpdates<A>(fn: () => A): A;
-
-        discreteUpdates<A, B, C, D, R>(fn: (arg0: A, arg1: B, arg2: C, arg3: D) => R, a: A, b: B, c: C, d: D): R;
-
-        flushControlled(fn: () => any): void;
-
-        flushSync(): void;
-        flushSync<R>(fn: () => R): R;
-
-        isAlreadyRendering(): boolean;
-
-        flushPassiveEffects(): boolean;
-
-        getPublicRootInstance(container: OpaqueRoot): Component<any, any> | PublicInstance | null;
-
-        attemptSynchronousHydration(fiber: Fiber): void;
-
-        attemptDiscreteHydration(fiber: Fiber): void;
-
-        attemptContinuousHydration(fiber: Fiber): void;
-
-        attemptHydrationAtCurrentPriority(fiber: Fiber): void;
-
-        getCurrentUpdatePriority(): LanePriority;
-
-        runWithPriority<T>(priority: LanePriority, fn: () => T): T;
-
-        findHostInstance(component: any): PublicInstance | null;
-
-        findHostInstanceWithWarning(component: any, methodName: string): PublicInstance | null;
-
-        findHostInstanceWithNoPortals(fiber: Fiber): PublicInstance | null;
-
-        shouldError(fiber: Fiber): boolean | undefined;
-
-        shouldSuspend(fiber: Fiber): boolean;
-
-        injectIntoDevTools(devToolsConfig: DevToolsConfig<Instance, TextInstance, any>): boolean;
-    }
-}
-
-declare function extend<T extends ConstructorRepresentation>(objects: T): React$1.ExoticComponent<ThreeElement<T>>;
-declare function extend<T extends Catalogue>(objects: T): void;
-declare const reconciler: ReactReconciler.Reconciler<RootStore, Instance<any>, void, Instance<any>, never, any>;
-
-declare const isRenderer: (def: any) => boolean;
-interface OffscreenCanvas extends EventTarget {
-}
-declare const _roots: Map<HTMLCanvasElement | OffscreenCanvas, Root>;
-declare function createRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
-declare function unmountComponentAtNode<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
-declare function createPortal(children: ReactNode, container: Object3D | RefObject<Object3D | null> | RefObject<Object3D>, state?: InjectState): JSX.Element;
-interface PortalProps {
-    children: ReactNode;
-    state?: InjectState;
-    container: Object3D | RefObject<Object3D | null> | RefObject<Object3D>;
-}
-declare function Portal({ children, container, state }: PortalProps): JSX.Element;
-/**
- * Force React to flush any updates inside the provided callback synchronously and immediately.
- * All the same caveats documented for react-dom's `flushSync` apply here (see https://react.dev/reference/react-dom/flushSync).
- * Nevertheless, sometimes one needs to render synchronously, for example to keep DOM and 3D changes in lock-step without
- * having to revert to a non-React solution. Note: this will only flush updates within the `Canvas` root.
- */
-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.
- *
- * React currently throws a warning when using useLayoutEffect on the server.
- * To get around it, we can conditionally useEffect on the server (no-op) and
- * useLayoutEffect elsewhere.
- *
- * @see https://github.com/facebook/react/issues/14927
- */
-declare const useIsomorphicLayoutEffect: typeof React$1.useLayoutEffect;
-/**
- * Creates a stable ref that always contains the latest callback.
- * Useful for avoiding dependency arrays while ensuring the latest closure is called.
- *
- * @param fn - The callback function to wrap
- * @returns A ref containing the current callback
- */
-declare function useMutableCallback<T>(fn: T): React$1.RefObject<T>;
-/**
- * Bridges renderer Context and StrictMode from a primary renderer.
- * Used to maintain React context when rendering into portals or secondary canvases.
- *
- * @returns A Bridge component that wraps children with the parent renderer's context
- */
-declare function useBridge(): Bridge;
-/**
- * Internal component that blocks rendering until a promise resolves.
- * Used for suspense-like blocking behavior.
- *
- * @param set - Function to set the blocking promise
- */
-declare function Block({ set }: Omit<UnblockProps, 'children'>): null;
-/**
- * Error boundary component for catching and handling errors in the React tree.
- * Forwards errors to a state setter for external handling.
- *
- * NOTE: static members get down-level transpiled to mutations which break tree-shaking
- */
-declare const ErrorBoundary: {
-    new (props: {
-        set: React$1.Dispatch<Error | undefined>;
-        children: React$1.ReactNode;
-    }): {
-        state: {
-            error: boolean;
-        };
-        componentDidCatch(err: Error): void;
-        render(): React$1.ReactNode;
-        context: unknown;
-        setState<K extends "error">(state: {
-            error: boolean;
-        } | ((prevState: Readonly<{
-            error: boolean;
-        }>, props: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>) => {
-            error: boolean;
-        } | Pick<{
-            error: boolean;
-        }, K> | null) | Pick<{
-            error: boolean;
-        }, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>;
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, prevState: Readonly<{
-            error: boolean;
-        }>): any;
-        componentDidUpdate?(prevProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, prevState: Readonly<{
-            error: boolean;
-        }>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-    };
-    new (props: {
-        set: React$1.Dispatch<Error | undefined>;
-        children: React$1.ReactNode;
-    }, context: any): {
-        state: {
-            error: boolean;
-        };
-        componentDidCatch(err: Error): void;
-        render(): React$1.ReactNode;
-        context: unknown;
-        setState<K extends "error">(state: {
-            error: boolean;
-        } | ((prevState: Readonly<{
-            error: boolean;
-        }>, props: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>) => {
-            error: boolean;
-        } | Pick<{
-            error: boolean;
-        }, K> | null) | Pick<{
-            error: boolean;
-        }, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>;
-        componentDidMount?(): void;
-        shouldComponentUpdate?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): boolean;
-        componentWillUnmount?(): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, prevState: Readonly<{
-            error: boolean;
-        }>): any;
-        componentDidUpdate?(prevProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, prevState: Readonly<{
-            error: boolean;
-        }>, snapshot?: any): void;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
-            set: React$1.Dispatch<Error | undefined>;
-            children: React$1.ReactNode;
-        }>, nextState: Readonly<{
-            error: boolean;
-        }>, nextContext: any): void;
-    };
-    getDerivedStateFromError: () => {
-        error: boolean;
-    };
-    contextType?: React$1.Context<any> | undefined;
-    propTypes?: any;
-};
-
-/**
- * React internal props that should not be passed to Three.js objects.
- */
-declare const REACT_INTERNAL_PROPS: string[];
-/**
- * Returns the instance's initial (outermost) root.
- * Traverses through previousRoot links to find the original root store.
- *
- * @param instance - R3F instance to find root for
- * @returns The outermost root store
- */
-declare function findInitialRoot<T>(instance: Instance<T>): RootStore;
-/**
- * Returns instance root state.
- * If the object doesn't have __r3f (e.g., child meshes in primitives/GLTFs),
- * traverses ancestors to find the nearest managed parent.
- *
- * @param obj - Three.js object to get root state for
- * @returns Root state if found, undefined otherwise
- */
-declare function getRootState<T extends Object3D = Object3D>(obj: T): RootState | undefined;
-/**
- * Collects nodes, materials, and meshes from a Three.js Object3D hierarchy.
- * Handles duplicate material names by appending UUID prefixes.
- *
- * @param object - Root object to traverse
- * @returns ObjectMap containing named nodes, materials, and meshes
- *
- * @example
- * const { nodes, materials, meshes } = buildGraph(gltf.scene)
- * // Access by name: nodes.Head, materials.Metal, meshes.Body
- */
-declare function buildGraph(object: Object3D): ObjectMap;
-/**
- * Disposes an object and all its disposable properties.
- * Skips Scene objects as they should not be disposed automatically.
- *
- * @param obj - Object to dispose
- */
-declare function dispose<T extends Disposable>(obj: T): void;
-/**
- * Extracts instance props from React reconciler fiber props.
- * Filters out React-internal props (children, key, ref).
- *
- * @param queue - Pending props from reconciler fiber
- * @returns Props object without React-internal keys
- */
-declare function getInstanceProps<T = any>(pendingProps: Record<string, unknown>): Instance<T>['props'];
-/**
- * Creates or retrieves an R3F instance descriptor for a Three.js object.
- * Each object in the scene carries a LocalState descriptor (__r3f).
- *
- * @param target - Target object to prepare
- * @param root - Root store for this instance
- * @param type - String identifier for the object type
- * @param props - Initial props for the instance
- * @returns Instance descriptor
- */
-declare function prepare<T = any>(target: T, root: RootStore, type: string, props: Instance<T>['props']): Instance<T>;
-/**
- * Triggers an update for an instance.
- * Calls onUpdate callback and invalidates the frame if necessary.
- *
- * @param instance - Instance to invalidate
- */
-declare function invalidateInstance(instance: Instance): void;
-
-/**
- * Reserved prop names that should not be applied to Three.js objects.
- */
-declare const RESERVED_PROPS: string[];
-/**
- * Resolves a potentially pierced property key (e.g., 'material-color' → material.color).
- * First tries the entire key as a single property, then attempts piercing.
- *
- * @param root - Root object to resolve from
- * @param key - Property key (may contain dashes for piercing)
- * @returns Object containing root, key, and target value
- *
- * @example
- * resolve(mesh, 'material-color')
- * // => { root: mesh.material, key: 'color', target: mesh.material.color }
- */
-declare function resolve(root: any, key: string): {
-    root: any;
-    key: string;
-    target: any;
-};
-/**
- * Attaches a child instance to a parent instance.
- * Handles both string-based attachment (e.g., 'geometry', 'material-map')
- * and function-based attachment for custom logic.
- *
- * @param parent - Parent instance
- * @param child - Child instance to attach
- *
- * @example
- * // String attachment
- * <bufferGeometry attach="geometry" />
- * // Array attachment
- * <light attach="lights-0" />
- * // Function attachment
- * <thing attach={(parent, self) => { parent.customProp = self }} />
- */
-declare function attach(parent: Instance, child: Instance): void;
-/**
- * Detaches a child instance from a parent instance.
- * Restores the previous value or deletes the property if it was never set.
- *
- * @param parent - Parent instance
- * @param child - Child instance to detach
- */
-declare function detach(parent: Instance, child: Instance): void;
-/**
- * Compares old and new props to determine which properties have changed.
- * Also handles resetting removed props for HMR/fast-refresh.
- *
- * @param instance - Instance to diff props for
- * @param newProps - New props to compare against
- * @returns Object containing only changed props
- *
- * @example
- * const changes = diffProps(instance, { position: [1, 2, 3], color: 'red' })
- * // => { position: [1, 2, 3] } (only if position changed)
- */
-declare function diffProps<T = any>(instance: Instance<T>, newProps: Instance<T>['props']): Instance<T>['props'];
-/**
- * Applies a set of props to a Three.js object.
- * Handles special cases like colors, vectors, textures, events, and pierced props.
- *
- * @param object - Three.js object to apply props to
- * @param props - Props to apply
- * @returns The object with props applied
- *
- * @example
- * applyProps(mesh, { position: [0, 1, 0], 'material-color': 'red' })
- */
-declare function applyProps<T = any>(object: Instance<T>['object'], props: Instance<T>['props']): Instance<T>['object'];
-
-/**
- * Calculates the device pixel ratio for rendering.
- * Handles array DPR ranges [min, max] to clamp devicePixelRatio.
- *
- * @param dpr - Target DPR value or [min, max] range
- * @returns Calculated DPR value
- *
- * @example
- * calculateDpr(2) // => 2
- * calculateDpr([1, 2]) // => clamps window.devicePixelRatio between 1 and 2
- */
-declare function calculateDpr(dpr: Dpr): number;
-/**
- * Extracts the first segment of a UUID string (before the first hyphen).
- * Used for creating unique material names when duplicates exist.
- *
- * @param uuid - UUID string to extract prefix from
- * @returns First segment of the UUID
- *
- * @example
- * getUuidPrefix('a1b2c3d4-e5f6-g7h8-i9j0') // => 'a1b2c3d4'
- */
-declare function getUuidPrefix(uuid: string): string;
-/**
- * Updates camera projection based on viewport size.
- * Adjusts aspect ratio for perspective cameras or bounds for orthographic cameras.
- * Respects camera.manual flag - manual cameras are not modified.
- *
- * @param camera - Camera to update
- * @param size - Current viewport size
- */
-declare function updateCamera(camera: ThreeCamera, size: Size): void;
-/**
- * Updates a frustum from a camera's projection and world matrices.
- * If no target frustum is provided, creates and returns a new one.
- *
- * @param camera - Camera to extract frustum from
- * @param frustum - Optional existing frustum to update (creates new if not provided)
- * @returns The updated or newly created frustum
- *
- * @example
- * // Create new frustum
- * const frustum = updateFrustum(camera)
- *
- * // Update existing frustum (no allocation)
- * updateFrustum(camera, existingFrustum)
- *
- * // Use for visibility checks
- * if (frustum.containsPoint(point)) { ... }
- * if (frustum.intersectsObject(mesh)) { ... }
- */
-declare function updateFrustum(camera: ThreeCamera, frustum?: Frustum): Frustum;
-
-declare const is: {
-    obj: (a: any) => boolean;
-    fun: (a: any) => a is Function;
-    str: (a: any) => a is string;
-    num: (a: any) => a is number;
-    boo: (a: any) => a is boolean;
-    und: (a: any) => boolean;
-    nul: (a: any) => boolean;
-    arr: (a: any) => a is any[];
-    equ(a: any, b: any, { arrays, objects, strict }?: EquConfig): boolean;
-};
-declare const isOrthographicCamera: (def: ThreeCamera) => def is OrthographicCamera;
-declare const isRef: (obj: unknown) => obj is React.RefObject<unknown>;
-declare const isColorRepresentation: (value: unknown) => value is ColorRepresentation$1;
-declare const isObject3D: (object: any) => object is Object3D;
-declare const isTexture: (value: unknown) => value is Texture$1;
-type VectorLike = {
-    set: (...args: any[]) => void;
-    constructor?: Function;
-};
-declare const isVectorLike: (object: unknown) => object is VectorLike;
-type Copyable = {
-    copy: (...args: any[]) => void;
-    constructor?: Function;
-};
-declare const isCopyable: (object: unknown) => object is Copyable;
-declare const hasConstructor: (object: unknown) => object is {
-    constructor?: Function;
-};
-
-/**
- * Symbol marker for deferred ref resolution.
- * Used to identify values that should be resolved from refs after mount.
- */
-declare const FROM_REF: unique symbol;
-/**
- * Defers prop application until the referenced object is available.
- * Useful for props like `target` that need sibling refs to be populated.
- *
- * @param ref - React ref object to resolve at mount time
- * @returns A marker value that applyProps will resolve after mount
- *
- * @example
- * const targetRef = useRef<THREE.Object3D>(null)
- *
- * <group ref={targetRef} position={[-3, -2, -15]} />
- * <spotLight target={fromRef(targetRef)} intensity={100} />
- */
-declare function fromRef<T>(ref: React$1.RefObject<T | null>): T;
-/**
- * Type guard to check if a value is a fromRef marker.
- *
- * @param value - Value to check
- * @returns True if value is a fromRef marker
- */
-declare function isFromRef(value: unknown): value is {
-    [FROM_REF]: React$1.RefObject<any>;
-};
-
-/**
- * Symbol marker for mount-only method calls.
- * Used to identify methods that should only be called once on initial mount.
- */
-declare const ONCE: unique symbol;
-/**
- * Marks a method call to be executed only on initial mount.
- * Useful for geometry transforms that should not be reapplied on every render.
- *
- * When `args` prop changes (triggering reconstruction), the method will be
- * called again on the new instance since appliedOnce is not carried over.
- *
- * @param args - Arguments to pass to the method
- * @returns A marker value that applyProps will execute once
- *
- * @example
- * // Rotate geometry on mount
- * <boxGeometry args={[1, 1, 1]} rotateX={once(Math.PI / 2)} />
- *
- * // Multiple arguments
- * <bufferGeometry applyMatrix4={once(matrix)} />
- *
- * // No arguments
- * <geometry center={once()} />
- */
-declare function once<T>(...args: T[]): T;
-/**
- * Type guard to check if a value is a once marker.
- *
- * @param value - Value to check
- * @returns True if value is a once marker
- */
-declare function isOnce(value: unknown): value is {
-    [ONCE]: any[] | true;
-};
-
-/**
- * A DOM canvas which accepts threejs elements as children.
- * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
- */
-declare function Canvas(props: CanvasProps): react_jsx_runtime.JSX.Element;
-
-/**
- * ScopedStore - Type-safe wrapper for nested stores (uniforms, nodes)
- *
- * Provides TypeScript-friendly access to uniform/node stores where the runtime
- * structure is `Record<string, T | Record<string, T>>` (leaf nodes or nested scopes).
- *
- * The wrapper uses a Proxy to:
- * 1. Return `T` for property access (type assumption: assumes leaf node)
- * 2. Provide `.scope(key)` method for explicit nested access
- * 3. Support iteration methods: has(), keys(), Object.keys(), for...in
- *
- * @example
- * ```tsx
- * useLocalNodes(({ uniforms }) => ({
- *   wobble: sin(uniforms.uTime.mul(2)),           // No cast needed!
- *   playerHealth: uniforms.scope('player').uHealth // Explicit scope access
- * }))
- * ```
- */
-
-/** Keys reserved for methods (excluded from index signature) */
-type MethodKeys = 'scope' | 'has' | 'keys';
-/**
- * Type-safe wrapper interface for accessing nested store data.
- * Property access returns `T` (assumes leaf node).
- * Use `.scope(key)` for nested object access.
- *
- * Uses mapped type with key filtering to exclude method names from index signature,
- * allowing methods to have their correct return types.
- */
-type ScopedStoreType<T> = {
-    /** Direct property access returns the leaf type T (method keys excluded) */
-    readonly [K in string as K extends MethodKeys ? never : K]: T;
-} & {
-    /** Access a nested scope by key. Returns empty wrapper if scope doesn't exist. */
-    scope(key: string): ScopedStoreType<T>;
-    /** Check if a key exists in the store */
-    has(key: string): boolean;
-    /** Get all keys in the store */
-    keys(): string[];
-};
-/**
- * Create a type-safe ScopedStore wrapper around store data.
- * @param data - The raw store data (uniforms or nodes from RootState)
- * @returns A ScopedStoreType wrapper with type-safe access
- */
-declare function createScopedStore<T>(data: Record<string, any>): ScopedStoreType<T>;
-/**
- * State type passed to creator functions with ScopedStore wrappers.
- * Provides type-safe access to uniforms and nodes without manual casting.
- */
-type CreatorState = Omit<RootState, 'uniforms' | 'nodes'> & {
-    /** Type-safe uniform access - property access returns UniformNode */
-    uniforms: ScopedStoreType<UniformNode>;
-    /** Type-safe node access - property access returns TSLNodeType (Node | ShaderCallable | ShaderNodeObject) */
-    nodes: ScopedStoreType<TSLNodeType>;
-};
-
-/** Creator function that returns uniform inputs (can be raw values or UniformNodes) */
-type UniformCreator<T extends UniformInputRecord = UniformInputRecord> = (state: CreatorState) => T;
-/** Function signature for removeUniforms util */
-type RemoveUniformsFn = (names: string | string[], scope?: string) => void;
-/** Function signature for clearUniforms util */
-type ClearUniformsFn = (scope?: string) => void;
-/** Function signature for rebuildUniforms util */
-type RebuildUniformsFn = (scope?: string) => void;
-/** Return type with utils included */
-type UniformsWithUtils<T extends UniformRecord = UniformRecord> = T & {
-    removeUniforms: RemoveUniformsFn;
-    clearUniforms: ClearUniformsFn;
-    rebuildUniforms: RebuildUniformsFn;
-};
-declare function useUniforms(): UniformsWithUtils<UniformRecord & Record<string, UniformRecord>>;
-declare function useUniforms(scope: string): UniformsWithUtils;
-declare function useUniforms<T extends UniformInputRecord>(creator: UniformCreator<T>): UniformsWithUtils<UniformRecord<UniformNode>>;
-declare function useUniforms<T extends UniformInputRecord>(creator: UniformCreator<T>, scope: string): UniformsWithUtils<UniformRecord<UniformNode>>;
-declare function useUniforms<T extends UniformInputRecord>(uniforms: T): UniformsWithUtils<UniformRecord<UniformNode>>;
-declare function useUniforms<T extends UniformInputRecord>(uniforms: T, scope: string): UniformsWithUtils<UniformRecord<UniformNode>>;
-/**
- * Global rebuildUniforms function for HMR integration.
- * Clears cached uniforms and increments _hmrVersion to trigger re-creation.
- * Call this when HMR is detected to refresh all uniform creators.
- *
- * @param store - The R3F store (from useStore or context)
- * @param scope - Optional scope to rebuild ('root' for root only, string for specific scope, undefined for all)
- */
-declare function rebuildAllUniforms(store: ReturnType<typeof useStore>, scope?: string): void;
-/**
- * Remove uniforms by name from root level or a scope
- * @deprecated Use `const { removeUniforms } = useUniforms()` instead
- */
-declare function removeUniforms(set: ReturnType<typeof useStore>['setState'], names: string[], scope?: string): void;
-/**
- * Clear all uniforms from a scope (removes the entire scope object)
- * @deprecated Use `const { clearUniforms } = useUniforms()` instead
- */
-declare function clearScope(set: ReturnType<typeof useStore>['setState'], scope: string): void;
-/**
- * Clear all root-level uniforms (preserves scopes)
- * @deprecated Use `const { clearUniforms } = useUniforms()` with `clearUniforms('root')` instead
- */
-declare function clearRootUniforms(set: ReturnType<typeof useStore>['setState']): void;
-
-/**
- * Supported uniform value types:
- * - Raw values: number, boolean, Vector2, Vector3, Vector4, Color, Matrix3, Matrix4
- * - String colors: '#ff0000', 'red', 'rgb(255,0,0)' (auto-converted to Color)
- * - TSL nodes: color(), vec3(), float(), etc. (for type casting)
- * - UniformNode: existing uniforms (reused as-is)
- */
-type UniformValue = number | boolean | string | Vector2$1 | Vector3$1 | Vector4$1 | Color$2 | Matrix3$1 | Matrix4$1 | Node | UniformNode;
-/**
- * Widen literal types to their base types:
- * - 0 → number
- * - true → boolean
- * - '#ff0000' → Color (string colors are converted to Color objects)
- * - Node → Node (TSL nodes passed through for uniform type casting)
- */
-type Widen<T> = T extends number ? number : T extends boolean ? boolean : T extends string ? Color$2 : T;
-declare function useUniform<T extends UniformValue>(name: string): UniformNode<T>;
-declare function useUniform<T extends UniformValue>(name: string, value: T): UniformNode<Widen<T>>;
-
-/**
- * Minimal interface for TSL nodes.
- * Used instead of Three.js's Node type because the @types/three definitions
- * have inconsistencies where OperatorNode, ConstNode, etc. don't properly
- * extend Node with all required properties.
- */
-interface TSLNodeLike {
-    uuid?: string;
-    nodeType?: string | null;
-    /** label method for chaining - sets the node's label and returns self */
-    label?: ((label: string) => TSLNodeLike) | string;
-    setName?: (name: string) => this;
-}
-/** TSL node type - alias for compatibility */
-type TSLNode = TSLNodeLike;
-/**
- * A record of TSL nodes - allows mixed node types (OperatorNode, ConstNode, etc.)
- * Uses TSLNodeLike for broader compatibility with Three.js's TSL type definitions.
- */
-type NodeRecord<T extends TSLNodeLike = TSLNodeLike> = Record<string, T>;
-/**
- * Creator function that returns a record of nodes.
- * Uses TSLNodeLike constraint to allow mixed node types
- * (e.g., { n: OperatorNode; color: ConstNode<Color> }) to pass type checking.
- */
-type NodeCreator<T extends Record<string, TSLNodeLike>> = (state: CreatorState) => T;
-/** Function signature for removeNodes util */
-type RemoveNodesFn = (names: string | string[], scope?: string) => void;
-/** Function signature for clearNodes util */
-type ClearNodesFn = (scope?: string) => void;
-/** Function signature for rebuildNodes util */
-type RebuildNodesFn = (scope?: string) => void;
-/** Return type with utils included */
-type NodesWithUtils<T extends Record<string, TSLNodeLike> = Record<string, TSLNodeLike>> = T & {
-    removeNodes: RemoveNodesFn;
-    clearNodes: ClearNodesFn;
-    rebuildNodes: RebuildNodesFn;
-};
-declare function useNodes(): NodesWithUtils<Record<string, TSLNodeLike> & Record<string, Record<string, TSLNodeLike>>>;
-declare function useNodes(scope: string): NodesWithUtils<Record<string, TSLNodeLike>>;
-declare function useNodes<T extends Record<string, TSLNodeLike>>(creator: NodeCreator<T>): NodesWithUtils<T>;
-declare function useNodes<T extends Record<string, TSLNodeLike>>(creator: NodeCreator<T>, scope: string): NodesWithUtils<T>;
-/**
- * Global rebuildNodes function for HMR integration.
- * Clears cached nodes and increments _hmrVersion to trigger re-creation.
- * Call this when HMR is detected to refresh all node creators.
- *
- * @param store - The R3F store (from useStore or context)
- * @param scope - Optional scope to rebuild ('root' for root only, string for specific scope, undefined for all)
- */
-declare function rebuildAllNodes(store: ReturnType<typeof useStore>, scope?: string): void;
-/**
- * Remove nodes by name from root level or a scope
- * @deprecated Use `const { removeNodes } = useNodes()` instead
- */
-declare function removeNodes(set: ReturnType<typeof useStore>['setState'], names: string[], scope?: string): void;
-/**
- * Clear all nodes from a scope (removes the entire scope object)
- * @deprecated Use `const { clearNodes } = useNodes()` instead
- */
-declare function clearNodeScope(set: ReturnType<typeof useStore>['setState'], scope: string): void;
-/**
- * Clear all root-level nodes (preserves scopes)
- * @deprecated Use `const { clearNodes } = useNodes()` with `clearNodes('root')` instead
- */
-declare function clearRootNodes(set: ReturnType<typeof useStore>['setState']): void;
-
-/** Creator receives CreatorState with ScopedStore wrappers for type-safe access. Returns any record. */
-type LocalNodeCreator<T extends Record<string, unknown>> = (state: CreatorState) => T;
-/**
- * Creates local values that rebuild when uniforms, nodes, or textures change.
- *
- * Unlike `useNodes`, this does NOT register to the global store.
- * Use for component-specific nodes/values that depend on shared resources.
- *
- * @example
- * ```tsx
- * // Destructure what you need from state
- * const { wobble, uTime } = useLocalNodes(({ uniforms, nodes }) => ({
- *   wobble: sin(uniforms.uTime.mul(2)),
- *   uTime: uniforms.uTime,  // can return uniforms too
- * }))
- *
- * // Or access anything else from RootState
- * const { scaled } = useLocalNodes(({ camera, nodes }) => ({
- *   scaled: nodes.basePos.mul(camera.zoom),
- * }))
- *
- * // Type-safe uniform access
- * const { colorNode } = useLocalNodes(({ uniforms }) => {
- *   const uValue = uniforms.myUniform as UniformNode<number>
- *   return { colorNode: mix(colorA, colorB, uValue) }
- * })
- * ```
- */
-declare function useLocalNodes<T extends Record<string, unknown>>(creator: LocalNodeCreator<T>): T;
+import { FrameCallback, UseFrameNextOptions, FrameNextControls } from '@pmndrs/scheduler';
+export { AddPhaseOptions, FrameControls, FrameNextControls, FrameTimingState, RootOptions, Scheduler, SchedulerApi, UseFrameNextOptions, UseFrameOptions, getScheduler } from '@pmndrs/scheduler';
+import { JSX } from 'react';
+import 'react-use-measure';
+import 'zustand/traditional';
+import 'three/tsl';
+
+/**
+ * The `ReactThreeFiber` namespace of the WebGPU entry: the shared element types plus this entry's JSX map.
+ *
+ * Explicit aliases, not `export type *`: rollup-dts otherwise re-exports the types as namespace values
+ * and the built declaration fails to compile for consumers.
+ */
+
+
+type MutableOrReadonlyParameters<T extends (...args: any) => any> = MutableOrReadonlyParameters$1<T>
+type MathRepresentation = MathRepresentation$1
+type VectorRepresentation = VectorRepresentation$1
+type MathTypes = MathTypes$1
+type MathType<T extends MathTypes$1> = MathType$1<T>
+type MathProps<P> = MathProps$1<P>
+type Vector2 = Vector2$1
+type Vector3 = Vector3$1
+type Vector4 = Vector4$1
+type Color = Color$1
+type Layers = Layers$1
+type Quaternion = Quaternion$1
+type Euler = Euler$1
+type Matrix3 = Matrix3$1
+type Matrix4 = Matrix4$1
+type RaycastableRepresentation = RaycastableRepresentation$1
+type EventProps<P> = EventProps$1<P>
+type GeometryTransformProps = GeometryTransformProps$1
+type GeometryProps<P> = GeometryProps$1<P>
+type TSLNodeInput = TSLNodeInput$1
+type NodeProps<P> = NodeProps$1<P>
+type ReactProps<P> = ReactProps$1<P>
+type ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = ElementProps$1<T, P>
+type ThreeElement<T extends ConstructorRepresentation> = ThreeElement$1<T>
+type ThreeToJSXElements<T extends Record<string, any>> = ThreeToJSXElements$1<T>
+type Object3DMethod = Object3DMethod$1
+type ThreeElementsOf<T extends Record<string, any>> = ThreeElementsOf$1<T>
+type ElementOf<E, K extends string> = ElementOf$1<E, K>
+
+type webgpu_d_Color = Color;
+type webgpu_d_ElementOf<E, K extends string> = ElementOf<E, K>;
+type webgpu_d_ElementProps<T extends ConstructorRepresentation, P = InstanceType<T>> = ElementProps<T, P>;
+type webgpu_d_Euler = Euler;
+type webgpu_d_EventProps<P> = EventProps<P>;
+type webgpu_d_GeometryProps<P> = GeometryProps<P>;
+type webgpu_d_GeometryTransformProps = GeometryTransformProps;
+type webgpu_d_Layers = Layers;
+type webgpu_d_MathProps<P> = MathProps<P>;
+type webgpu_d_MathRepresentation = MathRepresentation;
+type webgpu_d_MathType<T extends MathTypes$1> = MathType<T>;
+type webgpu_d_MathTypes = MathTypes;
+type webgpu_d_Matrix3 = Matrix3;
+type webgpu_d_Matrix4 = Matrix4;
+type webgpu_d_MutableOrReadonlyParameters<T extends (...args: any) => any> = MutableOrReadonlyParameters<T>;
+type webgpu_d_NodeProps<P> = NodeProps<P>;
+type webgpu_d_Object3DMethod = Object3DMethod;
+type webgpu_d_Quaternion = Quaternion;
+type webgpu_d_RaycastableRepresentation = RaycastableRepresentation;
+type webgpu_d_ReactProps<P> = ReactProps<P>;
+type webgpu_d_TSLNodeInput = TSLNodeInput;
+type webgpu_d_ThreeElement<T extends ConstructorRepresentation> = ThreeElement<T>;
+type webgpu_d_ThreeElements = ThreeElements;
+type webgpu_d_ThreeElementsOf<T extends Record<string, any>> = ThreeElementsOf<T>;
+type webgpu_d_ThreeExports = ThreeExports;
+type webgpu_d_ThreeToJSXElements<T extends Record<string, any>> = ThreeToJSXElements<T>;
+type webgpu_d_Vector2 = Vector2;
+type webgpu_d_Vector3 = Vector3;
+type webgpu_d_Vector4 = Vector4;
+type webgpu_d_VectorRepresentation = VectorRepresentation;
+declare namespace webgpu_d {
+  export type { webgpu_d_Color as Color, webgpu_d_ElementOf as ElementOf, webgpu_d_ElementProps as ElementProps, webgpu_d_Euler as Euler, webgpu_d_EventProps as EventProps, webgpu_d_GeometryProps as GeometryProps, webgpu_d_GeometryTransformProps as GeometryTransformProps, webgpu_d_Layers as Layers, webgpu_d_MathProps as MathProps, webgpu_d_MathRepresentation as MathRepresentation, webgpu_d_MathType as MathType, webgpu_d_MathTypes as MathTypes, webgpu_d_Matrix3 as Matrix3, webgpu_d_Matrix4 as Matrix4, webgpu_d_MutableOrReadonlyParameters as MutableOrReadonlyParameters, webgpu_d_NodeProps as NodeProps, webgpu_d_Object3DMethod as Object3DMethod, webgpu_d_Quaternion as Quaternion, webgpu_d_RaycastableRepresentation as RaycastableRepresentation, webgpu_d_ReactProps as ReactProps, webgpu_d_TSLNodeInput as TSLNodeInput, webgpu_d_ThreeElement as ThreeElement, webgpu_d_ThreeElements as ThreeElements, webgpu_d_ThreeElementsOf as ThreeElementsOf, webgpu_d_ThreeExports as ThreeExports, webgpu_d_ThreeToJSXElements as ThreeToJSXElements, webgpu_d_Vector2 as Vector2, webgpu_d_Vector3 as Vector3, webgpu_d_Vector4 as Vector4, webgpu_d_VectorRepresentation as VectorRepresentation };
+}
+
+/**
+ * Re-export from core - useTextures is now a core R3F hook (a reactive Texture registry).
+ *
+ * This file maintains backwards compatibility for existing webgpu imports.
+ */
+
+/**
+ * @deprecated The registry now stores plain `Texture` objects, not TSL nodes. Use `Texture` directly.
+ * Kept as an alias for backwards compatibility.
+ */
+type TextureEntry = Texture;
+/**
+ * @deprecated The registry now stores plain `Texture` objects, not TSL nodes. Use `Texture` directly.
+ * Kept as an alias for backwards compatibility.
+ */
+type TextureNode = Texture;
 
 interface TextureOperations {
     add: (key: string, value: any) => void;
@@ -4478,45 +109,6 @@ interface TextureOperations {
 }
 declare function createTextureOperations(set: StoreApi<RootState>['setState']): TextureOperations;
 
-/**
- * Hook for managing WebGPU PostProcessing with automatic scenePass setup.
- *
- * Features:
- * - Creates PostProcessing instance if not exists
- * - Creates default scenePass (no MRT) automatically
- * - Callbacks receive full RootState for flexibility
- * - No auto-cleanup on unmount - use reset() for explicit cleanup
- * - Scene/camera changes trigger scenePass recreation
- *
- * @param mainCB - Main callback to configure outputNode and create effect passes
- * @param setupCB - Optional setup callback to configure MRT on scenePass
- * @returns { passes, postProcessing, clearPasses, reset, rebuild }
- *
- * @example
- * ```tsx
- * // Simple effect
- * usePostProcessing(({ postProcessing, passes }) => {
- *   postProcessing.outputNode = bloom(passes.scenePass.getTextureNode())
- * })
- *
- * // With MRT setup
- * usePostProcessing(
- *   ({ postProcessing, passes }) => {
- *     const beauty = passes.scenePass.getTextureNode().toInspector('Color')
- *     const vel = passes.scenePass.getTextureNode('velocity')
- *     postProcessing.outputNode = motionBlur(beauty, vel)
- *   },
- *   ({ passes }) => {
- *     passes.scenePass.setMRT(mrt({ output, velocity }))
- *   }
- * )
- *
- * // Read-only access
- * const { postProcessing, passes } = usePostProcessing()
- * ```
- */
-declare function usePostProcessing(mainCB?: PostProcessingMainCallback, setupCB?: PostProcessingSetupCallback): UsePostProcessingReturn;
-
 //* Renderer Props ========================================
 
 type WebGPUDefaultProps = Omit<WebGPURendererParameters, 'canvas'> & BaseRendererProps
@@ -4564,5 +156,46 @@ interface WebGPURootState extends Omit<RootState, 'renderer' | 'gl' | 'internal'
   internal: WebGPUInternalState
 }
 
-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, clearNodeScope, clearRootNodes, clearRootUniforms, clearScope, context, createEvents, createPointerEvents, createPortal, createRoot, createScopedStore, createStore, createTextureOperations, 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, rebuildAllNodes, rebuildAllUniforms, reconciler, registerPrimary, removeInteractivity, removeNodes, removeUniforms, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useLocalNodes, useMutableCallback, useNodes, usePostProcessing, useRenderTarget, useStore, useTexture, useTextures, useThree, useUniform, useUniforms, waitForPrimary };
-export type { Act, AddPhaseOptions, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, Bridge, Camera, CameraProps, CanvasProps, CanvasSchedulerConfig, Catalogue, ClearNodesFn, ClearUniformsFn, Color, ComputeFunction, ConstructorRepresentation, CreatorState, DefaultGLProps, DefaultRendererProps, Disposable, 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, WebGPUInternalState as InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, LocalNodeCreator, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeCreator, NodeProps, NodeRecord, NodesWithUtils, NonFunctionKeys, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, WebGPUR3FRenderer as R3FRenderer, RaycastableRepresentation, ReactProps, RebuildNodesFn, RebuildUniformsFn, ReconcilerRoot, RemoveNodesFn, RemoveUniformsFn, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootOptions, WebGPURootState as RootState, RootStore, SchedulerApi, ScopedStoreType, SetBlock, Size, Subscription, TSLNode, TSLNodeInput, TextureEntry, TextureOperations, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UniformCreator, UniformValue, UniformsWithUtils, UseFrameNextOptions, UseFrameOptions, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, WebGPUDefaultProps, WebGPUProps, WebGPUShadowConfig, XRManager };
+declare const R3F_BUILD_LEGACY = false;
+declare const R3F_BUILD_WEBGPU = true;
+/** Create a root that always constructs a WebGPURenderer. */
+declare function createRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
+
+/** `useThree` narrowed to WebGPU state — `state.renderer` is a `WebGPURenderer`. */
+type UseThreeWebGPU = <T = WebGPURootState>(selector?: (state: WebGPURootState) => T, equalityFn?: <U>(state: U, newState: U) => boolean) => T;
+/** `useFrame` narrowed to WebGPU state — the callback's `state.renderer` is a `WebGPURenderer`. */
+type UseFrameWebGPU = (callback?: FrameCallback<WebGPURootState>, priorityOrOptions?: number | UseFrameNextOptions) => FrameNextControls;
+declare const useThree: UseThreeWebGPU;
+declare const useFrame: UseFrameWebGPU;
+/** `useRenderTarget` narrowed to the target this entry's renderer produces. */
+declare const useRenderTarget: {
+    (options?: RenderTargetOptions): RenderTarget;
+    (size: number, options?: RenderTargetOptions): RenderTarget;
+    (width: number, height: number, options?: RenderTargetOptions): RenderTarget;
+};
+
+/** Canvas props on the WebGPU entry: `onCreated` receives `WebGPURootState`. */
+type WebGPUCanvasProps = Omit<CanvasProps, 'onCreated'> & {
+    /** Callback after the canvas has rendered (but not yet committed); `state.renderer` is a `WebGPURenderer` */
+    onCreated?: (state: WebGPURootState) => void;
+};
+
+/**
+ * A DOM canvas which accepts threejs elements as children, rendered with WebGPU. `onCreated` is
+ * typed against `WebGPURootState`.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/canvas
+ */
+declare const Canvas: (props: WebGPUCanvasProps) => JSX.Element;
+/** Three.js constructors available as JSX elements on this entry. */
+type ThreeExports = typeof ThreeWebGPU;
+interface ThreeElements extends ThreeElementsOf$1<ThreeExports> {
+}
+declare module 'react' {
+    namespace JSX {
+        interface IntrinsicElements extends ThreeElements {
+        }
+    }
+}
+
+export { BaseRendererProps, RootState as BaseRootState, Canvas, Color$1 as Color, ConstructorRepresentation, ElementOf$1 as ElementOf, ElementProps$1 as ElementProps, Euler$1 as Euler, EventProps$1 as EventProps, GeometryProps$1 as GeometryProps, GeometryTransformProps$1 as GeometryTransformProps, Layers$1 as Layers, MathProps$1 as MathProps, MathRepresentation$1 as MathRepresentation, MathType$1 as MathType, MathTypes$1 as MathTypes, Matrix3$1 as Matrix3, Matrix4$1 as Matrix4, MutableOrReadonlyParameters$1 as MutableOrReadonlyParameters, NodeProps$1 as NodeProps, Object3DMethod$1 as Object3DMethod, Properties, Quaternion$1 as Quaternion, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, RaycastableRepresentation$1 as RaycastableRepresentation, ReactProps$1 as ReactProps, webgpu_d as ReactThreeFiber, ReconcilerRoot, RenderTargetOptions, RendererFactory, TSLNodeInput$1 as TSLNodeInput, ThreeElement$1 as ThreeElement, ThreeElementsOf$1 as ThreeElementsOf, ThreeToJSXElements$1 as ThreeToJSXElements, Vector2$1 as Vector2, Vector3$1 as Vector3, Vector4$1 as Vector4, VectorRepresentation$1 as VectorRepresentation, createRoot, createTextureOperations, useFrame, useRenderTarget, useThree };
+export type { WebGPUCanvasProps as CanvasProps, WebGPUInternalState as InternalState, WebGPUR3FRenderer as R3FRenderer, WebGPURootState as RootState, TextureEntry, TextureNode, TextureOperations, ThreeElements, ThreeExports, UseFrameWebGPU, UseThreeWebGPU, WebGPUCanvasProps, WebGPUDefaultProps, WebGPUProps, WebGPUShadowConfig };