@react-three/fiber 10.0.0-canary.4a21acb → 10.0.0-canary.4f316e6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/legacy.d.cts CHANGED
@@ -10,7 +10,6 @@ import { FrameTimingState, FrameCallback as FrameCallback$1, SchedulerApi, UseFr
10
10
  export { AddPhaseOptions, FrameControls, FrameNextControls, FrameTimingState, RootOptions, Scheduler, SchedulerApi, UseFrameNextOptions, UseFrameOptions, getScheduler } from '@pmndrs/scheduler';
11
11
  import { Options } from 'react-use-measure';
12
12
  import * as react_jsx_runtime from 'react/jsx-runtime';
13
- import { ThreeElement as ThreeElement$1, Euler as Euler$2 } from '@react-three/fiber';
14
13
  import { GroundedSkybox } from 'three/examples/jsm/objects/GroundedSkybox.js';
15
14
 
16
15
  function _mergeNamespaces(n, m) {
@@ -39,9 +38,9 @@ function _mergeNamespaces(n, m) {
39
38
  declare const R3F_BUILD_LEGACY = true;
40
39
  declare const R3F_BUILD_WEBGPU = false;
41
40
 
42
- declare const Inspector: {
43
- new (): {};
44
- };
41
+ type Inspector = never;
42
+ /** Not available on the legacy (WebGL-only) entry. */
43
+ declare function loadInspector(): Promise<never>;
45
44
  declare const WebGPURenderer: {
46
45
  new (): {};
47
46
  };
@@ -59,7 +58,8 @@ var THREE = /*#__PURE__*/_mergeNamespaces({
59
58
  R3F_BUILD_WEBGPU: R3F_BUILD_WEBGPU,
60
59
  RenderTarget: RenderTarget,
61
60
  RenderTargetCompat: WebGLRenderTarget,
62
- WebGPURenderer: WebGPURenderer
61
+ WebGPURenderer: WebGPURenderer,
62
+ loadInspector: loadInspector
63
63
  }, [THREE$1]);
64
64
 
65
65
  //* Utility Types ==============================
@@ -359,6 +359,33 @@ type BufferRecord = Record<string, BufferLike>
359
359
  */
360
360
  type BufferStore = Record<string, BufferLike | BufferRecord>
361
361
 
362
+ //* Node Types (useNodes) ========================================
363
+
364
+ /**
365
+ * Structural shape of a TSL node as stored on `state.nodes`.
366
+ *
367
+ * Deliberately minimal rather than three's nominal `Node`: in @types/three several node classes
368
+ * TSL hands back (OperatorNode, ConstNode, ...) do not extend `Node` cleanly, so a `Node` bound
369
+ * would reject values `useNodes` creators legitimately return. This is the same shape
370
+ * `useNodes` already constrains creators to (`TSLNodeLike`).
371
+ */
372
+ interface NodeLike {
373
+ uuid?: string
374
+ nodeType?: string | null
375
+ /** label method for chaining - sets the node's label and returns self */
376
+ label?: ((label: string) => NodeLike) | string
377
+ setName?: (name: string) => this
378
+ }
379
+
380
+ /** Flat record of TSL nodes (no nested scopes) */
381
+ type NodeRecord = Record<string, NodeLike>
382
+
383
+ /**
384
+ * Node store that can contain both root-level nodes and scoped node objects.
385
+ * Structure: { wobble: OperatorNode, fx: { blur: ShaderCallable } }
386
+ */
387
+ type NodeStore = Record<string, NodeLike | NodeRecord>
388
+
362
389
  //* Storage Types (useGPUStorage) ========================================
363
390
 
364
391
  /**
@@ -492,11 +519,28 @@ interface InternalState {
492
519
  /** Container for child attachment (scene for root, original container for portals) */
493
520
  container?: THREE$1.Object3D
494
521
  /**
495
- * CanvasTarget for multi-canvas WebGPU rendering.
496
- * Created for all WebGPU canvases to support renderer sharing.
522
+ * The CanvasTarget this root sizes and renders through.
523
+ *
524
+ * A primary (`<Canvas id>`) owns the renderer's default target -- the one three itself built
525
+ * around the canvas element -- so sizing it is sizing the renderer. A secondary owns a target
526
+ * R3F created for its own element. Either way there is exactly one target per canvas element,
527
+ * and the canvas-target job makes it the renderer's active one before this root renders.
528
+ * Absent on WebGL and on an id-less WebGPU canvas, where the renderer is sized directly.
497
529
  * @see https://threejs.org/docs/#api/en/renderers/common/CanvasTarget
498
530
  */
499
531
  canvasTarget?: CanvasTarget
532
+ /**
533
+ * Set when this root's canvas target has been resized and the backend's cached render pass
534
+ * descriptor (which holds a depth-stencil view built once per canvas) is therefore stale.
535
+ *
536
+ * Flushed by the canvas-target job in the `start` phase, which is the only place this root's
537
+ * target is guaranteed to be the renderer's active one — `backend.updateSize()` operates on
538
+ * whatever `getCanvasTarget()` returns, so calling it from the resize subscription would
539
+ * invalidate some other canvas's descriptor instead.
540
+ *
541
+ * @see https://github.com/pmndrs/react-three-fiber/issues/3847
542
+ */
543
+ canvasTargetSizeDirty?: boolean
500
544
  /**
501
545
  * Whether multi-canvas rendering is active.
502
546
  * True when any canvas uses `renderer={{ primaryCanvas: 'id' }}` to share a renderer.
@@ -606,7 +650,7 @@ interface RootState {
606
650
  /** Global TSL uniform nodes - root-level uniforms + scoped sub-objects. Use useUniforms() hook */
607
651
  uniforms: UniformStore
608
652
  /** Global TSL nodes - root-level nodes + scoped sub-objects. Use useNodes() hook */
609
- nodes: Record<string, any>
653
+ nodes: NodeStore
610
654
  /** Global TSL buffer nodes - root-level buffers + scoped sub-objects. Use useBuffers() hook */
611
655
  buffers: BufferStore
612
656
  /** Global GPU storage (textures, etc.) - root-level storage + scoped sub-objects. Use useGPUStorage() hook */
@@ -618,7 +662,7 @@ interface RootState {
618
662
  /** WebGPU RenderPipeline instance - use useRenderPipeline() hook */
619
663
  renderPipeline: ThreeRenderPipeline | null
620
664
  /** Global TSL pass nodes for render pipeline - use useRenderPipeline() hook */
621
- passes: Record<string, any>
665
+ passes: PassRecord
622
666
  /** Internal version counter for HMR - incremented by rebuildNodes/rebuildUniforms to bust memoization */
623
667
  _hmrVersion: number
624
668
  /** Internal: whether setSize() has taken ownership of canvas dimensions */
@@ -706,12 +750,19 @@ type DefaultRendererProps = {
706
750
  */
707
751
  interface CanvasSchedulerConfig {
708
752
  /**
709
- * Render this canvas after another canvas completes.
710
- * Pass the `id` of another canvas.
753
+ * Run this Canvas root before the referenced Canvas root id(s).
754
+ */
755
+ before?: string | string[]
756
+ /**
757
+ * Run this Canvas root after the referenced Canvas root id(s).
758
+ */
759
+ after?: string | string[]
760
+ /**
761
+ * Numeric root order. Lower values run first.
711
762
  */
712
- after?: string
763
+ order?: number
713
764
  /**
714
- * Limit this canvas's render rate (frames per second).
765
+ * Limit this Canvas's default render job (frames per second).
715
766
  */
716
767
  fps?: number
717
768
  }
@@ -1159,7 +1210,33 @@ declare global {
1159
1210
  * ergonomics. The result is three's structural type, so members stay in sync with the
1160
1211
  * installed three instead of needing to be mirrored by hand.
1161
1212
  */
1162
- type UniformNode<T = unknown> = three_webgpu.UniformNode<unknown, T>
1213
+ type UniformNode<T = unknown> = three_webgpu.UniformNode<UniformNodeTypeFor<T>, T>
1214
+
1215
+ /**
1216
+ * three's node type name for a uniform value type, mirroring the `uniform()` overloads.
1217
+ * A `UniformNode<number>` is a `Node<'float'>`, so TSL math (`.mul`, `.add`, ...) accepts it.
1218
+ * Unknown or unlisted value types resolve to `unknown`, which TSL math rejects: narrow with
1219
+ * `as UniformNode<number>` (or the matching value type) at the call site.
1220
+ */
1221
+ type UniformNodeTypeFor<T> = T extends number
1222
+ ? 'float'
1223
+ : T extends boolean
1224
+ ? 'bool'
1225
+ : T extends three_webgpu.Color
1226
+ ? 'color'
1227
+ : T extends three_webgpu.Vector2
1228
+ ? 'vec2'
1229
+ : T extends three_webgpu.Vector3
1230
+ ? 'vec3'
1231
+ : T extends three_webgpu.Vector4
1232
+ ? 'vec4'
1233
+ : T extends three_webgpu.Matrix2
1234
+ ? 'mat2'
1235
+ : T extends three_webgpu.Matrix3
1236
+ ? 'mat3'
1237
+ : T extends three_webgpu.Matrix4
1238
+ ? 'mat4'
1239
+ : unknown
1163
1240
 
1164
1241
  /**
1165
1242
  * ShaderCallable - the return type of Fn()
@@ -1312,30 +1389,97 @@ declare global {
1312
1389
  */
1313
1390
  type ThreeRenderPipeline = three_webgpu.RenderPipeline
1314
1391
 
1315
- /** Pass record - stores TSL pass nodes for render pipeline */
1316
- type PassRecord = Record<string, any>
1392
+ /**
1393
+ * The pass `useRenderPipeline` creates for you: three's own `PassNode`, as returned by
1394
+ * `pass(scene, camera)` from `three/tsl`. Referenced from three so members like
1395
+ * `getTextureNode`, `setMRT` and `dispose` track the installed version.
1396
+ */
1397
+ type ScenePassNode = three_webgpu.PassNode
1398
+
1399
+ /**
1400
+ * Pass record - stores TSL pass nodes for render pipeline.
1401
+ *
1402
+ * `scenePass` is the only key the library owns. It is optional here because this is also the
1403
+ * shape of `state.passes`, which is `{}` before the pipeline exists and again after `reset()`
1404
+ * or `clearPasses()`. Inside the callbacks it is always present; see
1405
+ * {@link RenderPipelineCallbackState}.
1406
+ *
1407
+ * Every other key is user-registered, via a callback's return value. Those are TSL nodes of
1408
+ * any kind, not only passes: texture reads of an MRT attachment, effect nodes, extra
1409
+ * `pass()` instances. `Node` is the common base, so that is the bound. Narrow at the call
1410
+ * site when you need a member, e.g. `passes.velocity as TextureNode`.
1411
+ */
1412
+ interface PassRecord {
1413
+ scenePass?: ScenePassNode
1414
+ [key: string]: three_webgpu.Node
1415
+ }
1416
+
1417
+ /**
1418
+ * State passed to pipeline callbacks after the active pipeline has been created.
1419
+ *
1420
+ * `passes.scenePass` is required here: the hook installs the default scene pass before either
1421
+ * callback runs, so callbacks can use it without a guard or a cast.
1422
+ *
1423
+ * `renderer` is narrowed to `WebGPURenderer` and `isLegacy` to `false`: the hook throws under
1424
+ * the legacy renderer before either callback can run, so a callback never sees WebGL.
1425
+ */
1426
+ type RenderPipelineCallbackState = RootState & {
1427
+ renderPipeline: ThreeRenderPipeline
1428
+ passes: PassRecord & { scenePass: ScenePassNode }
1429
+ renderer: three_webgpu.WebGPURenderer
1430
+ isLegacy: false
1431
+ }
1432
+
1433
+ /**
1434
+ * What a callback may return to register entries into `state.passes`.
1435
+ *
1436
+ * `scenePass` is reserved. The hook owns that entry and its lifecycle: it caches the pass it
1437
+ * created, and `rebuild()` / `reset()` dispose that cached pass. A callback overwriting the
1438
+ * store entry would leave the store pointing at a node the hook never disposes, and the hook
1439
+ * disposing a pass nothing references. So returning it is a type error.
1440
+ */
1441
+ type RegisteredPasses = Record<string, three_webgpu.Node> & { scenePass?: never }
1317
1442
 
1318
1443
  /** Setup callback - runs first to configure MRT, create additional passes */
1319
- type RenderPipelineSetupCallback = (state: RootState) => PassRecord | void
1444
+ type RenderPipelineSetupCallback = (state: RenderPipelineCallbackState) => RegisteredPasses | void
1320
1445
 
1321
1446
  /** Main callback - runs second to configure outputNode, create effect passes */
1322
- type RenderPipelineMainCallback = (state: RootState) => PassRecord | void
1447
+ type RenderPipelineMainCallback = (state: RenderPipelineCallbackState) => RegisteredPasses | void
1323
1448
 
1324
- /** Return type for useRenderPipeline hook */
1325
- interface UseRenderPipelineReturn {
1449
+ /** The imperative half of useRenderPipeline's return value, present in every state */
1450
+ interface UseRenderPipelineActions {
1326
1451
  /** Current passes from state */
1327
1452
  passes: PassRecord
1328
- /** RenderPipeline instance (null if not initialized) */
1329
- renderPipeline: ThreeRenderPipeline | null
1330
1453
  /** Clear all passes from state */
1331
1454
  clearPasses: () => void
1332
1455
  /** Reset RenderPipeline entirely (clears PP + passes) */
1333
1456
  reset: () => void
1334
1457
  /** Re-run setup/main callbacks with current closure values */
1335
1458
  rebuild: () => void
1336
- /** True when RenderPipeline is configured and ready */
1337
- isReady: boolean
1338
1459
  }
1460
+
1461
+ /**
1462
+ * Return type for useRenderPipeline hook, discriminated on `isReady`.
1463
+ *
1464
+ * `if (isReady)` narrows `renderPipeline` to non-null, which is what the docs already tell
1465
+ * callers to check. `passes.scenePass` deliberately stays optional in the ready branch:
1466
+ * `clearPasses()` empties the record while leaving the pipeline in place.
1467
+ */
1468
+ type UseRenderPipelineReturn = UseRenderPipelineActions &
1469
+ (
1470
+ | {
1471
+ /** True when RenderPipeline is configured and ready */
1472
+ isReady: true
1473
+ /** RenderPipeline instance */
1474
+ renderPipeline: ThreeRenderPipeline
1475
+ }
1476
+ | {
1477
+ /** False until the pipeline has been created */
1478
+ isReady: false
1479
+ /** Not initialized yet, or torn down by reset() */
1480
+ renderPipeline: null
1481
+ }
1482
+ )
1339
1483
  }
1340
1484
 
1341
1485
  type MutableOrReadonlyParameters<T extends (...args: any) => any> = Parameters<T> | Readonly<Parameters<T>>
@@ -1635,9 +1779,9 @@ type EnvironmentProps = {
1635
1779
  blur?: number;
1636
1780
  backgroundBlurriness?: number;
1637
1781
  backgroundIntensity?: number;
1638
- backgroundRotation?: Euler$2;
1782
+ backgroundRotation?: Euler;
1639
1783
  environmentIntensity?: number;
1640
- environmentRotation?: Euler$2;
1784
+ environmentRotation?: Euler;
1641
1785
  map?: Texture$1;
1642
1786
  preset?: PresetsType;
1643
1787
  scene?: Scene | React$1.RefObject<Scene>;
@@ -1721,7 +1865,7 @@ declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness
1721
1865
  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;
1722
1866
  declare module '@react-three/fiber' {
1723
1867
  interface ThreeElements {
1724
- groundProjectedEnvImpl: ThreeElement$1<typeof GroundedSkybox>;
1868
+ groundProjectedEnvImpl: ThreeElement<typeof GroundedSkybox>;
1725
1869
  }
1726
1870
  }
1727
1871
  /**
@@ -1821,6 +1965,24 @@ declare module '@react-three/fiber' {
1821
1965
  */
1822
1966
  declare function Environment(props: EnvironmentProps): react_jsx_runtime.JSX.Element;
1823
1967
 
1968
+ /**
1969
+ * Moves every trace of interactivity from one object to its replacement, for reconstruction.
1970
+ *
1971
+ * When `args` or a `primitive`'s `object` changes, R3F builds a new three object and keeps the same
1972
+ * instance. Removing the old object from the interaction state and registering the new one from
1973
+ * scratch makes events *work* again (#3778), but it forgets what was in flight: a pointer resting on
1974
+ * the object fires a second `onPointerEnter` without ever having left, and an active pointer capture
1975
+ * is dropped mid-drag. Rewriting the references instead keeps the interaction continuous across a
1976
+ * swap the user never asked to see (#3744).
1977
+ *
1978
+ * Captures are re-keyed rather than released, so the DOM-level capture on `captureData.target` is
1979
+ * left alone — releasing and re-acquiring it is precisely the glitch being avoided.
1980
+ *
1981
+ * Visibility handlers are deliberately not transferred: that registry is keyed by `object.uuid`, so
1982
+ * the replacement re-registers itself through `applyProps`. The old entry is dropped here so it
1983
+ * cannot outlive the object it described.
1984
+ */
1985
+ declare function swapInteractivity(store: RootStore, object: Object3D, newObject: Object3D): void;
1824
1986
  declare function removeInteractivity(store: RootStore, object: Object3D): void;
1825
1987
  declare function createEvents(store: RootStore): {
1826
1988
  handlePointer: (name: string) => (event: DomEvent) => void;
@@ -1861,7 +2023,7 @@ declare namespace useLoader {
1861
2023
  *
1862
2024
  * @param callback - Function called each frame with (state, delta). Optional if you only need scheduler access.
1863
2025
  * @param priorityOrOptions - Either a priority number (backwards compat) or options object
1864
- * @returns Controls object with step(), stepAll(), pause(), resume(), isPaused, id, scheduler
2026
+ * @returns Controls object with step(), stepAll(), invalidate(), pause(), resume(), isPaused, id, rootId, scheduler
1865
2027
  *
1866
2028
  * @example
1867
2029
  * // Simple priority (backwards compat)
@@ -2157,7 +2319,10 @@ declare function addTail(callback: GlobalRenderCallback): () => void;
2157
2319
  * Invalidates the view, requesting a frame to be rendered.
2158
2320
  * In demand mode, this triggers the scheduler to run frames.
2159
2321
  *
2160
- * @param state - Optional root state (ignored in new scheduler, kept for backwards compat)
2322
+ * With a state argument, only that root's jobs run on the requested frames; other
2323
+ * roots on 'demand' stay idle. Without one, every registered root is invalidated.
2324
+ *
2325
+ * @param state - Optional root state; targets the invalidation at that root
2161
2326
  * @param frames - Number of frames to request (default: 1)
2162
2327
  * @param stackFrames - If false, sets pendingFrames to frames. If true, adds to existing pendingFrames (default: false)
2163
2328
  *
@@ -2168,14 +2333,16 @@ declare function invalidate(state?: RootState, frames?: number, stackFrames?: bo
2168
2333
  * Advances the frameloop and runs render effects.
2169
2334
  * Useful for when manually rendering via `frameloop="never"`.
2170
2335
  *
2336
+ * With a state argument, only that root is stepped. Without one, every
2337
+ * registered root is stepped for backwards compatibility.
2338
+ *
2171
2339
  * @param timestamp - The timestamp to use for this frame
2172
2340
  * @param runGlobalEffects - Ignored (kept for backwards compat, global effects always run)
2173
- * @param state - Ignored (kept for backwards compat)
2174
- * @param frame - Ignored (kept for backwards compat)
2341
+ * @param state - Optional root state; targets the manual step at that root
2175
2342
  *
2176
2343
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
2177
2344
  */
2178
- declare function advance(timestamp: number): void;
2345
+ declare function advance(timestamp: number, runGlobalEffects?: boolean, state?: RootState): void;
2179
2346
 
2180
2347
  /* eslint-disable @definitelytyped/no-unnecessary-generics */
2181
2348
  declare function ReactReconciler<
@@ -3246,11 +3413,6 @@ declare function flushSync<R>(fn: () => R): R;
3246
3413
  declare const context: React$1.Context<RootStore>;
3247
3414
  declare const createStore: (invalidate: (state?: RootState, frames?: number, stackFrames?: boolean) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame) => void) => RootStore;
3248
3415
 
3249
- /**
3250
- * Safely flush async effects when testing, simulating a legacy root.
3251
- * @deprecated Import from React instead. import { act } from 'react'
3252
- */
3253
- declare const act: typeof React$1.act;
3254
3416
  /**
3255
3417
  * An SSR-friendly useLayoutEffect.
3256
3418
  *
@@ -3734,5 +3896,5 @@ declare function isOnce(value: unknown): value is {
3734
3896
  */
3735
3897
  declare function Canvas(props: CanvasProps): react_jsx_runtime.JSX.Element;
3736
3898
 
3737
- 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, act, addAfterEffect, addEffect, addTail, advance, applyProps, attach, buildGraph, calculateDpr, context, createEvents, createPointerEvents, createPortal, createRoot, createStore, detach, diffProps, dispose, createPointerEvents as events, extend, findInitialRoot, flushSync, fromRef, getInstanceProps, getPrimary, getPrimaryIds, getRootState, getUuidPrefix, hasConstructor, hasPrimary, invalidate, invalidateInstance, is, isColorRepresentation, isCopyable, isFromRef, isObject3D, isOnce, isOrthographicCamera, isRef, isRenderer, isTexture, isVectorLike, once, prepare, presetsObj, reconciler, registerPrimary, removeInteractivity, resolve, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
3738
- 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, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, LegacyInternalState as InternalState, Intersection, IntersectionEvent, IsAllOptional, IsOptional, Layers, LegacyInternalState, LegacyRenderer, LegacyRootState, LoaderInstance, LoaderLike, LoaderResult, MappedTextureType, MathProps, MathRepresentation, MathType, MathTypes, Matrix3, Matrix4, Mutable, MutableOrReadonlyParameters, NodeProps, NonFunctionKeys, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, LegacyRenderer as R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, LegacyRootState as 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 };
3899
+ 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, removeInteractivity, resolve, swapInteractivity, unmountComponentAtNode, unregisterPrimary, updateCamera, updateFrustum, useBridge, useEnvironment, useFrame, useGraph, useInstanceHandle, useIsomorphicLayoutEffect, useLoader, useMutableCallback, useRenderTarget, useStore, useTexture, useTextures, useThree, waitForPrimary };
3900
+ 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, GLProps, GLTFLike, GeometryProps, GeometryTransformProps, GlobalEffectType, GlobalRenderCallback, HostConfig, InferLoadResult, InjectState, InputLike, Instance, InstanceProps, LegacyInternalState as 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, ObjectMap, OffscreenCanvas$1 as OffscreenCanvas, Overwrite, Performance, PointerCaptureTarget, PointerState, PresetsType, PrimaryCanvasEntry, Properties, Quaternion, LegacyRenderer as R3FRenderer, RaycastableRepresentation, ReactProps, ReconcilerRoot, RenderCallback, RenderProps, RenderTargetOptions, Renderer, RendererConfigExtended, RendererFactory, RendererProps, Root, LegacyRootState as 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 };