@react-three/fiber 10.0.0-canary.dbbe704 → 10.0.0-canary.ea31ccd

package/dist/webgpu/index.d.ts

@@ -1,5 +1,6 @@
+import * as three_examples_jsm_inspector_Inspector_js from 'three/examples/jsm/inspector/Inspector.js';
 import * as three_webgpu from 'three/webgpu';
-import { RenderTarget, WebGPURenderer, CanvasTarget, Node, ShaderNodeObject, Euler as Euler$2, Color as Color$2, ColorRepresentation as ColorRepresentation$1, Layers as Layers$1, Raycaster, Intersection as Intersection$1, BufferGeometry, Matrix4 as Matrix4$1, Quaternion as Quaternion$1, Vector2 as Vector2$1, Vector3 as Vector3$1, Vector4 as Vector4$1, Matrix3 as Matrix3$1, Loader as Loader$1, ColorSpace, Texture as Texture$1, CubeTexture, Scene, Object3D, Frustum, OrthographicCamera, WebGPURendererParameters } from 'three/webgpu';
+import { CubeRenderTarget, RenderTarget, WebGPURenderer, Node, StorageTexture, Storage3DTexture, StorageArrayTexture, Data3DTexture, CanvasTarget, 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, Object3D, 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, Frustum, OrthographicCamera, Matrix2, WebGPURendererParameters } from 'three/webgpu';
 import { Inspector } from 'three/addons/inspector/Inspector.js';
 import * as THREE$1 from 'three';
 import { Color as Color$1, ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1 } from 'three';
@@ -7,25 +8,12 @@ import * as React$1 from 'react';
 import { ReactNode, Component, RefObject, JSX } from 'react';
 import { StoreApi } from 'zustand';
 import { UseBoundStoreWithEqualityFn } from 'zustand/traditional';
+import { FrameTimingState, FrameCallback as FrameCallback$1, SchedulerApi, UseFrameNextOptions, FrameNextControls } from '@pmndrs/scheduler';
+export { AddPhaseOptions, FrameControls, FrameNextControls, FrameTimingState, RootOptions, Scheduler, SchedulerApi, UseFrameNextOptions, UseFrameOptions, getScheduler } from '@pmndrs/scheduler';
 import { Options } from 'react-use-measure';
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ThreeElement as ThreeElement$1, Euler as Euler$3 } from '@react-three/fiber';
 import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
 
-function _mergeNamespaces(n, m) {
-  m.forEach(function (e) {
-    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
-      if (k !== 'default' && !(k in n)) {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  });
-  return Object.freeze(n);
-}
 
 /**
  * @fileoverview Internal Three.js re-exports - WEBGPU ONLY ENTRY
@@ -39,6 +27,8 @@ function _mergeNamespaces(n, m) {
 declare const R3F_BUILD_LEGACY = false;
 declare const R3F_BUILD_WEBGPU = true;
 
+/** Lazily load the three Inspector. Keeps it out of the eager module graph — see note above. */
+declare function loadInspector(): Promise<typeof three_examples_jsm_inspector_Inspector_js.Inspector>;
 declare const WebGLRenderer: {
     new (): {};
 };
@@ -47,17 +37,8 @@ type WebGLShadowMap = never;
 
 declare const WebGLRenderTarget: any;
 
-var THREE = /*#__PURE__*/_mergeNamespaces({
-  __proto__: null,
-  Inspector: Inspector,
-  R3F_BUILD_LEGACY: R3F_BUILD_LEGACY,
-  R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
-  RenderTargetCompat: RenderTarget,
-  WebGLRenderTarget: WebGLRenderTarget,
-  WebGLRenderer: WebGLRenderer,
-  WebGLRendererParameters: WebGLRendererParameters,
-  WebGLShadowMap: WebGLShadowMap
-}, [three_webgpu]);
+declare const WebGLCubeRenderTarget: any;
+
 
 //* Utility Types ==============================
 
@@ -151,6 +132,8 @@ interface IntersectionEvent<TSourceEvent> extends Intersection {
   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 */
@@ -227,6 +210,18 @@ interface EventHandlers {
 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
@@ -246,8 +241,21 @@ interface EventManager<TTarget> {
   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?: () => void
+  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 {
@@ -267,227 +275,116 @@ interface VisibilityEntry {
 }
 
 //* Scheduler Types (useFrame) ==============================
+//
+// The generic, framework-agnostic scheduler types now live in @pmndrs/scheduler.
+// This file re-exports them and layers r3f's RootState-aware frame state on top,
+// so existing `#types` imports across the codebase keep resolving unchanged.
 
 
 
-// Public Options --------------------------------
+// Frame State (r3f-specific) --------------------------------
 
 /**
- * Options for useFrame hook
+ * State passed to useFrame callbacks (extends RootState with timing).
  */
-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
-}
+interface FrameNextState extends RootState, FrameTimingState {}
 
-/** Alias for UseFrameNextOptions */
-type UseFrameOptions = UseFrameNextOptions
+/** Alias for FrameNextState */
+type FrameState = FrameNextState
+
+// Callback Types (r3f-specific) --------------------------------
 
 /**
- * Options for addPhase
+ * Callback function for useFrame. Receives the full r3f RootState plus timing.
  */
-interface AddPhaseOptions {
-  /** Insert this phase before the specified phase */
-  before?: string
-  /** Insert this phase after the specified phase */
-  after?: string
-}
+type FrameNextCallback = FrameCallback$1<RootState>
 
-// Frame State --------------------------------
+/** Alias for FrameNextCallback */
+type FrameCallback = FrameNextCallback
+
+//* Buffer Types (useBuffers) ========================================
 
 /**
- * Timing-only state for independent/outside mode (no RootState)
+ * 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')
+ * ```
  */
-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
-}
+type BufferLike =
+  | Float32Array
+  | Uint32Array
+  | Int32Array
+  | Float64Array
+  | Uint8Array
+  | Int8Array
+  | Uint16Array
+  | Int16Array
+  | THREE$1.BufferAttribute // Base class for all buffer attributes
+  | THREE$1.InterleavedBufferAttribute
+  | Node // TSL buffer nodes (instancedArray, storage)
+
+/** Flat record of buffer-like values (no nested scopes) */
+type BufferRecord = Record<string, BufferLike>
 
 /**
- * State passed to useFrame callbacks (extends RootState with timing)
+ * Buffer store that can contain both root-level buffers and scoped buffer objects.
+ * Structure: { positions: Float32Array, particles: { vel: StorageBufferNode } }
  */
-interface FrameNextState extends RootState, FrameTimingState {}
-
-/** Alias for FrameNextState */
-type FrameState = FrameNextState
+type BufferStore = Record<string, BufferLike | BufferRecord>
 
-// Root Options --------------------------------
+//* Node Types (useNodes) ========================================
 
 /**
- * Options for registerRoot
+ * Every node representation `useNodes` accepts and `state.nodes` holds: three's real `Node`,
+ * the callable proxy `Fn()` returns, and the legacy structural shape (`uuid`/`nodeType`) older
+ * code passes through. Creators are constrained to this same type, so the shape a creator returns
+ * and the shape the store holds are one type by construction.
  */
-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
-}
+type NodeLike = TSLNodeType | LegacyTSLNodeLike
 
-// Callback Types --------------------------------
+/** Flat record of TSL nodes (no nested scopes) */
+type NodeRecord<T extends NodeLike = NodeLike> = Record<string, T>
 
 /**
- * Callback function for useFrame
+ * Node store that can contain both root-level nodes and scoped node objects.
+ * Structure: { wobble: OperatorNode, fx: { blur: ShaderCallable } }
  */
-type FrameNextCallback = (state: FrameNextState, delta: number) => void
-
-/** Alias for FrameNextCallback */
-type FrameCallback = FrameNextCallback
+type NodeStore = Record<string, NodeLike | NodeRecord>
 
-// Controls returned from useFrame --------------------------------
+//* Storage Types (useGPUStorage) ========================================
 
 /**
- * Controls object returned from useFrame hook
+ * 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')
+ * ```
  */
-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
-}
+type StorageLike =
+  | StorageTexture // 2D GPU storage texture
+  | Storage3DTexture // 3D GPU storage texture (volumes, fluid grids)
+  | StorageArrayTexture // 2D-array GPU storage texture
+  | Data3DTexture // 3D texture (can be used as storage)
+  | Node // TSL storage texture nodes (storageTexture)
 
-/** Alias for FrameNextControls */
-type FrameControls = FrameNextControls
-
-// Scheduler Interface --------------------------------
+/** Flat record of storage-like values (no nested scopes) */
+type StorageRecord = Record<string, StorageLike>
 
 /**
- * Public interface for the global Scheduler
+ * Storage store that can contain both root-level storage and scoped storage objects.
+ * Structure: { heightMap: StorageTexture, terrain: { normal: StorageTextureNode } }
  */
-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
-}
+type StorageStore = Record<string, StorageLike | StorageRecord>
 
 //* Renderer Types ========================================
 
