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

package/dist/index.d.mts

@@ -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 } 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 } from 'three/webgpu';
 import * as THREE$1 from 'three';
 import { WebGLCubeRenderTarget, WebGLRenderTarget, WebGLRenderer, Color as Color$1, ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1 } from 'three';
 import { WebGLRendererParameters } from 'three/src/renderers/WebGLRenderer.js';
@@ -64,7 +64,7 @@ var THREE = /*#__PURE__*/_mergeNamespaces({
   WebGLRenderer: WebGLRenderer,
   WebGLRendererParameters: WebGLRendererParameters,
   loadInspector: loadInspector
-}, [three_webgpu]);
+}, [webgpu]);
 
 //* Utility Types ==============================
 
@@ -328,90 +328,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 */
@@ -584,12 +500,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) */
@@ -652,24 +569,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 */
@@ -1200,243 +1103,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 {
@@ -3928,4 +3594,4 @@ declare function isOnce(value: unknown): value is {
 declare function Canvas(props: CanvasProps): react_jsx_runtime.JSX.Element;
 
 export { Block, Canvas, Environment, EnvironmentCube, EnvironmentMap, EnvironmentPortal, ErrorBoundary, FROM_REF, IsObject, ONCE, Portal, R3F_BUILD_LEGACY, R3F_BUILD_WEBGPU, REACT_INTERNAL_PROPS, RESERVED_PROPS, three_d as ReactThreeFiber, Texture, _roots, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, 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, Bridge, BufferLike, BufferRecord, BufferStore, Camera, CameraProps, CanvasProps, CanvasSchedulerConfig, Catalogue, Color, ColorManagementConfig, ComputeFunction, ConstructorRepresentation, DefaultGLProps, DefaultRendererProps, Disposable, DisposeOptions, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameNextCallback, FrameNextState, FrameState, Frameloop, FromRefMarker, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeLike, NodeProps, NodeRecord, NodeStore, NonFunctionKeys, Object3DMethod, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, OnceValue, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootExtension, RootState, RootStore, SetBlock, Size, StorageLike, StorageRecord, StorageStore, Subscription, TSLNodeInput, TextureInput, TextureResult, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, XRManager, XRPointerConfig };
+export type { Act, Args, ArgsProp, AttachFnType, AttachType, BackgroundConfig, BackgroundProp, BaseRendererProps, Bridge, Camera, CameraProps, CanvasProps, CanvasSchedulerConfig, Catalogue, Color, ColorManagementConfig, ComputeFunction, ConstructorRepresentation, DefaultGLProps, DefaultRendererProps, Disposable, DisposeOptions, DomEvent, Dpr, ElementProps, EnvironmentLoaderProps, EnvironmentProps, EquConfig, Euler, EventHandlers, EventManager, EventProps, Events, Extensions, FiberRoot, FilterFunction, FrameCallback, FrameNextCallback, FrameNextState, FrameState, Frameloop, FromRefMarker, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeProps, NonFunctionKeys, Object3DMethod, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, OnceValue, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, RootExtension, RootState, RootStore, SetBlock, Size, Subscription, TSLNodeInput, TextureInput, TextureResult, ThreeCamera, ThreeElement, ThreeElements, ThreeElementsImpl, ThreeEvent, ThreeExports, ThreeToJSXElements, UnblockProps, UseTextureOptions, UseTexturesReturn, Vector2, Vector3, Vector4, VectorRepresentation, Viewport, VisibilityEntry, WebGLDefaultProps, WebGLProps, WebGLShadowConfig, XRManager, XRPointerConfig };