@react-three/fiber 10.0.0-canary.dc0ec15 → 10.0.0-canary.de17310

package/dist/webgpu/index.d.cts

@@ -1,6 +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 { 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 * as webgpu from 'three/webgpu';
+import { CubeRenderTarget, RenderTarget, WebGPURenderer, 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, 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';
@@ -66,7 +66,7 @@ var THREE = /*#__PURE__*/_mergeNamespaces({
   WebGLRendererParameters: WebGLRendererParameters,
   WebGLShadowMap: WebGLShadowMap,
   loadInspector: loadInspector
-}, [three_webgpu]);
+}, [webgpu]);
 
 //* Utility Types ==============================
 
@@ -330,90 +330,6 @@ type FrameNextCallback = FrameCallback$1<RootState>
 /** Alias for FrameNextCallback */
 type FrameCallback = FrameNextCallback
 
-//* Buffer Types (useBuffers) ========================================
-
-/**
- * Buffer-like types for GPU compute and storage operations.
- * Includes raw CPU arrays, Three.js buffer attributes, and TSL buffer nodes.
- *
- * @example
- * ```tsx
- * const { positions, velocities } = useBuffers(() => ({
- *   positions: instancedArray(count, 'vec3'),       // StorageBufferNode
- *   velocities: new Float32Array(count * 3),        // TypedArray
- * }), 'particles')
- * ```
- */
-type BufferLike =
-  | Float32Array
-  | Uint32Array
-  | Int32Array
-  | Float64Array
-  | Uint8Array
-  | Int8Array
-  | Uint16Array
-  | Int16Array
-  | THREE$1.BufferAttribute // Base class for all buffer attributes
-  | THREE$1.InterleavedBufferAttribute
-  | Node // TSL buffer nodes (instancedArray, storage)
-
-/** Flat record of buffer-like values (no nested scopes) */
-type BufferRecord = Record<string, BufferLike>
-
-/**
- * Buffer store that can contain both root-level buffers and scoped buffer objects.
- * Structure: { positions: Float32Array, particles: { vel: StorageBufferNode } }
- */
-type BufferStore = Record<string, BufferLike | BufferRecord>
-
-//* Node Types (useNodes) ========================================
-
-/**
- * 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.
- */
-type NodeLike = TSLNodeType | LegacyTSLNodeLike
-
-/** Flat record of TSL nodes (no nested scopes) */
-type NodeRecord<T extends NodeLike = NodeLike> = Record<string, T>
-
-/**
- * Node store that can contain both root-level nodes and scoped node objects.
- * Structure: { wobble: OperatorNode, fx: { blur: ShaderCallable } }
- */
-type NodeStore = Record<string, NodeLike | NodeRecord>
-
-//* Storage Types (useGPUStorage) ========================================
-
-/**
- * GPU storage types for texture-based storage operations.
- * Includes Three.js storage textures and TSL storage texture nodes.
- *
- * @example
- * ```tsx
- * const { heightMap } = useGPUStorage(() => ({
- *   heightMap: new StorageTexture(512, 512),
- * }), 'terrain')
- * ```
- */
-type StorageLike =
-  | StorageTexture // 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)
-
-/** Flat record of storage-like values (no nested scopes) */
-type StorageRecord = Record<string, StorageLike>
-
-/**
- * Storage store that can contain both root-level storage and scoped storage objects.
- * Structure: { heightMap: StorageTexture, terrain: { normal: StorageTextureNode } }
- */
-type StorageStore = Record<string, StorageLike | StorageRecord>
-
 //* Renderer Types ========================================
 
 /** Default renderer type - union of WebGL and WebGPU renderers */