@@ -502,6 +399,18 @@ type Subscription = {
   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 {
@@ -543,12 +452,21 @@ interface Performance {
 
 interface InternalState {
   interaction: THREE$1.Object3D[]
-  hovered: Map<string, ThreeEvent<DomEvent>>
   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[]
-  lastEvent: React$1.RefObject<DomEvent | null>
   /** Visibility event registry (onFramed, onOccluded, onVisible) */
   visibilityRegistry: Map<string, VisibilityEntry>
   /** Whether occlusion queries are enabled (WebGPU only) */
@@ -574,14 +492,31 @@ interface InternalState {
   /** 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.
+   * The CanvasTarget this root sizes and renders through.
+   *
+   * A primary (`<Canvas id>`) owns the renderer's default target -- the one three itself built
+   * around the canvas element -- so sizing it is sizing the renderer. A secondary owns a target
+   * R3F created for its own element. Either way there is exactly one target per canvas element,
+   * and the canvas-target job makes it the renderer's active one before this root renders.
+   * Absent on WebGL and on an id-less WebGPU canvas, where the renderer is sized directly.
    * @see https://threejs.org/docs/#api/en/renderers/common/CanvasTarget
    */
   canvasTarget?: CanvasTarget
+  /**
+   * Set when this root's canvas target has been resized and the backend's cached render pass
+   * descriptor (which holds a depth-stencil view built once per canvas) is therefore stale.
+   *
+   * Flushed by the canvas-target job in the `start` phase, which is the only place this root's
+   * target is guaranteed to be the renderer's active one — `backend.updateSize()` operates on
+   * whatever `getCanvasTarget()` returns, so calling it from the resize subscription would
+   * invalidate some other canvas's descriptor instead.
+   *
+   * @see https://github.com/pmndrs/react-three-fiber/issues/3847
+   */
+  canvasTargetSizeDirty?: boolean
   /**
    * Whether multi-canvas rendering is active.
-   * True when any canvas uses `target` prop to share a renderer.
+   * True when any canvas uses `renderer={{ primaryCanvas: 'id' }}` to share a renderer.
    * When true, setCanvasTarget is called before each render.
    */
   isMultiCanvas?: boolean
@@ -679,8 +614,8 @@ interface RootState {
   setSize: (width?: number, height?: number, top?: number, left?: number) => void
   /** Shortcut to manual setting the pixel ratio */
   setDpr: (dpr: Dpr) => void
-  /** Shortcut to setting frameloop flags */
-  setFrameloop: (frameloop: Frameloop) => void
+  /** Shortcut to setting frameloop flags. No args resets to 'always'. */
+  setFrameloop: (frameloop?: Frameloop) => void
   /** Set error state to propagate to error boundary */
   setError: (error: Error | null) => void
   /** Current error state (null when no error) */
@@ -688,13 +623,19 @@ interface RootState {
   /** 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>
+  nodes: NodeStore
+  /** 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 Texture registry (key → Texture, usually keyed by URL) - use useTextures() hook for access + lifecycle */
+  textures: Map<string, THREE$1.Texture>
+  /** Internal: refcount per texture key, driven by mounted useTexture consumers (registry enrollment is on by default) */
+  _textureRefs: Map<string, number>
+  /** WebGPU RenderPipeline instance - use useRenderPipeline() hook */
+  renderPipeline: ThreeRenderPipeline | null
+  /** Global TSL pass nodes for render pipeline - use useRenderPipeline() hook */
+  passes: PassRecord
   /** Internal version counter for HMR - incremented by rebuildNodes/rebuildUniforms to bust memoization */
   _hmrVersion: number
   /** Internal: whether setSize() has taken ownership of canvas dimensions */
@@ -743,6 +684,20 @@ 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'> & {
@@ -753,7 +708,7 @@ type GLProps =
   | Renderer
   | ((defaultProps: DefaultGLProps) => Renderer)
   | ((defaultProps: DefaultGLProps) => Promise<Renderer>)
-  | Partial<Properties<THREE$1.WebGLRenderer> | THREE$1.WebGLRendererParameters>
+  | (Partial<Properties<THREE$1.WebGLRenderer> | THREE$1.WebGLRendererParameters> & ColorManagementConfig)
 
 //* WebGPU Renderer Props ==============================
 
@@ -768,20 +723,27 @@ type DefaultRendererProps = {
  */
 interface CanvasSchedulerConfig {
   /**
-   * Render this canvas after another canvas completes.
-   * Pass the `id` of another canvas.
+   * Run this Canvas root before the referenced Canvas root id(s).
    */
-  after?: string
+  before?: string | string[]
   /**
-   * Limit this canvas's render rate (frames per second).
+   * Run this Canvas root after the referenced Canvas root id(s).
+   */
+  after?: string | string[]
+  /**
+   * Numeric root order. Lower values run first.
+   */
+  order?: number
+  /**
+   * Limit this Canvas's default render job (frames per second).
    */
   fps?: number
 }
 
 /**
- * Extended renderer configuration for multi-canvas support.
+ * Extended renderer configuration for multi-canvas support and color management.
  */
-interface RendererConfigExtended {
+interface RendererConfigExtended extends ColorManagementConfig {
   /** Share renderer from another canvas (WebGPU only) */
   primaryCanvas?: string
   /** Canvas-level scheduler options */
@@ -846,8 +808,6 @@ interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas$1> {
    * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
    */
   shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE$1.WebGLShadowMap>
-  /** Color space assigned to 8-bit input textures (color maps). Defaults to sRGB. Most textures are authored in sRGB. */
-  textureColorSpace?: THREE$1.ColorSpace
   /** Creates an orthographic camera */
   orthographic?: boolean
   /**
@@ -862,14 +822,17 @@ interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas$1> {
   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>
+  /**
+   * Props that go into the default raycaster. `params` is merged into the raycaster's defaults,
+   * so a single threshold can be set: `raycaster={{ params: { Points: { threshold: 0.2 } } }}`.
+   */
+  raycaster?: Partial<Omit<THREE$1.Raycaster, 'params'>> & { params?: Partial<THREE$1.RaycasterParameters> }
   /** 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>
+  events?: (store: RootStore) => EventManager<Element>
   /** Callback after the canvas has rendered (but not yet committed) */
   onCreated?: (state: RootState) => void
   /** Response for pointer clicks that have missed any target */
@@ -958,7 +921,6 @@ type InstanceProps<T = any, P = any> = ArgsProp<P> & {
   object?: T
   dispose?: null
   attach?: AttachType<T>
-  onUpdate?: (self: T) => void
 }
 
 interface Instance<O = any> {
@@ -973,8 +935,6 @@ interface Instance<O = any> {
   attach?: AttachType<O>
   previousAttach?: any
   isHidden: boolean
-  /** Deferred ref props to apply in commitMount */
-  deferredRefs?: Array<{ prop: string; ref: React$1.RefObject<any> }>
   /** Set of props that have been applied via once() */
   appliedOnce?: Set<string>
 }
@@ -1100,7 +1060,7 @@ interface CanvasProps
    */
   resize?: Options
   /** The target where events are being subscribed to, default: the div that wraps canvas */
-  eventSource?: HTMLElement | React$1.RefObject<HTMLElement>
+  eventSource?: Element | React$1.RefObject<Element | 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 */
@@ -1208,70 +1168,86 @@ interface LegacyRootState extends Omit<RootState, 'renderer' | 'internal'> {
 
 type RenderTargetOptions = RenderTargetOptions$1
 
-//* Global Types ==============================
+//* Global TSL 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> }
-   * ```
+   * Broad callable-node fallback for dynamic store readers.
+   * Creator hooks preserve the exact function signatures inferred from Three's `Fn`.
    */
-  type ShaderCallable<R extends Node = Node> = ((...params: unknown[]) => ShaderNodeObject<R>) & Node
+  type CallableTSLNode = ((...params: never[]) => unknown) & {
+    readonly shaderNode: unknown
+    readonly id: number
+  }
 
-  /**
-   * 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>
+  /** Legacy structural node accepted when at least one historical marker exists. */
+  type LegacyTSLNodeLike = {
+    label?: ((label: string) => unknown) | string
+    setName?: (name: string) => unknown
+  } & ({ uuid: string | undefined; nodeType?: string | null } | { uuid?: string; nodeType: string | null | undefined })
+
+  /** Node type accepted by broad dynamic node-store readers. */
+  type TSLNodeType = three_webgpu.Node | CallableTSLNode
 
   /**
-   * 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)
-   * }
-   * ```
+   * Derive Three's shader node type from an existing node or a supported raw input.
+   * Existing InputNode generics take precedence over structural value normalization.
+   * Both generics must be inferred because Three's UniformNode intersects an unknown-typed
+   * InputNode base with its concrete InputNode specialization.
    */
-  type TSLNodeType = Node | ShaderCallable<Node> | ShaderNodeObject<Node>
+  type UniformNodeType<T> = T extends three_webgpu.UniformNode<infer TNodeType, infer _TValue>
+    ? TNodeType
+    : T extends three_webgpu.InputNode<infer TNodeType, infer _TValue>
+      ? TNodeType
+      : T extends number
+        ? 'float'
+        : T extends boolean
+          ? 'bool'
+          : T extends string | three_webgpu.Color | { r: number; g: number; b: number }
+            ? 'color'
+            : T extends three_webgpu.Vector4 | { x: number; y: number; z: number; w: number }
+              ? 'vec4'
+              : T extends three_webgpu.Vector3 | { x: number; y: number; z: number }
+                ? 'vec3'
+                : T extends three_webgpu.Vector2 | { x: number; y: number }
+                  ? 'vec2'
+                  : T extends three_webgpu.Matrix4
+                    ? 'mat4'
+                    : T extends three_webgpu.Matrix3
+                      ? 'mat3'
+                      : T extends three_webgpu.Matrix2
+                        ? 'mat2'
+                        : unknown
+
+  /** Derive the normalized JavaScript value stored by a uniform node. */
+  type UniformNodeValue<T> = T extends three_webgpu.UniformNode<infer _TNodeType, infer TValue>
+    ? TValue
+    : T extends three_webgpu.InputNode<infer _TNodeType, infer TValue>
+      ? TValue
+      : T extends string | { r: number; g: number; b: number }
+        ? three_webgpu.Color
+        : T extends { x: number; y: number; z: number; w: number }
+          ? three_webgpu.Vector4
+          : T extends { x: number; y: number; z: number }
+            ? three_webgpu.Vector3
+            : T extends { x: number; y: number }
+              ? three_webgpu.Vector2
+              : T extends number
+                ? number
+                : T extends boolean
+                  ? boolean
+                  : T
+
+  /** Three's exact UniformNode with shader and value generics derived from an input. */
+  type UniformNodeFor<T> = three_webgpu.UniformNode<UniformNodeType<T>, UniformNodeValue<T>>
+
+  /** Preserve every input key while mapping values to exact Three uniform nodes. */
+  type UniformNodesFor<T extends UniformInputRecord> = {
+    [K in keyof T]: UniformNodeFor<T[K]>
+  }
+
+  /** Backward-compatible single-parameter uniform alias. */
+  type UniformNode<T = unknown> = UniformNodeFor<T>
 
   /** Flat record of uniform nodes (no nested scopes) */
   type UniformRecord<T extends UniformNode = UniformNode> = Record<string, T>
@@ -1296,7 +1272,7 @@ declare global {
    * 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
+   * - Three.js types: Color, Vector2/3/4, Matrix2/3/4
    * - Plain objects: { x, y, z, w } converted to vectors
    * - TSL nodes: color(), vec3(), float() for type casting
    * - UniformNode: existing uniforms (reused as-is)
@@ -1309,226 +1285,124 @@ declare global {
     | three_webgpu.Vector2
     | three_webgpu.Vector3
     | three_webgpu.Vector4
+    | three_webgpu.Matrix2
     | three_webgpu.Matrix3
     | three_webgpu.Matrix4
-    | three_webgpu.Euler
-    | three_webgpu.Quaternion
-    | { x: number; y?: number; z?: number; w?: number } // Plain objects converted to vectors
-    | Node // TSL nodes like color(), vec3(), float() for type casting
+    | { x: number; y: number }
+    | { x: number; y: number; z: number }
+    | { x: number; y: number; z: number; w: number }
+    | { r: number; g: number; b: number; a?: number } // Plain objects converted to Color
+    | three_webgpu.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' {
+declare global {
   /**
-   * Fn with array parameter destructuring
-   * @example Fn(([uv, skew]) => { ... })
+   * three's own render pipeline type. Named here so the rest of R3F refers to three's shape
+   * rather than `any`. three r183 renamed `PostProcessing` to `RenderPipeline`; our peer floor
+   * is r185, so the new name is the only one.
    */
-  export function Fn<R extends Node = Node>(
-    jsFunc: (inputs: ShaderNodeObject<Node>[]) => ShaderNodeObject<R>,
-  ): ShaderCallable<R>
+  type ThreeRenderPipeline = three_webgpu.RenderPipeline
 
   /**
-   * Fn with object parameter destructuring
-   * @example Fn(({ color, intensity }) => { ... })
+   * The pass `useRenderPipeline` creates for you: three's own `PassNode`, as returned by
+   * `pass(scene, camera)` from `three/tsl`. Referenced from three so members like
+   * `getTextureNode`, `setMRT` and `dispose` track the installed version.
    */
-  export function Fn<T extends Record<string, unknown>, R extends Node = Node>(
-    jsFunc: (inputs: T) => ShaderNodeObject<R>,
-  ): ShaderCallable<R>
+  type ScenePassNode = three_webgpu.PassNode
 
   /**
-   * Fn with array params + layout
-   * @example Fn(([a, b]) => { ... }, { layout: [...] })
+   * Pass record - stores TSL pass nodes for render pipeline.
+   *
+   * `scenePass` is the only key the library owns. It is optional here because this is also the
+   * shape of `state.passes`, which is `{}` before the pipeline exists and again after `reset()`
+   * or `clearPasses()`. Inside the callbacks it is always present; see
+   * {@link RenderPipelineCallbackState}.
+   *
+   * Every other key is user-registered, via a callback's return value. Those are TSL nodes of
+   * any kind, not only passes: texture reads of an MRT attachment, effect nodes, extra
+   * `pass()` instances. `Node` is the common base, so that is the bound. Narrow at the call
+   * site when you need a member, e.g. `passes.velocity as TextureNode`.
+   *
+   * The index signature admits `undefined` because a key may simply not be registered, and
+   * because the optional `scenePass` must be assignable to it: under `skipLibCheck: false` an
+   * optional property whose type excludes `undefined` from the index signature is an error
+   * (TS2411) for every consumer compiling these declarations.
    */
-  export function Fn<R extends Node = Node>(
-    jsFunc: (inputs: ShaderNodeObject<Node>[]) => ShaderNodeObject<R>,
-    layout: { layout?: unknown },
-  ): ShaderCallable<R>
+  interface PassRecord {
+    scenePass?: ScenePassNode
+    [key: string]: three_webgpu.Node | undefined
+  }
 
   /**
-   * Fn with object params + layout
+   * State passed to pipeline callbacks after the active pipeline has been created.
+   *
+   * `passes.scenePass` is required here: the hook installs the default scene pass before either
+   * callback runs, so callbacks can use it without a guard or a cast.
+   *
+   * `renderer` is narrowed to `WebGPURenderer` and `isLegacy` to `false`: the hook throws under
+   * the legacy renderer before either callback can run, so a callback never sees WebGL.
    */
-  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)
- */
-
-
+  type RenderPipelineCallbackState = RootState & {
+    renderPipeline: ThreeRenderPipeline
+    passes: PassRecord & { scenePass: ScenePassNode }
+    renderer: three_webgpu.WebGPURenderer
+    isLegacy: false
+  }
 
-declare global {
-  /** Pass record - stores TSL pass nodes for post-processing */
-  type PassRecord = Record<string, any>
+  /**
+   * What a callback may return to register entries into `state.passes`.
+   *
+   * `scenePass` is reserved. The hook owns that entry and its lifecycle: it caches the pass it
+   * created, and `rebuild()` / `reset()` dispose that cached pass. A callback overwriting the
+   * store entry would leave the store pointing at a node the hook never disposes, and the hook
+   * disposing a pass nothing references. So returning it is a type error.
+   */
+  type RegisteredPasses = Record<string, three_webgpu.Node> & { scenePass?: never }
 
   /** Setup callback - runs first to configure MRT, create additional passes */
-  type PostProcessingSetupCallback = (state: RootState) => PassRecord | void
+  type RenderPipelineSetupCallback = (state: RenderPipelineCallbackState) => RegisteredPasses | void
 
   /** Main callback - runs second to configure outputNode, create effect passes */
-  type PostProcessingMainCallback = (state: RootState) => PassRecord | void
+  type RenderPipelineMainCallback = (state: RenderPipelineCallbackState) => RegisteredPasses | void
 
-  /** Return type for usePostProcessing hook */
-  interface UsePostProcessingReturn {
+  /** The imperative half of useRenderPipeline's return value, present in every state */
+  interface UseRenderPipelineActions {
     /** 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 RenderPipeline 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
+   * Return type for useRenderPipeline hook, discriminated on `isReady`.
+   *
+   * `if (isReady)` narrows `renderPipeline` to non-null, which is what the docs already tell
+   * callers to check. `passes.scenePass` deliberately stays optional in the ready branch:
+   * `clearPasses()` empties the record while leaving the pipeline in place.
    */
-  type DefaultPhase = 'start' | 'input' | 'physics' | 'update' | 'render' | 'finish'
+  type UseRenderPipelineReturn = UseRenderPipelineActions &
+    (
+      | {
+          /** True when RenderPipeline is configured and ready */
+          isReady: true
+          /** RenderPipeline instance */
+          renderPipeline: ThreeRenderPipeline
+        }
+      | {
+          /** False until the pipeline has been created */
+          isReady: false
+          /** Not initialized yet, or torn down by reset() */
+          renderPipeline: null
+        }
+    )
 }
 
 type MutableOrReadonlyParameters<T extends (...args: any) => any> = Parameters<T> | Readonly<Parameters<T>>
@@ -1607,10 +1481,11 @@ 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.
+ * since @types/three has broken inheritance for TSL node subclasses. NodeClass requires
+ * `nodeType`, so this structural key test remains neutral to the selected Three entry.
  */
 type NodeProps<P> = {
-  [K in keyof P as P[K] extends Node | null ? K : never]?: TSLNodeInput
+  [K in keyof P as NonNullable<P[K]> extends { nodeType: string | null } ? K : never]?: TSLNodeInput
 }
 
 interface ReactProps<P> {
@@ -1631,11 +1506,29 @@ type ThreeToJSXElements<T extends Record<string, any>> = {
   [K in keyof T & string as Uncapitalize<K>]: T[K] extends ConstructorRepresentation ? ThreeElement<T[K]> : never
 }
 
+/** Method names of Object3D, excluded from the `primitive` element's typed props. */
+type Object3DMethod = NonNullable<
+  {
+    [K in keyof Object3D]-?: Object3D[K] extends (...args: any[]) => any ? K : never
+  }[keyof Object3D]
+>
+
 type ThreeExports = typeof import('three/webgpu')
 type ThreeElementsImpl = ThreeToJSXElements<ThreeExports>
 
 interface ThreeElements extends Omit<ThreeElementsImpl, 'audio' | 'source' | 'line' | 'path'> {
-  primitive: Omit<ThreeElement<any>, 'args'> & { object: object }
+  /**
+   * `primitive` wraps a pre-existing object, so its props cannot be derived from one class.
+   * Events are typed from `EventHandlers` (`onClick={(e) => ...}` infers `e`), the ref is
+   * untyped, and any other prop is accepted and applied to the object by name. Object3D's own
+   * methods are left out of the typed surface: they return `this`, so a subclass element's
+   * props (`ThreeElements['group']`) could not be spread onto a primitive otherwise.
+   */
+  primitive: Omit<ThreeElement<typeof Object3D>, 'args' | 'object' | 'ref' | Object3DMethod> & {
+    object: object
+    ref?: React.Ref<any>
+    [prop: string]: unknown
+  }
   // Conflicts with DOM types can be accessed through a three* prefix
   threeAudio: ThreeElementsImpl['audio']
   threeSource: ThreeElementsImpl['source']
@@ -1676,6 +1569,7 @@ 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_Object3DMethod = Object3DMethod;
 type three_d_Quaternion = Quaternion;
 type three_d_RaycastableRepresentation = RaycastableRepresentation;
 type three_d_ReactProps<P> = ReactProps<P>;
@@ -1690,7 +1584,7 @@ type three_d_Vector3 = Vector3;
 type three_d_Vector4 = Vector4;
 type three_d_VectorRepresentation = VectorRepresentation;
 declare namespace three_d {
-  export type { three_d_Color as Color, three_d_ElementProps as ElementProps, three_d_Euler as Euler, three_d_EventProps as EventProps, three_d_GeometryProps as GeometryProps, three_d_GeometryTransformProps as GeometryTransformProps, three_d_Layers as Layers, three_d_MathProps as MathProps, three_d_MathRepresentation as MathRepresentation, three_d_MathType as MathType, three_d_MathTypes as MathTypes, three_d_Matrix3 as Matrix3, three_d_Matrix4 as Matrix4, three_d_MutableOrReadonlyParameters as MutableOrReadonlyParameters, three_d_NodeProps as NodeProps, three_d_Quaternion as Quaternion, three_d_RaycastableRepresentation as RaycastableRepresentation, three_d_ReactProps as ReactProps, three_d_TSLNodeInput as TSLNodeInput, three_d_ThreeElement as ThreeElement, three_d_ThreeElements as ThreeElements, three_d_ThreeElementsImpl as ThreeElementsImpl, three_d_ThreeExports as ThreeExports, three_d_ThreeToJSXElements as ThreeToJSXElements, three_d_Vector2 as Vector2, three_d_Vector3 as Vector3, three_d_Vector4 as Vector4, three_d_VectorRepresentation as VectorRepresentation };
+  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_Object3DMethod as Object3DMethod, 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 };
 }
 
 /**
@@ -1700,7 +1594,7 @@ declare namespace three_d {
  * a single WebGPURenderer using Three.js CanvasTarget API.
  *
  * Primary canvas: Has `id` prop, creates its own renderer, registers here
- * Secondary canvas: Has `target="id"` prop, shares primary's renderer via CanvasTarget
+ * Secondary canvas: Has `renderer={{ primaryCanvas: 'id' }}`, shares primary's renderer via CanvasTarget
  */
 
 interface PrimaryCanvasEntry {
@@ -1768,12 +1662,23 @@ type EnvironmentLoaderProps = {
  * const texture = useEnvironment({ preset: 'sunset' })
  * ```
  */
-declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<unknown> | CubeTexture;
+declare function useEnvironment({ files, path, preset, colorSpace, extensions, }?: Partial<EnvironmentLoaderProps>): Texture$1<unknown, THREE$1.TextureEventMap> | CubeTexture<unknown>;
 declare namespace useEnvironment {
     var preload: (preloadOptions?: EnvironmentLoaderPreloadOptions) => void;
     var clear: (clearOptions?: EnvironmentLoaderClearOptions) => void;
 }
-type EnvironmentLoaderPreloadOptions = Omit<EnvironmentLoaderProps, 'encoding'>;
+/**
+ * Options accepted by `useEnvironment.preload`.
+ *
+ * `colorSpace` is deliberately omitted: preload only warms the loader cache, and colorSpace is
+ * applied to the texture by `useEnvironment()` at use time, per consumer. Accepting it here would
+ * advertise an option this function silently ignores.
+ *
+ * This previously read `Omit<…, 'encoding'>` — omitting a key that does not exist on
+ * `EnvironmentLoaderProps`, a leftover from three's pre-`colorSpace` `encoding` API. That made the
+ * type equivalent to the full props, so `colorSpace` was accepted and then dropped on the floor.
+ */
+type EnvironmentLoaderPreloadOptions = Omit<EnvironmentLoaderProps, 'colorSpace'>;
 type EnvironmentLoaderClearOptions = Pick<EnvironmentLoaderProps, 'files' | 'preset'>;
 
 /**
@@ -1817,9 +1722,9 @@ type EnvironmentProps = {
     blur?: number;
     backgroundBlurriness?: number;
     backgroundIntensity?: number;
-    backgroundRotation?: Euler$3;
+    backgroundRotation?: Euler;
     environmentIntensity?: number;
-    environmentRotation?: Euler$3;
+    environmentRotation?: Euler;
     map?: Texture$1;
     preset?: PresetsType;
     scene?: Scene | React$1.RefObject<Scene>;
@@ -1903,7 +1808,7 @@ declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness
 declare function EnvironmentPortal({ children, near, far, resolution, frames, map, background, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, scene, files, path, preset, extensions, }: EnvironmentProps): react_jsx_runtime.JSX.Element;
 declare module '@react-three/fiber' {
     interface ThreeElements {
-        groundProjectedEnvImpl: ThreeElement$1<typeof GroundedSkybox>;
+        groundProjectedEnvImpl: ThreeElement<typeof GroundedSkybox>;
     }
 }
 /**
@@ -2003,12 +1908,32 @@ declare module '@react-three/fiber' {
  */
 declare function Environment(props: EnvironmentProps): react_jsx_runtime.JSX.Element;
 
+/**
+ * Moves every trace of interactivity from one object to its replacement, for reconstruction.
+ *
+ * When `args` or a `primitive`'s `object` changes, R3F builds a new three object and keeps the same
+ * instance. Removing the old object from the interaction state and registering the new one from
+ * scratch makes events *work* again (#3778), but it forgets what was in flight: a pointer resting on
+ * the object fires a second `onPointerEnter` without ever having left, and an active pointer capture
+ * is dropped mid-drag. Rewriting the references instead keeps the interaction continuous across a
+ * swap the user never asked to see (#3744).
+ *
+ * Captures are re-keyed rather than released, so the DOM-level capture on `captureData.target` is
+ * left alone — releasing and re-acquiring it is precisely the glitch being avoided.
+ *
+ * Visibility handlers are deliberately not transferred: that registry is keyed by `object.uuid`, so
+ * the replacement re-registers itself through `applyProps`. The old entry is dropped here so it
+ * cannot outlive the object it described.
+ */
+declare function swapInteractivity(store: RootStore, object: Object3D, newObject: Object3D): void;
 declare function removeInteractivity(store: RootStore, object: Object3D): void;
 declare function createEvents(store: RootStore): {
     handlePointer: (name: string) => (event: DomEvent) => void;
+    flushDeferredPointers: () => void;
+    processDeferredPointer: (event: DomEvent, pointerId: number) => void;
 };
 /** Default R3F event manager for web */
-declare function createPointerEvents(store: RootStore): EventManager<HTMLElement>;
+declare function createPointerEvents(store: RootStore): EventManager<Element>;
 
 /**
  * Gets or creates a memoized loader instance from a loader constructor or returns the loader if it's already an instance.
@@ -2021,419 +1946,13 @@ declare function getLoader<L extends LoaderLike | ConstructorRepresentation<Load
  * Note: this hook's caller must be wrapped with `React.Suspense`
  * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useloader
  */
-declare function useLoader<I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void): I extends any[] ? LoaderResult<L>[] : LoaderResult<L>;
+declare function useLoader<I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void, cacheKey?: InputLike): I extends any[] ? LoaderResult<L>[] : LoaderResult<L>;
 declare namespace useLoader {
-    var preload: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void) => void;
-    var clear: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I) => void;
+    var preload: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void, cacheKey?: InputLike) => void;
+    var clear: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, cacheKey?: InputLike) => void;
     var loader: typeof getLoader;
 }
 
-/**
- * Global Singleton Scheduler - manages the frame loop and job execution for ALL R3F roots.
- *
- * Features:
- * - Single RAF loop for entire application
- * - Root registration (multiple Canvas support)
- * - Global phases for addEffect/addAfterEffect (deprecated)
- * - Per-root job management with phases, priorities, FPS throttling
- * - onIdle callbacks for addTail (deprecated)
- * - Demand mode support via invalidate()
- */
-declare class Scheduler {
-    private static readonly INSTANCE_KEY;
-    private static get instance();
-    private static set instance(value);
-    /**
-     * Get the global scheduler instance (creates if doesn't exist).
-     * Uses HMR data to preserve instance across hot reloads.
-     * @returns {Scheduler} The singleton scheduler instance
-     */
-    static get(): Scheduler;
-    /**
-     * Reset the singleton instance. Stops the loop and clears all state.
-     * Primarily used for testing to ensure clean state between tests.
-     * @returns {void}
-     */
-    static reset(): void;
-    private roots;
-    private phaseGraph;
-    private loopState;
-    private stoppedTime;
-    private nextRootIndex;
-    private globalBeforeJobs;
-    private globalAfterJobs;
-    private nextGlobalIndex;
-    private idleCallbacks;
-    private nextJobIndex;
-    private jobStateListeners;
-    private pendingFrames;
-    private _frameloop;
-    private _independent;
-    private errorHandler;
-    private rootReadyCallbacks;
-    get phases(): string[];
-    get frameloop(): Frameloop;
-    set frameloop(mode: Frameloop);
-    get isRunning(): boolean;
-    get isReady(): boolean;
-    get independent(): boolean;
-    set independent(value: boolean);
-    constructor();
-    /**
-     * Register a root (Canvas) with the scheduler.
-     * The first root to register starts the RAF loop (if frameloop='always').
-     * @param {string} id - Unique identifier for this root
-     * @param {RootOptions} [options] - Optional configuration with getState and onError callbacks
-     * @returns {() => void} Unsubscribe function to remove this root
-     */
-    registerRoot(id: string, options?: RootOptions): () => void;
-    /**
-     * Unregister a root from the scheduler.
-     * Cleans up all job state listeners for this root's jobs.
-     * The last root to unregister stops the RAF loop.
-     * @param {string} id - The root ID to unregister
-     * @returns {void}
-     */
-    unregisterRoot(id: string): void;
-    /**
-     * Subscribe to be notified when a root becomes available.
-     * Fires immediately if a root already exists.
-     * @param {() => void} callback - Function called when first root registers
-     * @returns {() => void} Unsubscribe function
-     */
-    onRootReady(callback: () => void): () => void;
-    /**
-     * Notify all registered root-ready callbacks.
-     * Called when the first root registers.
-     * @returns {void}
-     * @private
-     */
-    private notifyRootReady;
-    /**
-     * Ensure a default root exists for independent mode.
-     * Creates a minimal root with no state provider.
-     * @returns {void}
-     * @private
-     */
-    private ensureDefaultRoot;
-    /**
-     * Trigger error handling for job errors.
-     * Uses the bound error handler if available, otherwise logs to console.
-     * @param {Error} error - The error to handle
-     * @returns {void}
-     */
-    triggerError(error: Error): void;
-    /**
-     * Add a named phase to the scheduler's execution order.
-     * Marks all roots for rebuild to incorporate the new phase.
-     * @param {string} name - The phase name (e.g., 'physics', 'postprocess')
-     * @param {AddPhaseOptions} [options] - Positioning options (before/after other phases)
-     * @returns {void}
-     * @example
-     * scheduler.addPhase('physics', { before: 'update' });
-     * scheduler.addPhase('postprocess', { after: 'render' });
-     */
-    addPhase(name: string, options?: AddPhaseOptions): void;
-    /**
-     * Check if a phase exists in the scheduler.
-     * @param {string} name - The phase name to check
-     * @returns {boolean} True if the phase exists
-     */
-    hasPhase(name: string): boolean;
-    /**
-     * Register a global job that runs once per frame (not per-root).
-     * Used internally by deprecated addEffect/addAfterEffect APIs.
-     * @param {'before' | 'after'} phase - When to run: 'before' all roots or 'after' all roots
-     * @param {string} id - Unique identifier for this global job
-     * @param {(timestamp: number) => void} callback - Function called each frame with RAF timestamp
-     * @returns {() => void} Unsubscribe function to remove this global job
-     * @deprecated Use useFrame with phases instead
-     */
-    registerGlobal(phase: 'before' | 'after', id: string, callback: (timestamp: number) => void): () => void;
-    /**
-     * Register an idle callback that fires when the loop stops.
-     * Used internally by deprecated addTail API.
-     * @param {(timestamp: number) => void} callback - Function called when loop becomes idle
-     * @returns {() => void} Unsubscribe function to remove this idle callback
-     * @deprecated Use demand mode with invalidate() instead
-     */
-    onIdle(callback: (timestamp: number) => void): () => void;
-    /**
-     * Notify all registered idle callbacks.
-     * Called when the loop stops in demand mode.
-     * @param {number} timestamp - The RAF timestamp when idle occurred
-     * @returns {void}
-     * @private
-     */
-    private notifyIdle;
-    /**
-     * Register a job (frame callback) with a specific root.
-     * This is the core registration method used by useFrame internally.
-     * @param {FrameNextCallback} callback - The function to call each frame
-     * @param {JobOptions & { rootId?: string; system?: boolean }} [options] - Job configuration
-     * @param {string} [options.rootId] - Target root ID (defaults to first registered root)
-     * @param {string} [options.id] - Unique job ID (auto-generated if not provided)
-     * @param {string} [options.phase] - Execution phase (defaults to 'update')
-     * @param {number} [options.priority] - Priority within phase (higher = earlier, default 0)
-     * @param {number} [options.fps] - FPS throttle limit
-     * @param {boolean} [options.drop] - Drop frames when behind (default true)
-     * @param {boolean} [options.enabled] - Whether job is active (default true)
-     * @param {boolean} [options.system] - Internal flag for system jobs (not user-facing)
-     * @returns {() => void} Unsubscribe function to remove this job
-     */
-    register(callback: FrameNextCallback, options?: JobOptions & {
-        rootId?: string;
-        system?: boolean;
-    }): () => void;
-    /**
-     * Unregister a job by its ID.
-     * Searches all roots if rootId is not provided.
-     * @param {string} id - The job ID to unregister
-     * @param {string} [rootId] - Optional root ID to search (searches all if not provided)
-     * @returns {void}
-     */
-    unregister(id: string, rootId?: string): void;
-    /**
-     * Update a job's options dynamically.
-     * Searches all roots to find the job by ID.
-     * Phase/constraint changes trigger a rebuild of the sorted job list.
-     * @param {string} id - The job ID to update
-     * @param {Partial<JobOptions>} options - The options to update
-     * @returns {void}
-     */
-    updateJob(id: string, options: Partial<JobOptions>): void;
-    /**
-     * Check if a job is currently paused (disabled).
-     * @param {string} id - The job ID to check
-     * @returns {boolean} True if the job exists and is paused
-     */
-    isJobPaused(id: string): boolean;
-    /**
-     * Subscribe to state changes for a specific job.
-     * Listener is called when job is paused or resumed.
-     * @param {string} id - The job ID to subscribe to
-     * @param {() => void} listener - Callback invoked on state changes
-     * @returns {() => void} Unsubscribe function
-     */
-    subscribeJobState(id: string, listener: () => void): () => void;
-    /**
-     * Notify all listeners that a job's state has changed.
-     * @param {string} id - The job ID that changed
-     * @returns {void}
-     * @private
-     */
-    private notifyJobStateChange;
-    /**
-     * Pause a job by ID (sets enabled=false).
-     * Notifies any subscribed state listeners.
-     * @param {string} id - The job ID to pause
-     * @returns {void}
-     */
-    pauseJob(id: string): void;
-    /**
-     * Resume a paused job by ID (sets enabled=true).
-     * Resets job timing to prevent frame accumulation.
-     * Notifies any subscribed state listeners.
-     * @param {string} id - The job ID to resume
-     * @returns {void}
-     */
-    resumeJob(id: string): void;
-    /**
-     * Start the requestAnimationFrame loop.
-     * Resets timing state (elapsedTime, frameCount) on start.
-     * No-op if already running.
-     * @returns {void}
-     */
-    start(): void;
-    /**
-     * Stop the requestAnimationFrame loop.
-     * Cancels any pending RAF callback.
-     * No-op if not running.
-     * @returns {void}
-     */
-    stop(): void;
-    /**
-     * Request frames to be rendered in demand mode.
-     * Accumulates pending frames (capped at 60) and starts the loop if not running.
-     * No-op if frameloop is not 'demand'.
-     * @param {number} [frames=1] - Number of frames to request
-     * @param {boolean} [stackFrames=false] - Whether to add frames to existing pending count
-     *   - `false` (default): Sets pending frames to the specified value (replaces existing count)
-     *   - `true`: Adds frames to existing pending count (useful for accumulating invalidations)
-     * @returns {void}
-     * @example
-     * // Request a single frame render
-     * scheduler.invalidate();
-     *
-     * @example
-     * // Request 5 frames (e.g., for animations)
-     * scheduler.invalidate(5);
-     *
-     * @example
-     * // Set pending frames to exactly 3 (don't stack with existing)
-     * scheduler.invalidate(3, false);
-     *
-     * @example
-     * // Add 2 more frames to existing pending count
-     * scheduler.invalidate(2, true);
-     */
-    invalidate(frames?: number, stackFrames?: boolean): void;
-    /**
-     * Reset timing state for deterministic testing.
-     * Preserves jobs and roots but resets lastTime, frameCount, elapsedTime, etc.
-     * @returns {void}
-     */
-    resetTiming(): void;
-    /**
-     * Manually execute a single frame for all roots.
-     * Useful for frameloop='never' mode or testing scenarios.
-     * @param {number} [timestamp] - Optional timestamp (defaults to performance.now())
-     * @returns {void}
-     * @example
-     * // Manual control mode
-     * scheduler.frameloop = 'never';
-     * scheduler.step(); // Execute one frame
-     */
-    step(timestamp?: number): void;
-    /**
-     * Manually execute a single job by its ID.
-     * Useful for testing individual job callbacks in isolation.
-     * @param {string} id - The job ID to step
-     * @param {number} [timestamp] - Optional timestamp (defaults to performance.now())
-     * @returns {void}
-     */
-    stepJob(id: string, timestamp?: number): void;
-    /**
-     * Main RAF loop callback.
-     * Executes frame, handles demand mode, and schedules next frame.
-     * @param {number} timestamp - RAF timestamp in milliseconds
-     * @returns {void}
-     * @private
-     */
-    private loop;
-    /**
-     * Execute a single frame across all roots.
-     * Order: globalBefore → each root's jobs → globalAfter
-     * @param {number} timestamp - RAF timestamp in milliseconds
-     * @returns {void}
-     * @private
-     */
-    private executeFrame;
-    /**
-     * Run all global jobs from a job map.
-     * Catches and logs errors without stopping execution.
-     * @param {Map<string, GlobalJob>} jobs - The global jobs map to execute
-     * @param {number} timestamp - RAF timestamp in milliseconds
-     * @returns {void}
-     * @private
-     */
-    private runGlobalJobs;
-    /**
-     * Execute all jobs for a single root in sorted order.
-     * Rebuilds sorted job list if needed, then dispatches each job.
-     * Errors are caught and propagated via triggerError.
-     * @param {RootEntry} root - The root entry to tick
-     * @param {number} timestamp - RAF timestamp in milliseconds
-     * @param {number} delta - Time since last frame in seconds
-     * @returns {void}
-     * @private
-     */
-    private tickRoot;
-    /**
-     * Get the total number of registered jobs across all roots.
-     * Includes both per-root jobs and global before/after jobs.
-     * @returns {number} Total job count
-     */
-    getJobCount(): number;
-    /**
-     * Get all registered job IDs across all roots.
-     * Includes both per-root jobs and global before/after jobs.
-     * @returns {string[]} Array of all job IDs
-     */
-    getJobIds(): string[];
-    /**
-     * Get the number of registered roots (Canvas instances).
-     * @returns {number} Number of registered roots
-     */
-    getRootCount(): number;
-    /**
-     * Check if any user (non-system) jobs are registered in a specific phase.
-     * Used by the default render job to know if a user has taken over rendering.
-     *
-     * @param phase The phase to check
-     * @param rootId Optional root ID to check (checks all roots if not provided)
-     * @returns true if any user jobs exist in the phase
-     */
-    hasUserJobsInPhase(phase: string, rootId?: string): boolean;
-    /**
-     * Generate a unique root ID for automatic root registration.
-     * @returns {string} A unique root ID in the format 'root_N'
-     */
-    generateRootId(): string;
-    /**
-     * Generate a unique job ID.
-     * @returns {string} A unique job ID in the format 'job_N'
-     * @private
-     */
-    private generateJobId;
-    /**
-     * Normalize before/after constraints to a Set.
-     * Handles undefined, single string, or array inputs.
-     * @param {string | string[] | undefined} value - The constraint value(s)
-     * @returns {Set<string>} Normalized Set of constraint strings
-     * @private
-     */
-    private normalizeConstraints;
-}
-/**
- * Get the global scheduler instance.
- * Creates one if it doesn't exist.
- */
-declare const getScheduler: () => Scheduler;
-
-/**
- * Frame hook with phase-based ordering, priority, and FPS throttling.
- *
- * Works both inside and outside Canvas context:
- * - Inside Canvas: Full RootState (gl, scene, camera, etc.)
- * - Outside Canvas (waiting mode): Waits for Canvas to mount, then gets full state
- * - Outside Canvas (independent mode): Fires immediately with timing-only state
- *
- * Returns a controls object for manual stepping, pausing, and resuming.
- *
- * @param callback - Function called each frame with (state, delta). Optional if you only need scheduler access.
- * @param priorityOrOptions - Either a priority number (backwards compat) or options object
- * @returns Controls object with step(), stepAll(), pause(), resume(), isPaused, id, scheduler
- *
- * @example
- * // Simple priority (backwards compat)
- * useFrame((state, delta) => { ... }, 5)
- *
- * @example
- * // With phase-based ordering
- * useFrame((state, delta) => { ... }, { phase: 'physics' })
- *
- * @example
- * // Outside Canvas - waits for Canvas to mount
- * function UI() {
- *   useFrame((state, delta) => { syncUI(state.camera) });
- *   return <button>...</button>;
- * }
- *
- * @example
- * // Independent mode - no Canvas needed
- * getScheduler().independent = true;
- * useFrame((state, delta) => { updateGame(delta) });
- *
- * @example
- * // Scheduler-only access (no callback)
- * const { scheduler } = useFrame()
- * scheduler.pauseJob('some-job-id')
- *
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe
- */
-declare function useFrame(callback?: FrameNextCallback, priorityOrOptions?: number | UseFrameNextOptions): FrameNextControls;
-
 declare const IsObject: (url: unknown) => url is Record<string, string>;
 type TextureArray<T> = T extends string[] ? Texture$1[] : never;
 type TextureRecord<T> = T extends Record<string, string> ? {
@@ -2446,11 +1965,16 @@ type UseTextureOptions<Url extends string[] | string | Record<string, string>> =
     /** Callback when texture(s) finish loading */
     onLoad?: (texture: MappedTextureType<Url>) => void;
     /**
-     * Cache the texture in R3F's global state for access via useTextures().
-     * When true:
+     * Register the texture(s) in R3F's global texture registry for access via useTextures().
+     * When true (the default):
      * - Textures persist until explicitly disposed
-     * - Returns existing cached textures if available (preserving modifications like colorSpace)
-     * @default false
+     * - On mount, returns existing registered textures if available (preserving modifications like colorSpace)
+     *
+     * Reads are taken once at mount — a mounted `useTexture` does not re-render when the registry
+     * changes. To react to registry swaps, use `useTextures(s => s.get(key))` instead.
+     *
+     * Pass `false` to opt out of registry enrollment entirely.
+     * @default true
      */
     cache?: boolean;
 };
@@ -2474,15 +1998,18 @@ type UseTextureOptions<Url extends string[] | string | Record<string, string>> =
  *   normal: '/normal.png'
  * })
  *
- * // With caching - returns same texture object across components
- * // Modifications (colorSpace, wrapS, etc.) are preserved
- * const diffuse = useTexture('/diffuse.png', { cache: true })
+ * // Textures are registered in the global registry by default — the same texture
+ * // object is shared across components and modifications (colorSpace, wrapS, etc.) are preserved
+ * const diffuse = useTexture('/diffuse.png')
  * diffuse.colorSpace = THREE.SRGBColorSpace
  *
  * // Another component gets the SAME texture with colorSpace already set
- * const sameDiffuse = useTexture('/diffuse.png', { cache: true })
+ * const sameDiffuse = useTexture('/diffuse.png')
+ *
+ * // Opt out of registry enrollment for a one-off texture
+ * const scratch = useTexture('/scratch.png', { cache: false })
  *
- * // Access cache directly
+ * // Access the registry directly
  * const { get } = useTextures()
  * const cached = get('/diffuse.png')
  * ```
@@ -2499,63 +2026,80 @@ declare const Texture: ({ children, input, onLoad, cache, }: {
     cache?: boolean;
 }) => react_jsx_runtime.JSX.Element;
 
-type TextureEntry = Texture$1 | {
-    value: Texture$1;
-    [key: string]: any;
+/** Accepted shapes for a registry read: a single key, a list of keys, or a name→key map. */
+type TextureInput = string | string[] | Record<string, string>;
+/** Result of a `get()` read, mirroring the input shape. */
+type TextureResult<Input extends TextureInput> = Input extends string ? Texture$1 | undefined : Input extends string[] ? (Texture$1 | undefined)[] : {
+    [K in keyof Input]: Texture$1 | undefined;
 };
+/** Options for `dispose()`. */
+interface DisposeOptions {
+    /** Dispose even if the texture still has active references (default false). */
+    force?: boolean;
+}
 interface UseTexturesReturn {
-    /** Map of all textures currently in cache */
-    textures: Map<string, TextureEntry>;
-    /** Get a specific texture by key (usually URL) */
-    get: (key: string) => TextureEntry | undefined;
-    /** Check if a texture exists in cache */
-    has: (key: string) => boolean;
-    /** Add a texture to the cache */
-    add: (key: string, value: TextureEntry) => void;
-    /** Add multiple textures to the cache */
-    addMultiple: (items: Map<string, TextureEntry> | Record<string, TextureEntry>) => void;
-    /** Remove a texture from cache (does NOT dispose GPU resources) */
-    remove: (key: string) => void;
-    /** Remove multiple textures from cache */
-    removeMultiple: (keys: string[]) => void;
-    /** Dispose a texture's GPU resources and remove from cache */
-    dispose: (key: string) => void;
-    /** Dispose multiple textures */
-    disposeMultiple: (keys: string[]) => void;
-    /** Dispose ALL cached textures - use with caution */
-    disposeAll: () => void;
+    /** The live registry Map (key → Texture). Treat as read-only. */
+    readonly all: Map<string, Texture$1>;
+    /** Read one texture, an array of textures, or a name→texture record (mirrors the input shape). */
+    get<Input extends TextureInput>(input: Input): TextureResult<Input>;
+    /** Check whether a key exists in the registry. */
+    has(key: string): boolean;
+    /**
+     * Register a texture (or a record of textures) that has no URL — e.g. a render
+     * target or procedural texture. URL-loaded textures are registered automatically
+     * by `useTexture` (registry enrollment is on by default).
+     */
+    add(key: string, texture: Texture$1): void;
+    add(record: Record<string, Texture$1>): void;
+    /**
+     * Dispose a texture's GPU resources and remove it from the registry.
+     * Refcount-aware: if the key is still in use by a mounted `useTexture` consumer it is
+     * skipped (with a warning) unless `{ force: true }` is passed.
+     * @returns true if disposed, false if skipped.
+     */
+    dispose(key: string, options?: DisposeOptions): boolean;
+    /** Dispose every texture in the registry and clear it. Use on scene teardown. */
+    disposeAll(): void;
 }
 /**
- * Hook for managing the global texture cache in R3F state.
+ * Reactive Texture registry — load once with `useTexture`, reach the textures from anywhere.
+ *
+ * This is a registry of plain `Texture` objects (not TSL nodes), so the same texture can feed
+ * a material map, a heightmap sampler, or anything else. It does **not** load — pair it with
+ * `useTexture` for loading (registry enrollment is on by default); `useTextures` is for access and lifecycle.
  *
- * Textures are stored in a Map with URL/path keys for efficient lookup.
- * Useful for sharing texture references across materials and components.
+ * The returned handle is **reactive**: the calling component re-renders when the registry
+ * changes. Pass a selector to scope the subscription to a single read.
  *
  * @example
  * ```tsx
- * const { textures, add, get, remove, has, dispose } = useTextures()
+ * // Load + register once (anywhere in the tree) — registered by default
+ * useTexture({ map: '/diffuse.jpg', normalMap: '/normal.jpg' })
  *
- * // Check if texture is already cached
- * if (!has('/textures/diffuse.png')) {
- *   // Load with useTexture and cache: true, or manually add
- *   const tex = useTexture('/textures/diffuse.png', { cache: true })
- * }
- *
- * // Access cached texture from anywhere
- * const diffuse = get('/textures/diffuse.png')
- * if (diffuse) material.map = diffuse
+ * // Reach them from another component — record form lands straight into a material
+ * const { map, normalMap } = useTextures().get({ map: '/diffuse.jpg', normalMap: '/normal.jpg' })
+ * return <meshStandardMaterial map={map} normalMap={normalMap} />
  *
- * // Remove from cache only (texture still in GPU memory)
- * remove('/textures/old.png')
+ * // A set of heightmaps at once
+ * const [a, b, c] = useTextures().get(['/h0.png', '/h1.png', '/h2.png'])
  *
- * // Fully dispose (frees GPU memory + removes from cache)
- * dispose('/textures/unused.png')
+ * // Register a non-URL texture (render target / procedural)
+ * useTextures().add('rt-main', renderTarget.texture)
  *
- * // Nuclear option - dispose everything
- * disposeAll()
+ * // Deliberate GPU cleanup (refcount-aware; force to override)
+ * useTextures().dispose('/diffuse.jpg')
+ * useTextures().disposeAll() // scene teardown
  * ```
+ *
+ * @remarks
+ * **Future expansion:** an imperative async loader (e.g. `await useTextures().load('/x.jpg')`) is
+ * intentionally not included yet. It would let non-React code (loading screens, dynamic streaming)
+ * populate the registry without Suspense, at the cost of putting loading back into this hook. It
+ * will be added only if a concrete consumer needs imperative loading; for now, loading lives in
+ * `useTexture`.
  */
 declare function useTextures(): UseTexturesReturn;
+declare function useTextures<T>(selector: (registry: UseTexturesReturn) => T): T;
 
 /**
  * Creates a render target compatible with the current renderer.
@@ -2585,20 +2129,15 @@ declare function useTextures(): UseTexturesReturn;
  * const fbo = useRenderTarget(512, 256, { samples: 4 })
  * ```
  */
-declare function useRenderTarget(options?: RenderTargetOptions): RenderTarget | WebGLRenderTarget;
-declare function useRenderTarget(size: number, options?: RenderTargetOptions): RenderTarget | WebGLRenderTarget;
-declare function useRenderTarget(width: number, height: number, options?: RenderTargetOptions): RenderTarget | WebGLRenderTarget;
+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).
  * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usestore
  */
 declare function useStore(): RootStore;
-/**
- * Accesses R3F's internal state, containing renderer, canvas, scene, etc.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usethree
- */
-declare function useThree<T = RootState>(selector?: (state: RootState) => T, equalityFn?: <T>(state: T, newState: T) => boolean): T;
 /**
  * Exposes an object's {@link Instance}.
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useInstanceHandle
@@ -2674,7 +2213,10 @@ declare function addTail(callback: GlobalRenderCallback): () => void;
  * Invalidates the view, requesting a frame to be rendered.
  * In demand mode, this triggers the scheduler to run frames.
  *
- * @param state - Optional root state (ignored in new scheduler, kept for backwards compat)
+ * With a state argument, only that root's jobs run on the requested frames; other
+ * roots on 'demand' stay idle. Without one, every registered root is invalidated.
+ *
+ * @param state - Optional root state; targets the invalidation at that root
  * @param frames - Number of frames to request (default: 1)
  * @param stackFrames - If false, sets pendingFrames to frames. If true, adds to existing pendingFrames (default: false)
  *
@@ -2685,14 +2227,16 @@ declare function invalidate(state?: RootState, frames?: number, stackFrames?: bo
  * Advances the frameloop and runs render effects.
  * Useful for when manually rendering via `frameloop="never"`.
  *
+ * With a state argument, only that root is stepped. Without one, every
+ * registered root is stepped for backwards compatibility.
+ *
  * @param timestamp - The timestamp to use for this frame
  * @param runGlobalEffects - Ignored (kept for backwards compat, global effects always run)
- * @param state - Ignored (kept for backwards compat)
- * @param frame - Ignored (kept for backwards compat)
+ * @param state - Optional root state; targets the manual step at that root
  *
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
  */
-declare function advance(timestamp: number): void;
+declare function advance(timestamp: number, runGlobalEffects?: boolean, state?: RootState): void;
 
 /* eslint-disable @definitelytyped/no-unnecessary-generics */
 declare function ReactReconciler<
@@ -3737,6 +3281,7 @@ declare namespace ReactReconciler {
 
 declare function extend<T extends ConstructorRepresentation>(objects: T): React$1.ExoticComponent<ThreeElement<T>>;
 declare function extend<T extends Catalogue>(objects: T): void;
+declare function extend(objects: Record<string, unknown>): void;
 declare const reconciler: ReactReconciler.Reconciler<RootStore, Instance<any>, void, Instance<any>, never, any>;
 
 declare const isRenderer: (def: any) => boolean;
@@ -3763,11 +3308,6 @@ declare function flushSync<R>(fn: () => R): R;
 declare const context: React$1.Context<RootStore>;
 declare const createStore: (invalidate: (state?: RootState, frames?: number, stackFrames?: boolean) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame) => void) => RootStore;
 
-/**
- * Safely flush async effects when testing, simulating a legacy root.
- * @deprecated Import from React instead. import { act } from 'react'
- */
-declare const act: typeof React$1.act;
 /**
  * An SSR-friendly useLayoutEffect.
  *
@@ -4019,7 +3559,7 @@ declare function getInstanceProps<T = any>(pendingProps: Record<string, unknown>
 declare function prepare<T = any>(target: T, root: RootStore, type: string, props: Instance<T>['props']): Instance<T>;
 /**
  * Triggers an update for an instance.
- * Calls onUpdate callback and invalidates the frame if necessary.
+ * Invalidates the frame if the root is in demand mode.
  *
  * @param instance - Instance to invalidate
  */
@@ -4185,29 +3725,44 @@ declare const hasConstructor: (object: unknown) => object is {
  * Used to identify values that should be resolved from refs after mount.
  */
 declare const FROM_REF: unique symbol;
+/** The marker `fromRef()` returns; resolved by the reconciler in `commitMount`. */
+interface FromRefMarker<T = unknown, R = T> {
+    [FROM_REF]: React$1.RefObject<T | null>;
+    /** Optional transform applied to the resolved ref before assignment. */
+    transform?: (value: T) => R;
+}
 /**
  * Defers prop application until the referenced object is available.
  * Useful for props like `target` that need sibling refs to be populated.
  *
+ * Only top-level props on a three element are resolved: a marker nested inside another value
+ * (an array, an options object) is never seen. When the prop needs the sibling *wrapped* rather
+ * than assigned as-is, pass a `transform`; it runs once the ref is populated and its result is
+ * what gets assigned.
+ *
  * @param ref - React ref object to resolve at mount time
- * @returns A marker value that applyProps will resolve after mount
+ * @param transform - Optional mapping from the resolved object to the value the prop expects
+ * @returns A marker value that the reconciler resolves after mount
  *
  * @example
  * const targetRef = useRef<THREE.Object3D>(null)
  *
  * <group ref={targetRef} position={[-3, -2, -15]} />
  * <spotLight target={fromRef(targetRef)} intensity={100} />
+ *
+ * @example
+ * // Wrap the sibling: a node material's lightsNode needs a LightsNode, not the light itself
+ * <meshPhongNodeMaterial lightsNode={fromRef(lightRef, (light) => lights([light]))} />
  */
 declare function fromRef<T>(ref: React$1.RefObject<T | null>): T;
+declare function fromRef<T, R>(ref: React$1.RefObject<T | null>, transform: (value: T) => R): R;
 /**
  * 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>;
-};
+declare function isFromRef(value: unknown): value is FromRefMarker<any, unknown>;
 
 /**
  * Symbol marker for mount-only method calls.
@@ -4234,7 +3789,15 @@ declare const ONCE: unique symbol;
  * // No arguments
  * <geometry center={once()} />
  */
-declare function once<T>(...args: T[]): T;
+declare function once<A extends unknown[]>(...args: A): OnceValue<A>;
+/**
+ * What `once(...args)` is typed as, so the marker is assignable to the prop it targets:
+ * the single argument itself (`rotateX={once(angle)}`), the argument tuple for multi-argument
+ * methods (`translate={once(x, y, z)}`), or `true` for a bare call (`center={once()}`).
+ *
+ * The runtime value is always the marker object; only the declared type follows the prop.
+ */
+type OnceValue<A extends unknown[]> = A extends [] ? true : A extends [infer Single] ? Single : A;
 /**
  * Type guard to check if a value is a once marker.
  *
@@ -4245,11 +3808,8 @@ 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;
+/** Distinguishes a resource leaf from a nested resource scope. */
+type ResourceLeafGuard<T> = (value: unknown) => value is T;
 
 /**
  * ScopedStore - Type-safe wrapper for nested stores (uniforms, nodes)
@@ -4271,42 +3831,43 @@ declare function Canvas(props: CanvasProps): react_jsx_runtime.JSX.Element;
  * ```
  */
 
-/** Keys reserved for methods (excluded from index signature) */
-type MethodKeys = 'scope' | 'has' | 'keys';
 /**
  * Type-safe wrapper interface for accessing nested store data.
  * Property access returns `T` (assumes leaf node).
  * Use `.scope(key)` for nested object access.
  *
- * Uses mapped type with key filtering to exclude method names from index signature,
- * allowing methods to have their correct return types.
  */
-type ScopedStoreType<T> = {
-    /** Direct property access returns the leaf type T (method keys excluded) */
-    readonly [K in string as K extends MethodKeys ? never : K]: T;
-} & {
+type ScopedStoreMethods<TLeaf> = {
     /** Access a nested scope by key. Returns empty wrapper if scope doesn't exist. */
-    scope(key: string): ScopedStoreType<T>;
+    scope<TScope extends Record<string, TLeaf> = Record<string, TLeaf>>(key: string): ScopedStoreType<TLeaf, TScope>;
     /** Check if a key exists in the store */
     has(key: string): boolean;
     /** Get all keys in the store */
     keys(): string[];
 };
+type ScopedStoreType<TLeaf, TEntries extends Record<string, TLeaf> = Record<string, TLeaf>> = Readonly<TEntries> & ScopedStoreMethods<TLeaf>;
+interface ScopedStoreData<TLeaf> {
+    [key: string]: TLeaf | ScopedStoreData<TLeaf>;
+}
 /**
  * Create a type-safe ScopedStore wrapper around store data.
  * @param data - The raw store data (uniforms or nodes from RootState)
  * @returns A ScopedStoreType wrapper with type-safe access
  */
-declare function createScopedStore<T>(data: Record<string, any>): ScopedStoreType<T>;
+declare function createScopedStore<TLeaf>(data: ScopedStoreData<TLeaf>, isLeaf: ResourceLeafGuard<TLeaf>): ScopedStoreType<TLeaf>;
 /**
  * State type passed to creator functions with ScopedStore wrappers.
- * Provides type-safe access to uniforms and nodes without manual casting.
+ * Provides type-safe access to uniforms, nodes, buffers, and gpuStorage without manual casting.
  */
-type CreatorState = Omit<RootState, 'uniforms' | 'nodes'> & {
+type CreatorState = Omit<RootState, 'uniforms' | 'nodes' | 'buffers' | 'gpuStorage'> & {
     /** Type-safe uniform access - property access returns UniformNode */
     uniforms: ScopedStoreType<UniformNode>;
-    /** Type-safe node access - property access returns TSLNodeType (Node | ShaderCallable | ShaderNodeObject) */
-    nodes: ScopedStoreType<TSLNodeType>;
+    /** Type-safe node access for real, callable, and legacy structural nodes */
+    nodes: ScopedStoreType<NodeLike>;
+    /** Type-safe buffer access - property access returns BufferLike (TypedArrays, BufferAttributes, TSL nodes) */
+    buffers: ScopedStoreType<BufferLike>;
+    /** Type-safe GPU storage access - property access returns StorageLike (StorageTexture, TSL nodes) */
+    gpuStorage: ScopedStoreType<StorageLike>;
 };
 
 /** Creator function that returns uniform inputs (can be raw values or UniformNodes) */
@@ -4318,22 +3879,26 @@ type ClearUniformsFn = (scope?: string) => void;
 /** Function signature for rebuildUniforms util */
 type RebuildUniformsFn = (scope?: string) => void;
 /** Return type with utils included */
-type UniformsWithUtils<T extends UniformRecord = UniformRecord> = T & {
+type UniformsWithUtils<T extends UniformRecord | UniformStore = UniformRecord> = T & {
     removeUniforms: RemoveUniformsFn;
     clearUniforms: ClearUniformsFn;
     rebuildUniforms: RebuildUniformsFn;
 };
-declare function useUniforms(): UniformsWithUtils<UniformRecord & Record<string, UniformRecord>>;
+declare function useUniforms<T extends UniformInputRecord>(creator: UniformCreator<T>): UniformsWithUtils<UniformNodesFor<T>>;
+declare function useUniforms<T extends UniformInputRecord>(creator: UniformCreator<T>, scope: string): UniformsWithUtils<UniformNodesFor<T>>;
+declare function useUniforms<T extends UniformInputRecord>(uniforms: T): UniformsWithUtils<UniformNodesFor<T>>;
+declare function useUniforms<T extends UniformInputRecord>(uniforms: T, scope: string): UniformsWithUtils<UniformNodesFor<T>>;
+declare function useUniforms(): UniformsWithUtils<UniformStore>;
 declare function useUniforms(scope: string): UniformsWithUtils;
-declare function useUniforms<T extends UniformInputRecord>(creator: UniformCreator<T>): UniformsWithUtils<UniformRecord<UniformNode>>;
-declare function useUniforms<T extends UniformInputRecord>(creator: UniformCreator<T>, scope: string): UniformsWithUtils<UniformRecord<UniformNode>>;
-declare function useUniforms<T extends UniformInputRecord>(uniforms: T): UniformsWithUtils<UniformRecord<UniformNode>>;
-declare function useUniforms<T extends UniformInputRecord>(uniforms: T, scope: string): UniformsWithUtils<UniformRecord<UniformNode>>;
+declare function useUniforms<T extends UniformInputRecord>(scope?: string): UniformsWithUtils<UniformNodesFor<T>>;
 /**
  * Global rebuildUniforms function for HMR integration.
- * Clears cached uniforms and increments _hmrVersion to trigger re-creation.
+ * Invalidates cached uniforms and increments _hmrVersion to trigger re-creation.
  * Call this when HMR is detected to refresh all uniform creators.
  *
+ * Resolves to the primary store so shared TSL resources rebuild on the
+ * authoritative store.
+ *
  * @param store - The R3F store (from useStore or context)
  * @param scope - Optional scope to rebuild ('root' for root only, string for specific scope, undefined for all)
  */
@@ -4356,47 +3921,28 @@ declare function clearRootUniforms(set: ReturnType<typeof useStore>['setState'])
 
 /**
  * Supported uniform value types:
- * - Raw values: number, boolean, Vector2, Vector3, Vector4, Color, Matrix3, Matrix4
+ * - Raw values: number, boolean, Vector2, Vector3, Vector4, Color, Matrix2, Matrix3, Matrix4
  * - String colors: '#ff0000', 'red', 'rgb(255,0,0)' (auto-converted to Color)
  * - TSL nodes: color(), vec3(), float(), etc. (for type casting)
  * - UniformNode: existing uniforms (reused as-is)
  */
-type UniformValue = number | boolean | string | Vector2$1 | Vector3$1 | Vector4$1 | Color$2 | Matrix3$1 | Matrix4$1 | Node | UniformNode;
-/**
- * Widen literal types to their base types:
- * - 0 → number
- * - true → boolean
- * - '#ff0000' → Color (string colors are converted to Color objects)
- * - Node → Node (TSL nodes passed through for uniform type casting)
- */
-type Widen<T> = T extends number ? number : T extends boolean ? boolean : T extends string ? Color$2 : T;
-declare function useUniform<T extends UniformValue>(name: string): UniformNode<T>;
-declare function useUniform<T extends UniformValue>(name: string, value: T): UniformNode<Widen<T>>;
+type UniformValue = number | boolean | string | Vector2$1 | Vector3$1 | Vector4$1 | Color$2 | Matrix2 | Matrix3$1 | Matrix4$1 | Node | UniformNode;
+declare function useUniform<T extends UniformValue = UniformValue>(name: string): UniformNodeFor<T>;
+declare function useUniform<T extends UniformValue>(name: string, value: T): UniformNodeFor<T>;
 
 /**
- * Minimal interface for TSL nodes.
- * Used instead of Three.js's Node type because the @types/three definitions
- * have inconsistencies where OperatorNode, ConstNode, etc. don't properly
- * extend Node with all required properties.
+ * Every node representation a creator may return. The definition lives with the store types as
+ * `NodeLike`, so the shape creators return and the shape `state.nodes` holds are one type by
+ * construction: three's real `Node`, the callable proxy `Fn()` returns, or the legacy structural
+ * `{ uuid, nodeType }` shape.
  */
-interface TSLNodeLike {
-    uuid?: string;
-    nodeType?: string | null;
-    /** label method for chaining - sets the node's label and returns self */
-    label?: ((label: string) => TSLNodeLike) | string;
-    setName?: (name: string) => this;
-}
-/** TSL node type - alias for compatibility */
+type TSLNodeLike = NodeLike;
+
+/** Backward-compatible alias covering every accepted node representation. */
 type TSLNode = TSLNodeLike;
-/**
- * A record of TSL nodes - allows mixed node types (OperatorNode, ConstNode, etc.)
- * Uses TSLNodeLike for broader compatibility with Three.js's TSL type definitions.
- */
-type NodeRecord<T extends TSLNodeLike = TSLNodeLike> = Record<string, T>;
 /**
  * Creator function that returns a record of nodes.
- * Uses TSLNodeLike constraint to allow mixed node types
- * (e.g., { n: OperatorNode; color: ConstNode<Color> }) to pass type checking.
+ * Exact creator return inference is preserved within the compatible node constraint.
  */
 type NodeCreator<T extends Record<string, TSLNodeLike>> = (state: CreatorState) => T;
 /** Function signature for removeNodes util */
@@ -4406,20 +3952,25 @@ type ClearNodesFn = (scope?: string) => void;
 /** Function signature for rebuildNodes util */
 type RebuildNodesFn = (scope?: string) => void;
 /** Return type with utils included */
-type NodesWithUtils<T extends Record<string, TSLNodeLike> = Record<string, TSLNodeLike>> = T & {
+type NodesWithUtils<T extends Record<string, unknown> = NodeRecord> = T & {
     removeNodes: RemoveNodesFn;
     clearNodes: ClearNodesFn;
     rebuildNodes: RebuildNodesFn;
 };
-declare function useNodes(): NodesWithUtils<Record<string, TSLNodeLike> & Record<string, Record<string, TSLNodeLike>>>;
-declare function useNodes(scope: string): NodesWithUtils<Record<string, TSLNodeLike>>;
-declare function useNodes<T extends Record<string, TSLNodeLike>>(creator: NodeCreator<T>): NodesWithUtils<T>;
-declare function useNodes<T extends Record<string, TSLNodeLike>>(creator: NodeCreator<T>, scope: string): NodesWithUtils<T>;
+declare function useNodes(): NodesWithUtils<NodeStore>;
+declare function useNodes(scope: string): NodesWithUtils<NodeRecord>;
+declare function useNodes<T extends NodeRecord>(scope?: string): NodesWithUtils<T>;
+declare function useNodes<T extends NodeRecord>(creator: NodeCreator<T>): NodesWithUtils<T>;
+declare function useNodes<T extends NodeRecord>(creator: NodeCreator<T>, scope: string): NodesWithUtils<T>;
+declare function useNodes(creatorOrScope?: NodeCreator<NodeRecord> | string, scope?: string): NodesWithUtils<Record<string, unknown>>;
 /**
  * Global rebuildNodes function for HMR integration.
- * Clears cached nodes and increments _hmrVersion to trigger re-creation.
+ * Invalidates cached nodes and increments _hmrVersion to trigger re-creation.
  * Call this when HMR is detected to refresh all node creators.
  *
+ * Resolves to the primary store so shared TSL resources rebuild on the
+ * authoritative store.
+ *
  * @param store - The R3F store (from useStore or context)
  * @param scope - Optional scope to rebuild ('root' for root only, string for specific scope, undefined for all)
  */
@@ -4470,6 +4021,107 @@ type LocalNodeCreator<T extends Record<string, unknown>> = (state: CreatorState)
  */
 declare function useLocalNodes<T extends Record<string, unknown>>(creator: LocalNodeCreator<T>): T;
 
+/**
+ * A record of buffer-like values - allows mixed types (TypedArrays, BufferAttributes, TSL nodes)
+ */
+type BufferRecordType<T extends BufferLike = BufferLike> = Record<string, T>;
+/**
+ * Creator function that returns a record of buffers.
+ * Receives CreatorState with access to existing buffers, gpuStorage, uniforms, nodes, etc.
+ */
+type BufferCreator<T extends Record<string, BufferLike>> = (state: CreatorState) => T;
+/** Function signature for removeBuffers util */
+type RemoveBuffersFn = (names: string | string[], scope?: string) => void;
+/** Function signature for clearBuffers util */
+type ClearBuffersFn = (scope?: string) => void;
+/** Function signature for rebuildBuffers util */
+type RebuildBuffersFn = (scope?: string) => void;
+/** Function signature for disposeBuffers util - releases GPU resources */
+type DisposeBuffersFn = (names: string | string[], scope?: string) => void;
+/** Return type with utils included */
+type BuffersWithUtils<T extends BufferRecordType | BufferStore = BufferRecordType> = T & {
+    removeBuffers: RemoveBuffersFn;
+    clearBuffers: ClearBuffersFn;
+    rebuildBuffers: RebuildBuffersFn;
+    disposeBuffers: DisposeBuffersFn;
+};
+declare function useBuffers(): BuffersWithUtils<BufferStore>;
+declare function useBuffers(scope: string): BuffersWithUtils<Record<string, BufferLike>>;
+declare function useBuffers<T extends Record<string, BufferLike>>(scope?: string): BuffersWithUtils<T>;
+declare function useBuffers<T extends Record<string, BufferLike>>(creator: BufferCreator<T>): BuffersWithUtils<T>;
+declare function useBuffers<T extends Record<string, BufferLike>>(creator: BufferCreator<T>, scope: string): BuffersWithUtils<T>;
+/**
+ * Global rebuildBuffers function for HMR integration.
+ * Invalidates cached buffers and increments _hmrVersion to trigger re-creation.
+ * Call this when HMR is detected to refresh all buffer creators.
+ *
+ * Resolves to the primary store so shared TSL resources rebuild on the
+ * authoritative store.
+ *
+ * @param store - The R3F store (from useStore or context)
+ * @param scope - Optional scope to rebuild ('root' for root only, string for specific scope, undefined for all)
+ */
+declare function rebuildAllBuffers(store: ReturnType<typeof useStore>, scope?: string): void;
+
+/**
+ * A record of storage-like values - allows mixed types (StorageTexture, Storage3DTexture, TSL nodes)
+ */
+type StorageRecordType<T extends StorageLike = StorageLike> = Record<string, T>;
+/**
+ * Creator function that returns a record of GPU storage objects.
+ * Receives CreatorState with access to existing buffers, gpuStorage, uniforms, nodes, etc.
+ */
+type StorageCreator<T extends Record<string, StorageLike>> = (state: CreatorState) => T;
+/** Function signature for removeStorage util */
+type RemoveStorageFn = (names: string | string[], scope?: string) => void;
+/** Function signature for clearStorage util */
+type ClearStorageFn = (scope?: string) => void;
+/** Function signature for rebuildStorage util */
+type RebuildStorageFn = (scope?: string) => void;
+/** Function signature for disposeStorage util - releases GPU resources */
+type DisposeStorageFn = (names: string | string[], scope?: string) => void;
+/** Return type with utils included */
+type StorageWithUtils<T extends StorageRecordType | StorageStore = StorageRecordType> = T & {
+    removeStorage: RemoveStorageFn;
+    clearStorage: ClearStorageFn;
+    rebuildStorage: RebuildStorageFn;
+    disposeStorage: DisposeStorageFn;
+};
+declare function useGPUStorage(): StorageWithUtils<StorageStore>;
+declare function useGPUStorage(scope: string): StorageWithUtils<Record<string, StorageLike>>;
+declare function useGPUStorage<T extends Record<string, StorageLike>>(scope?: string): StorageWithUtils<T>;
+declare function useGPUStorage<T extends Record<string, StorageLike>>(creator: StorageCreator<T>): StorageWithUtils<T>;
+declare function useGPUStorage<T extends Record<string, StorageLike>>(creator: StorageCreator<T>, scope: string): StorageWithUtils<T>;
+/**
+ * Global rebuildStorage function for HMR integration.
+ * Invalidates cached storage and increments _hmrVersion to trigger re-creation.
+ * Call this when HMR is detected to refresh all storage creators.
+ *
+ * Resolves to the primary store so shared TSL resources rebuild on the
+ * authoritative store.
+ *
+ * @param store - The R3F store (from useStore or context)
+ * @param scope - Optional scope to rebuild ('root' for root only, string for specific scope, undefined for all)
+ */
+declare function rebuildAllStorage(store: ReturnType<typeof useStore>, scope?: string): void;
+
+/**
+ * Re-export from core - useTextures is now a core R3F hook (a reactive Texture registry).
+ *
+ * This file maintains backwards compatibility for existing webgpu imports.
+ */
+
+/**
+ * @deprecated The registry now stores plain `Texture` objects, not TSL nodes. Use `Texture` directly.
+ * Kept as an alias for backwards compatibility.
+ */
+type TextureEntry = Texture$1;
+/**
+ * @deprecated The registry now stores plain `Texture` objects, not TSL nodes. Use `Texture` directly.
+ * Kept as an alias for backwards compatibility.
+ */
+type TextureNode = Texture$1;
+
 interface TextureOperations {
     add: (key: string, value: any) => void;
     addMultiple: (items: Map<string, any> | Record<string, any>) => void;
@@ -4479,32 +4131,36 @@ interface TextureOperations {
 declare function createTextureOperations(set: StoreApi<RootState>['setState']): TextureOperations;
 
 /**
- * Hook for managing WebGPU PostProcessing with automatic scenePass setup.
+ * Hook for managing WebGPU RenderPipeline with automatic scenePass setup.
  *
  * Features:
- * - Creates PostProcessing instance if not exists
+ * - Creates RenderPipeline instance if not exists
  * - Creates default scenePass (no MRT) automatically
  * - Callbacks receive full RootState for flexibility
  * - No auto-cleanup on unmount - use reset() for explicit cleanup
  * - Scene/camera changes trigger scenePass recreation
+ * - A replaced scenePass is disposed once the new graph is installed, so rebuild() does not
+ *   strand its render target (and MRT attachments) on the GPU
+ * - Any run that changes the output node sets RenderPipeline.needsUpdate, so rebuild() actually
+ *   recompiles instead of silently keeping the first compiled graph
  *
  * @param mainCB - Main callback to configure outputNode and create effect passes
  * @param setupCB - Optional setup callback to configure MRT on scenePass
- * @returns { passes, postProcessing, clearPasses, reset, rebuild }
+ * @returns { passes, renderPipeline, clearPasses, reset, rebuild }
  *
  * @example
  * ```tsx
  * // Simple effect
- * usePostProcessing(({ postProcessing, passes }) => {
- *   postProcessing.outputNode = bloom(passes.scenePass.getTextureNode())
+ * useRenderPipeline(({ renderPipeline, passes }) => {
+ *   renderPipeline.outputNode = bloom(passes.scenePass.getTextureNode())
  * })
  *
  * // With MRT setup
- * usePostProcessing(
- *   ({ postProcessing, passes }) => {
+ * useRenderPipeline(
+ *   ({ renderPipeline, passes }) => {
  *     const beauty = passes.scenePass.getTextureNode().toInspector('Color')
  *     const vel = passes.scenePass.getTextureNode('velocity')
- *     postProcessing.outputNode = motionBlur(beauty, vel)
+ *     renderPipeline.outputNode = motionBlur(beauty, vel)
  *   },
  *   ({ passes }) => {
  *     passes.scenePass.setMRT(mrt({ output, velocity }))
@@ -4512,10 +4168,10 @@ declare function createTextureOperations(set: StoreApi<RootState>['setState']):
  * )
  *
  * // Read-only access
- * const { postProcessing, passes } = usePostProcessing()
+ * const { renderPipeline, passes } = useRenderPipeline()
  * ```
  */
-declare function usePostProcessing(mainCB?: PostProcessingMainCallback, setupCB?: PostProcessingSetupCallback): UsePostProcessingReturn;
+declare function useRenderPipeline(mainCB?: RenderPipelineMainCallback, setupCB?: RenderPipelineSetupCallback): UseRenderPipelineReturn;
 
 //* Renderer Props ========================================
 
@@ -4564,5 +4220,32 @@ interface WebGPURootState extends Omit<RootState, 'renderer' | 'gl' | 'internal'
   internal: WebGPUInternalState
 }
 
-export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Scheduler, Texture, _roots, act, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, clearNodeScope, clearRootNodes, clearRootUniforms, clearScope, context, createEvents, createPointerEvents, createPortal, createRoot, createScopedStore, createStore, createTextureOperations, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getScheduler, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, rebuildAllNodes, rebuildAllUniforms, reconciler, registerPrimary, removeInteractivity, removeNodes, removeUniforms, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useLocalNodes, useMutableCallback, useNodes, usePostProcessing, useRenderTarget, useStore, useTexture, useTextures, useThree, useUniform, useUniforms, waitForPrimary };
-export type { Act, AddPhaseOptions, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, Bridge, Camera, CameraProps, CanvasProps, CanvasSchedulerConfig, Catalogue, ClearNodesFn, ClearUniformsFn, Color, ComputeFunction, ConstructorRepresentation, CreatorState, DefaultGLProps, DefaultRendererProps, Disposable, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameControls, FrameNextCallback, FrameNextControls, FrameNextState, FrameState, FrameTimingState, Frameloop, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, WebGPUInternalState as InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, LocalNodeCreator, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeCreator, NodeProps, NodeRecord, NodesWithUtils, NonFunctionKeys, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, WebGPUR3FRenderer as R3FRenderer, RaycastableRepresentation, ReactProps, RebuildNodesFn, RebuildUniformsFn, ReconcilerRoot, RemoveNodesFn, RemoveUniformsFn, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootOptions, WebGPURootState as RootState, RootStore, SchedulerApi, ScopedStoreType, SetBlock, Size, Subscription, TSLNode, TSLNodeInput, TextureEntry, TextureOperations, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UniformCreator, UniformValue, UniformsWithUtils, UseFrameNextOptions, UseFrameOptions, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, WebGPUDefaultProps, WebGPUProps, WebGPUShadowConfig, XRManager };
+/**
+ * @fileoverview WebGPU entry point - WebGPU only, no legacy WebGL
+ *
+ * This entry point is for apps that want to use ONLY WebGPURenderer.
+ * Includes WebGPU-specific hooks (useUniforms, useNodes, useTextures).
+ * Auto-extends THREE with WebGPU node materials (MeshBasicNodeMaterial, etc.)
+ *
+ * Usage:
+ *   import { Canvas, useFrame, useUniforms } from '@react-three/fiber/webgpu'
+ */
+
+/** `useThree` narrowed to WebGPU state — `state.renderer` is a `WebGPURenderer`. */
+type UseThreeWebGPU = <T = WebGPURootState>(selector?: (state: WebGPURootState) => T, equalityFn?: <U>(state: U, newState: U) => boolean) => T;
+/** `useFrame` narrowed to WebGPU state — the callback's `state.renderer` is a `WebGPURenderer`. */
+type UseFrameWebGPU = (callback?: FrameCallback$1<WebGPURootState>, priorityOrOptions?: number | UseFrameNextOptions) => FrameNextControls;
+declare const useThree: UseThreeWebGPU;
+declare const useFrame: UseFrameWebGPU;
+
+/** Canvas props on the WebGPU entry: `onCreated` receives `WebGPURootState`. */
+type WebGPUCanvasProps = Omit<CanvasProps, 'onCreated'> & {
+    /** Callback after the canvas has rendered (but not yet committed); `state.renderer` is a `WebGPURenderer` */
+    onCreated?: (state: WebGPURootState) => void;
+};
+
+/** `Canvas` narrowed to WebGPU state — the same component, `onCreated` typed against `WebGPURootState`. */
+declare const Canvas: (props: WebGPUCanvasProps) => JSX.Element;
+
+export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, clearNodeScope, clearRootNodes, clearRootUniforms, clearScope, context, createEvents, createPointerEvents, createPortal, createRoot, createScopedStore, createStore, createTextureOperations, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, rebuildAllBuffers, rebuildAllNodes, rebuildAllStorage, rebuildAllUniforms, reconciler, registerPrimary, removeInteractivity, removeNodes, removeUniforms, resolve, swapInteractivity, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useBuffers, useEnvironment, useFrame, useGPUStorage, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useLocalNodes, useMutableCallback, useNodes, useRenderPipeline, useRenderTarget, useStore, useTexture, useTextures, useThree, useUniform, useUniforms, waitForPrimary };
+export type { Act, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, Bridge, BufferCreator, BufferLike, BufferRecord, BufferStore, BuffersWithUtils, Camera, CameraProps, WebGPUCanvasProps as CanvasProps, CanvasSchedulerConfig, Catalogue, ClearBuffersFn, ClearNodesFn, ClearStorageFn, ClearUniformsFn, Color, ColorManagementConfig, ComputeFunction, ConstructorRepresentation, CreatorState, DefaultGLProps, DefaultRendererProps, Disposable, DisposeBuffersFn, DisposeOptions, DisposeStorageFn, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameNextCallback, FrameNextState, FrameState, Frameloop, FromRefMarker, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, WebGPUInternalState as InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, LocalNodeCreator, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeCreator, NodeLike, NodeProps, NodeRecord, NodeStore, NodesWithUtils, NonFunctionKeys, Object3DMethod, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, OnceValue, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, WebGPUR3FRenderer as R3FRenderer, RaycastableRepresentation, ReactProps, RebuildBuffersFn, RebuildNodesFn, RebuildStorageFn, RebuildUniformsFn, ReconcilerRoot, RemoveBuffersFn, RemoveNodesFn, RemoveStorageFn, RemoveUniformsFn, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, WebGPURootState as RootState, RootStore, ScopedStoreType, SetBlock, Size, StorageCreator, StorageLike, StorageRecord, StorageStore, StorageWithUtils, Subscription, TSLNode, TSLNodeInput, TSLNodeLike, TextureEntry, TextureInput, TextureNode, TextureOperations, TextureResult, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UniformCreator, UniformValue, UniformsWithUtils, UseFrameWebGPU, UseTextureOptions, UseTexturesReturn, UseThreeWebGPU, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, WebGPUCanvasProps, WebGPUDefaultProps, WebGPUProps, WebGPUShadowConfig, XRManager, XRPointerConfig };