@react-three/fiber 10.0.0-alpha.2 → 10.0.0-canary.1b98c17

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import * as three_webgpu from 'three/webgpu';
-import { RenderTarget, Node, ShaderNodeObject, Euler as Euler$1, Color as Color$2, ColorRepresentation as ColorRepresentation$1, Layers as Layers$1, Raycaster, Intersection as Intersection$1, Vector2 as Vector2$1, Vector3 as Vector3$1, Vector4 as Vector4$1, Quaternion as Quaternion$1, Matrix3 as Matrix3$1, Matrix4 as Matrix4$1, Object3D, Texture as Texture$1, Frustum, OrthographicCamera } from 'three/webgpu';
+import { RenderTarget, WebGPURenderer, Node, StorageTexture, Data3DTexture, CanvasTarget, ShaderNodeObject, Euler as Euler$2, Color as Color$2, ColorRepresentation as ColorRepresentation$1, Layers as Layers$1, Raycaster, Intersection as Intersection$1, BufferGeometry, Matrix4 as Matrix4$1, Quaternion as Quaternion$1, Vector2 as Vector2$1, Vector3 as Vector3$1, Vector4 as Vector4$1, Matrix3 as Matrix3$1, Loader as Loader$1, ColorSpace, Texture as Texture$1, CubeTexture, Scene, Object3D, Frustum, OrthographicCamera } from 'three/webgpu';
 import * as THREE$1 from 'three';
-import { WebGLRenderTarget, WebGLRenderer, Color as Color$1, ColorRepresentation, RenderTargetOptions as RenderTargetOptions$1 } from 'three';
+import { WebGLRenderTarget, WebGLRenderer, Color as Color$1, ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1 } from 'three';
 import { WebGLRendererParameters } from 'three/src/renderers/WebGLRenderer.js';
 import { Inspector } from 'three/addons/inspector/Inspector.js';
 import * as React$1 from 'react';