@@ -586,12 +502,13 @@ interface RootState {
   /** Get current state */
   get: StoreApi<RootState>['getState']
   /**
-   * Reference to the authoritative store for shared TSL resources (uniforms, nodes, etc).
+   * The store of the canvas that owns this root's renderer.
    * - For primary/independent canvases: points to its own store (self-reference)
    * - For secondary canvases: points to the primary canvas's store
+   * - Portals copy it from their parent
    *
-   * Hooks like useNodes/useUniforms should read from primaryStore to ensure
-   * consistent shared state across all canvases sharing a renderer.
+   * Anything shared per renderer rather than per canvas (e.g. @react-three/tsl's resources)
+   * resolves through it.
    */
   primaryStore: RootStore
   /** @deprecated Use `renderer` instead. The instance of the renderer (typed as WebGLRenderer for backwards compat) */
@@ -654,24 +571,10 @@ interface RootState {
   setError: (error: Error | null) => void
   /** Current error state (null when no error) */
   error: Error | null
-  /** Global TSL uniform nodes - root-level uniforms + scoped sub-objects. Use useUniforms() hook */
-  uniforms: UniformStore
-  /** Global TSL nodes - root-level nodes + scoped sub-objects. Use useNodes() hook */
-  nodes: 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 */
   _sizeImperative: boolean
   /** Internal: stored size props from Canvas for reset functionality */
@@ -1202,243 +1105,6 @@ interface LegacyRootState extends Omit<RootState, 'renderer' | 'internal'> {
 
 type RenderTargetOptions = RenderTargetOptions$1
 
-//* Global TSL Types ==============================
-
-declare global {
-  /**
-   * Broad callable-node fallback for dynamic store readers.
-   * Creator hooks preserve the exact function signatures inferred from Three's `Fn`.
-   */
-  type CallableTSLNode = ((...params: never[]) => unknown) & {
-    readonly shaderNode: unknown
-    readonly id: number
-  }
-
-  /** 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
-
-  /**
-   * 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 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>
-
-  /**
-   * Uniform store that can contain both root-level uniforms and scoped uniform objects
-   * Used by state.uniforms which has structure like:
-   * { uTime: UniformNode, player: { uHealth: UniformNode }, enemy: { uHealth: UniformNode } }
-   */
-  type UniformStore = Record<string, UniformNode | UniformRecord>
-
-  /**
-   * Helper to safely access a uniform node from the store.
-   * Use this when accessing state.uniforms to get proper typing.
-   * @example
-   * const uTime = uniforms.uTime as UniformNode<number>
-   * const uColor = uniforms.uColor as UniformNode<import('three/webgpu').Color>
-   */
-  type GetUniform<T = unknown> = UniformNode<T>
-
-  /**
-   * Acceptable input values for useUniforms - raw values that get converted to UniformNodes
-   * Supports:
-   * - Primitives: number, string (color), boolean
-   * - Three.js types: Color, Vector2/3/4, 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)
-   */
-  type UniformValue =
-    | number
-    | string
-    | boolean
-    | three_webgpu.Color
-    | three_webgpu.Vector2
-    | three_webgpu.Vector3
-    | three_webgpu.Vector4
-    | three_webgpu.Matrix2
-    | three_webgpu.Matrix3
-    | three_webgpu.Matrix4
-    | { 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>
-}
-
-declare global {
-  /**
-   * three's own render pipeline type. Named here so the rest of R3F refers to three's shape
-   * rather than `any`. three r183 renamed `PostProcessing` to `RenderPipeline`; our peer floor
-   * is r185, so the new name is the only one.
-   */
-  type ThreeRenderPipeline = three_webgpu.RenderPipeline
-
-  /**
-   * 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.
-   */
-  type ScenePassNode = three_webgpu.PassNode
-
-  /**
-   * 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.
-   */
-  interface PassRecord {
-    scenePass?: ScenePassNode
-    [key: string]: three_webgpu.Node | undefined
-  }
-
-  /**
-   * 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.
-   */
-  type RenderPipelineCallbackState = RootState & {
-    renderPipeline: ThreeRenderPipeline
-    passes: PassRecord & { scenePass: ScenePassNode }
-    renderer: three_webgpu.WebGPURenderer
-    isLegacy: false
-  }
-
-  /**
-   * 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 RenderPipelineSetupCallback = (state: RenderPipelineCallbackState) => RegisteredPasses | void
-
-  /** Main callback - runs second to configure outputNode, create effect passes */
-  type RenderPipelineMainCallback = (state: RenderPipelineCallbackState) => RegisteredPasses | void
-
-  /** The imperative half of useRenderPipeline's return value, present in every state */
-  interface UseRenderPipelineActions {
-    /** Current passes from state */
-    passes: PassRecord
-    /** Clear all passes from state */
-    clearPasses: () => void
-    /** Reset RenderPipeline entirely (clears PP + passes) */
-    reset: () => void
-    /** Re-run setup/main callbacks with current closure values */
-    rebuild: () => void
-  }
-
-  /**
-   * 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 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>>
 
 interface MathRepresentation {
@@ -3874,303 +3540,6 @@ declare function isOnce(value: unknown): value is {
     [ONCE]: any[] | true;
 };
 
-/** 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)
- *
- * Provides TypeScript-friendly access to uniform/node stores where the runtime
- * structure is `Record<string, T | Record<string, T>>` (leaf nodes or nested scopes).
- *
- * The wrapper uses a Proxy to:
- * 1. Return `T` for property access (type assumption: assumes leaf node)
- * 2. Provide `.scope(key)` method for explicit nested access
- * 3. Support iteration methods: has(), keys(), Object.keys(), for...in
- *
- * @example
- * ```tsx
- * useLocalNodes(({ uniforms }) => ({
- *   wobble: sin(uniforms.uTime.mul(2)),           // No cast needed!
- *   playerHealth: uniforms.scope('player').uHealth // Explicit scope access
- * }))
- * ```
- */
-
-/**
- * Type-safe wrapper interface for accessing nested store data.
- * Property access returns `T` (assumes leaf node).
- * Use `.scope(key)` for nested object access.
- *
- */
-type ScopedStoreMethods<TLeaf> = {
-    /** Access a nested scope by key. Returns empty wrapper if scope doesn't exist. */
-    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<TLeaf>(data: ScopedStoreData<TLeaf>, isLeaf: ResourceLeafGuard<TLeaf>): ScopedStoreType<TLeaf>;
-/**
- * State type passed to creator functions with ScopedStore wrappers.
- * Provides type-safe access to uniforms, nodes, buffers, and gpuStorage without manual casting.
- */
-type CreatorState = Omit<RootState, 'uniforms' | 'nodes' | 'buffers' | 'gpuStorage'> & {
-    /** Type-safe uniform access - property access returns UniformNode */
-    uniforms: ScopedStoreType<UniformNode>;
-    /** 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) */
-type UniformCreator<T extends UniformInputRecord = UniformInputRecord> = (state: CreatorState) => T;
-/** Function signature for removeUniforms util */
-type RemoveUniformsFn = (names: string | string[], scope?: string) => void;
-/** Function signature for clearUniforms util */
-type ClearUniformsFn = (scope?: string) => void;
-/** Function signature for rebuildUniforms util */
-type RebuildUniformsFn = (scope?: string) => void;
-/** Return type with utils included */
-type UniformsWithUtils<T extends UniformRecord | UniformStore = UniformRecord> = T & {
-    removeUniforms: RemoveUniformsFn;
-    clearUniforms: ClearUniformsFn;
-    rebuildUniforms: RebuildUniformsFn;
-};
-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>(scope?: string): UniformsWithUtils<UniformNodesFor<T>>;
-/**
- * Global rebuildUniforms function for HMR integration.
- * 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)
- */
-declare function rebuildAllUniforms(store: ReturnType<typeof useStore>, scope?: string): void;
-/**
- * Remove uniforms by name from root level or a scope
- * @deprecated Use `const { removeUniforms } = useUniforms()` instead
- */
-declare function removeUniforms(set: ReturnType<typeof useStore>['setState'], names: string[], scope?: string): void;
-/**
- * Clear all uniforms from a scope (removes the entire scope object)
- * @deprecated Use `const { clearUniforms } = useUniforms()` instead
- */
-declare function clearScope(set: ReturnType<typeof useStore>['setState'], scope: string): void;
-/**
- * Clear all root-level uniforms (preserves scopes)
- * @deprecated Use `const { clearUniforms } = useUniforms()` with `clearUniforms('root')` instead
- */
-declare function clearRootUniforms(set: ReturnType<typeof useStore>['setState']): void;
-
-/**
- * Supported uniform value types:
- * - Raw values: number, boolean, Vector2, Vector3, Vector4, Color, 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 | 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>;
-
-/**
- * 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.
- */
-type TSLNodeLike = NodeLike;
-
-/** Backward-compatible alias covering every accepted node representation. */
-type TSLNode = TSLNodeLike;
-/**
- * Creator function that returns a record of nodes.
- * 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 */
-type RemoveNodesFn = (names: string | string[], scope?: string) => void;
-/** Function signature for clearNodes util */
-type ClearNodesFn = (scope?: string) => void;
-/** Function signature for rebuildNodes util */
-type RebuildNodesFn = (scope?: string) => void;
-/** Return type with utils included */
-type NodesWithUtils<T extends Record<string, unknown> = NodeRecord> = T & {
-    removeNodes: RemoveNodesFn;
-    clearNodes: ClearNodesFn;
-    rebuildNodes: RebuildNodesFn;
-};
-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.
- * 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)
- */
-declare function rebuildAllNodes(store: ReturnType<typeof useStore>, scope?: string): void;
-/**
- * Remove nodes by name from root level or a scope
- * @deprecated Use `const { removeNodes } = useNodes()` instead
- */
-declare function removeNodes(set: ReturnType<typeof useStore>['setState'], names: string[], scope?: string): void;
-/**
- * Clear all nodes from a scope (removes the entire scope object)
- * @deprecated Use `const { clearNodes } = useNodes()` instead
- */
-declare function clearNodeScope(set: ReturnType<typeof useStore>['setState'], scope: string): void;
-/**
- * Clear all root-level nodes (preserves scopes)
- * @deprecated Use `const { clearNodes } = useNodes()` with `clearNodes('root')` instead
- */
-declare function clearRootNodes(set: ReturnType<typeof useStore>['setState']): void;
-
-/** Creator receives CreatorState with ScopedStore wrappers for type-safe access. Returns any record. */
-type LocalNodeCreator<T extends Record<string, unknown>> = (state: CreatorState) => T;
-/**
- * Creates local values that rebuild when uniforms, nodes, or textures change.
- *
- * Unlike `useNodes`, this does NOT register to the global store.
- * Use for component-specific nodes/values that depend on shared resources.
- *
- * @example
- * ```tsx
- * // Destructure what you need from state
- * const { wobble, uTime } = useLocalNodes(({ uniforms, nodes }) => ({
- *   wobble: sin(uniforms.uTime.mul(2)),
- *   uTime: uniforms.uTime,  // can return uniforms too
- * }))
- *
- * // Or access anything else from RootState
- * const { scaled } = useLocalNodes(({ camera, nodes }) => ({
- *   scaled: nodes.basePos.mul(camera.zoom),
- * }))
- *
- * // Type-safe uniform access
- * const { colorNode } = useLocalNodes(({ uniforms }) => {
- *   const uValue = uniforms.myUniform as UniformNode<number>
- *   return { colorNode: mix(colorA, colorB, uValue) }
- * })
- * ```
- */
-declare function useLocalNodes<T extends Record<string, unknown>>(creator: LocalNodeCreator<T>): T;
-
-/**
- * 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).
  *
@@ -4196,49 +3565,6 @@ interface TextureOperations {
 }
 declare function createTextureOperations(set: StoreApi<RootState>['setState']): TextureOperations;
 
-/**
- * Hook for managing WebGPU RenderPipeline with automatic scenePass setup.
- *
- * Features:
- * - 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, renderPipeline, clearPasses, reset, rebuild }
- *
- * @example
- * ```tsx
- * // Simple effect
- * useRenderPipeline(({ renderPipeline, passes }) => {
- *   renderPipeline.outputNode = bloom(passes.scenePass.getTextureNode())
- * })
- *
- * // With MRT setup
- * useRenderPipeline(
- *   ({ renderPipeline, passes }) => {
- *     const beauty = passes.scenePass.getTextureNode().toInspector('Color')
- *     const vel = passes.scenePass.getTextureNode('velocity')
- *     renderPipeline.outputNode = motionBlur(beauty, vel)
- *   },
- *   ({ passes }) => {
- *     passes.scenePass.setMRT(mrt({ output, velocity }))
- *   }
- * )
- *
- * // Read-only access
- * const { renderPipeline, passes } = useRenderPipeline()
- * ```
- */
-declare function useRenderPipeline(mainCB?: RenderPipelineMainCallback, setupCB?: RenderPipelineSetupCallback): UseRenderPipelineReturn;
-
 //* Renderer Props ========================================
 
 type WebGPUDefaultProps = Omit<WebGPURendererParameters, 'canvas'> & BaseRendererProps
@@ -4290,11 +3616,12 @@ interface WebGPURootState extends Omit<RootState, 'renderer' | 'gl' | 'internal'
  * @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.)
+ * The TSL resource hooks (useUniforms, useNodes, useRenderPipeline, ...) are in @react-three/tsl.
  *
  * Usage:
- *   import { Canvas, useFrame, useUniforms } from '@react-three/fiber/webgpu'
+ *   import { Canvas, useFrame } from '@react-three/fiber/webgpu'
+ *   import { useUniforms } from '@react-three/tsl'
  */
 
 /** `useThree` narrowed to WebGPU state — `state.renderer` is a `WebGPURenderer`. */
@@ -4313,5 +3640,5 @@ type WebGPUCanvasProps = Omit<CanvasProps, 'onCreated'> & {
 /** `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, registerRootExtension, removeInteractivity, removeNodes, removeUniforms, resolve, setRenderOverride, 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, RootExtension, 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 };
+export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, 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, reconciler, registerPrimary, registerRootExtension, removeInteractivity, resolve, setRenderOverride, swapInteractivity, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
+export type { Act, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, RootState as BaseRootState, Bridge, Camera, CameraProps, WebGPUCanvasProps as CanvasProps, CanvasSchedulerConfig, Catalogue, Color, ColorManagementConfig, ComputeFunction, ConstructorRepresentation, DefaultGLProps, DefaultRendererProps, Disposable, DisposeOptions, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameNextCallback, FrameNextState, FrameState, Frameloop, 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, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeProps, NonFunctionKeys, Object3DMethod, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, OnceValue, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, WebGPUR3FRenderer as R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootExtension, WebGPURootState as RootState, RootStore, SetBlock, Size, Subscription, TSLNodeInput, TextureEntry, TextureInput, TextureNode, TextureOperations, TextureResult, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UseFrameWebGPU, UseTextureOptions, UseTexturesReturn, UseThreeWebGPU, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, WebGPUCanvasProps, WebGPUDefaultProps, WebGPUProps, WebGPUShadowConfig, XRManager, XRPointerConfig };