@@ -10,6 +10,8 @@ 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) {
@@ -55,1282 +57,1741 @@ var THREE = /*#__PURE__*/_mergeNamespaces({
   WebGLRendererParameters: WebGLRendererParameters
 }, [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> = { [K in keyof P]: P[K] | Readonly<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 ==============================
-
-interface ObjectMap {
-  nodes: { [name: string]: THREE$1.Object3D }
-  materials: { [name: string]: THREE$1.Material }
-  meshes: { [name: 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
-}
-
-//* 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: THREE$1.WebGLRenderer | any // WebGPURenderer when available
-  /** 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
-}
-
-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']
-  /** (deprecated) The instance of the WebGLrenderer */
-  gl: THREE$1.WebGLRenderer
-  /** The instance of the WebGPU renderer, the fallback, OR the default renderer as a mask of gl */
-  renderer: THREE$1.WebGLRenderer | any // WebGPURenderer when available
-  /** 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
-  /* Whether to enable r139's THREE.ColorManagement */
-  legacy: boolean
-  /** Shortcut to gl.outputColorSpace = THREE.LinearSRGBColorSpace */
-  linear: boolean
-  /** Shortcut to gl.toneMapping = NoTonemapping */
-  flat: boolean
-  /** 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
-}
-
+//* 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
+  /** pointerId of the original event for multiple pointer events */
+  pointerId: number
+  /** 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
+
+/** Configuration for XR pointer registration (controllers/hands) */
+interface XRPointerConfig {
+  /** Ray origin (updated each frame by XR system) */
+  ray: THREE$1.Ray
+  /** Optional: custom compute function for this pointer */
+  compute?: (state: RootState) => void
+  /** Pointer type identifier */
+  type: 'controller' | 'hand' | 'gaze'
+  /** Which hand (for controller/hand types) */
+  handedness?: 'left' | 'right'
+}
+
+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.
+   *  @param pointerId - Optional pointer ID to update specific pointer only
+   */
+  update?: (pointerId?: number) => void
+  /** Defer pointer move raycasting to frame start (default: true) */
+  frameTimedRaycasts?: boolean
+  /** Always fire raycaster immediately on scroll events (default: true) */
+  alwaysFireOnScroll?: boolean
+  /** Automatically re-raycast every frame to detect hover changes from moving objects/camera (default: false) */
+  updateOnFrame?: boolean
+  /** Flush deferred pointer raycasts. Called by scheduler at frame start (input phase). */
+  flush?: () => void
+  /** Register an XR pointer (controller/hand). Returns assigned pointerId */
+  registerPointer?: (config: XRPointerConfig) => number
+  /** Unregister an XR pointer */
+  unregisterPointer?: (pointerId: number) => 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
+}
+
+//* Buffer Types (useBuffers) ========================================
+
+/**
+ * Buffer-like types for GPU compute and storage operations.
+ * Includes raw CPU arrays, Three.js buffer attributes, and TSL buffer nodes.
+ *
+ * @example
+ * ```tsx
+ * const { positions, velocities } = useBuffers(() => ({
+ *   positions: instancedArray(count, 'vec3'),       // StorageBufferNode
+ *   velocities: new Float32Array(count * 3),        // TypedArray
+ * }), 'particles')
+ * ```
+ */
+type BufferLike =
+  | Float32Array
+  | Uint32Array
+  | Int32Array
+  | Float64Array
+  | Uint8Array
+  | Int8Array
+  | Uint16Array
+  | Int16Array
+  | THREE$1.BufferAttribute // Base class for all buffer attributes
+  | Node // TSL buffer nodes (instancedArray, storage)
+
+/** Flat record of buffer-like values (no nested scopes) */
+type BufferRecord = Record<string, BufferLike>
+
+/**
+ * Buffer store that can contain both root-level buffers and scoped buffer objects.
+ * Structure: { positions: Float32Array, particles: { vel: StorageBufferNode } }
+ */
+type BufferStore = Record<string, BufferLike | BufferRecord>
+
+//* Storage Types (useGPUStorage) ========================================
+
+/**
+ * GPU storage types for texture-based storage operations.
+ * Includes Three.js storage textures and TSL storage texture nodes.
+ *
+ * @example
+ * ```tsx
+ * const { heightMap } = useGPUStorage(() => ({
+ *   heightMap: new StorageTexture(512, 512),
+ * }), 'terrain')
+ * ```
+ */
+type StorageLike =
+  | StorageTexture // GPU storage texture
+  | Data3DTexture // 3D texture (can be used as storage)
+  | Node // TSL storage texture nodes (storageTexture)
+
+/** Flat record of storage-like values (no nested scopes) */
+type StorageRecord = Record<string, StorageLike>
+
+/**
+ * Storage store that can contain both root-level storage and scoped storage objects.
+ * Structure: { heightMap: StorageTexture, terrain: { normal: StorageTextureNode } }
+ */
+type StorageStore = Record<string, StorageLike | StorageRecord>
+
+//* 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
+}
+
+/** Per-pointer state for multi-touch and XR support */
+type PointerState = {
+  /** Objects currently hovered by this pointer */
+  hovered: Map<string, ThreeEvent<DomEvent>>
+  /** Objects capturing this pointer */
+  captured: Map<THREE$1.Object3D, PointerCaptureTarget>
+  /** Initial click position [x, y] */
+  initialClick: [x: number, y: number]
+  /** Objects hit on initial click */
+  initialHits: THREE$1.Object3D[]
+}
+
+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[]
+  subscribers: Subscription[]
+  /** Per-pointer state (hover, capture, click tracking) - replaces hovered, capturedMap, initialClick, initialHits */
+  pointerMap: Map<number, PointerState>
+  /** Pointers needing raycast this frame (used with frameTimedRaycasts) */
+  pointerDirty: Map<number, DomEvent>
+  /** Last event received (for events.update() compatibility) */
+  lastEvent: React$1.RefObject<DomEvent | null>
+  /** @deprecated Use pointerMap.get(pointerId).hovered instead */
+  hovered: Map<string, ThreeEvent<DomEvent>>
+  /** @deprecated Use pointerMap.get(pointerId).captured instead */
+  capturedMap: Map<number, Map<THREE$1.Object3D, PointerCaptureTarget>>
+  /** @deprecated Use pointerMap.get(pointerId).initialClick instead */
+  initialClick: [x: number, y: number]
+  /** @deprecated Use pointerMap.get(pointerId).initialHits instead */
+  initialHits: THREE$1.Object3D[]
+  /** 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 buffer nodes - root-level buffers + scoped sub-objects. Use useBuffers() hook */
+  buffers: BufferStore
+  /** Global GPU storage (textures, etc.) - root-level storage + scoped sub-objects. Use useGPUStorage() hook */
+  gpuStorage: StorageStore
+  /** Global TSL texture nodes - use useTextures() hook for operations */
+  textures: Map<string, any>
+  /** WebGPU RenderPipeline instance - use useRenderPipeline() hook */
+  renderPipeline: any | null // THREE.PostProcessing (will be THREE.RenderPipeline in future Three.js release)
+  /** Global TSL pass nodes for render pipeline - use useRenderPipeline() hook */
+  passes: Record<string, any>
+  /** Internal version counter for HMR - incremented by rebuildNodes/rebuildUniforms to bust memoization */
+  _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
-}
-
-type RendererProps =
-  | any // WebGPURenderer
-  | ((defaultProps: DefaultRendererProps) => any)
-  | ((defaultProps: DefaultRendererProps) => Promise<any>)
-  | Partial<Properties<any> | Record<string, any>>
-
-//* 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> {
-  /** 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>
-  /**
-   * Disables three r139 color management.
-   * @see https://threejs.org/docs/#manual/en/introduction/Color-management
-   */
-  legacy?: boolean
-  /** Switch off automatic sRGB encoding and gamma correction */
-  linear?: boolean
-  /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
-  flat?: boolean
-  /** Working color space for automatic texture colorspace assignment. Defaults to THREE.SRGBColorSpace */
-  /** 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
-}
-
-//* 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
-  }
+//* 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
+}
+
+//* Color Management Config ==============================
+
+/**
+ * Color management configuration shared by both WebGL and WebGPU renderers.
+ */
+interface ColorManagementConfig {
+  /**
+   * Color space assigned to 8-bit input textures (color maps).
+   * Defaults to sRGB. Most textures are authored in sRGB.
+   * @default THREE.SRGBColorSpace
+   */
+  textureColorSpace?: THREE$1.ColorSpace
+}
+
+//* 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> & ColorManagementConfig)
+
+//* 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 and color management.
+ */
+interface RendererConfigExtended extends ColorManagementConfig {
+  /** 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>
+  /** 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
-}
-
-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
-
+//* 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'
 
-//* Canvas Types ==============================
-
-interface CanvasProps
-  extends Omit<RenderProps<HTMLCanvasElement>, 'size'>, 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
-}
-
-//* 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>,
+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 | null>
+  /** 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
 
-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>
+//* 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
 }
 
-//* RenderTarget Types ==============================
-
-
+/**
+ * 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
-  }
-
-  /** 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, Three.js types, plain objects (converted to vectors), and UniformNodes
-   */
-  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
-    | UniformNode
-
-  /** Input record for useUniforms - accepts raw values or UniformNodes */
-  type UniformInputRecord = Record<string, UniformValue>
-}
-
-//* Fn Return Type ==============================
-
-/** The return type of Fn() - a callable shader function node */
-type ShaderCallable<R extends Node = Node> = ((...params: unknown[]) => ShaderNodeObject<R>) & Node
-
-//* 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$1 | Color$2
-
-type MathType<T extends MathTypes> = T extends Color$2
-  ? Args<typeof Color$2> | ColorRepresentation$1
-  : T extends VectorRepresentation | Layers$1 | Euler$1
-    ? 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$1>
-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> : {}
-
-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>>
->
-
-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 {}
-  }
+//* 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
+    | { r: number; g: number; b: number; a?: number } // Plain objects converted to Color
+    | 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>
+}
+
+/**
+ * RenderPipeline Types for useRenderPipeline hook (WebGPU only)
+ */
+
+
+
+declare global {
+  /** Pass record - stores TSL pass nodes for render pipeline */
+  type PassRecord = Record<string, any>
+
+  /** Setup callback - runs first to configure MRT, create additional passes */
+  type RenderPipelineSetupCallback = (state: RootState) => PassRecord | void
+
+  /** Main callback - runs second to configure outputNode, create effect passes */
+  type RenderPipelineMainCallback = (state: RootState) => PassRecord | void
+
+  /** Return type for useRenderPipeline hook */
+  interface UseRenderPipelineReturn {
+    /** Current passes from state */
+    passes: PassRecord
+    /** RenderPipeline instance (null if not initialized) */
+    renderPipeline: any | null // THREE.PostProcessing (will be THREE.RenderPipeline in future Three.js release)
+    /** Clear all passes from state */
+    clearPasses: () => void
+    /** Reset RenderPipeline entirely (clears PP + passes) */
+    reset: () => void
+    /** Re-run setup/main callbacks with current closure values */
+    rebuild: () => void
+    /** True when RenderPipeline 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;
@@ -1339,9 +1800,11 @@ 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;
@@ -1352,12 +1815,324 @@ 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_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_Quaternion as Quaternion, three_d_RaycastableRepresentation as RaycastableRepresentation, three_d_ReactProps as ReactProps, 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 };
+  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;
+    flushDeferredPointers: () => void;
+    processDeferredPointer: (event: DomEvent, pointerId: number) => void;
 };
 /** Default R3F event manager for web */
 declare function createPointerEvents(store: RootStore): EventManager<HTMLElement>;
@@ -1916,31 +2691,30 @@ declare function useTextures(): UseTexturesReturn;
  * - WebGPU build: Returns RenderTarget
  * - Default build: Returns whichever matches the active renderer
  *
- * @param width - Target width (defaults to canvas width)
- * @param height - Target height (defaults to canvas height)
- * @param options - Three.js RenderTarget options
- *
  * @example
  * ```tsx
- * function PortalScene() {
- *   const fbo = useRenderTarget(512, 512, { depthBuffer: true })
- *
- *   useFrame(({ renderer, scene, camera }) => {
- *     renderer.setRenderTarget(fbo)
- *     renderer.render(scene, camera)
- *     renderer.setRenderTarget(null)
- *   })
- *
- *   return (
- *     <mesh>
- *       <planeGeometry />
- *       <meshBasicMaterial map={fbo.texture} />
- *     </mesh>
- *   )
- * }
+ * // 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(width?: number, height?: number, options?: RenderTargetOptions): RenderTarget<THREE$1.Texture<unknown>>;
+declare function useRenderTarget(options?: RenderTargetOptions): RenderTarget;
+declare function useRenderTarget(size: number, options?: RenderTargetOptions): RenderTarget;
+declare function useRenderTarget(width: number, height: number, options?: RenderTargetOptions): RenderTarget;
 
 /**
  * Returns the R3F Canvas' Zustand store. Useful for [transient updates](https://github.com/pmndrs/zustand#transient-updates-for-often-occurring-state-changes).
@@ -2045,7 +2819,7 @@ declare function invalidate(state?: RootState, frames?: number, stackFrames?: bo
  *
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
  */
-declare function advance(timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame): void;
+declare function advance(timestamp: number): void;
 
 /* eslint-disable @definitelytyped/no-unnecessary-generics */
 declare function ReactReconciler<
@@ -3099,6 +3873,12 @@ 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).
@@ -3527,11 +4307,76 @@ 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;
 
-export { Block, Canvas, ErrorBoundary, IsObject, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Scheduler, Texture, _roots, act, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, getInstanceProps, getRootState, getScheduler, getUuidPrefix, hasConstructor, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isObject3D, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, prepare, reconciler, removeInteractivity, resolve, unmountComponentAtNode, updateCamera, updateFrustum, useBridge, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree };
-export type { Act, AddPhaseOptions, Args, ArgsProp, AttachFnType, AttachType, BaseRendererProps, Bridge, Camera, CameraProps, CanvasProps, Catalogue, Color, ComputeFunction, ConstructorRepresentation, DefaultGLProps, DefaultRendererProps, Disposable, DomEvent, Dpr, ElementProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameControls, FrameNextCallback, FrameNextControls, FrameNextState, FrameState, FrameTimingState, Frameloop, GLProps, GLTFLike, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LoaderInstance, LoaderLike, LoaderResult, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NonFunctionKeys, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, Properties, Quaternion, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererFactory, RendererProps, Root, RootOptions, RootState, RootStore, SchedulerApi, SetBlock, Size, Subscription, TextureEntry, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UseFrameNextOptions, UseFrameOptions, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, XRManager };
+export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Scheduler, Texture, _roots, act, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getScheduler, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
+export type { Act, AddPhaseOptions, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, Bridge, BufferLike, BufferRecord, BufferStore, Camera, CameraProps, CanvasProps, CanvasSchedulerConfig, Catalogue, Color, ColorManagementConfig, ComputeFunction, ConstructorRepresentation, DefaultGLProps, DefaultRendererProps, Disposable, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameControls, FrameNextCallback, FrameNextControls, FrameNextState, FrameState, FrameTimingState, Frameloop, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeProps, NonFunctionKeys, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootOptions, RootState, RootStore, SchedulerApi, SetBlock, Size, StorageLike, StorageRecord, StorageStore, Subscription, TSLNodeInput, TextureEntry, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UseFrameNextOptions, UseFrameOptions, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, XRManager, XRPointerConfig };