@react-three/fiber 10.0.0-canary.9b237a7 → 10.0.0-canary.a1c1d93

package/dist/shared/{fiber.Ddgoyqql.d.mts → fiber.BnIfHyTk.d.cts}

@@ -2,10 +2,9 @@ import * as React$1 from 'react';
 import { ReactNode, Component, RefObject, JSX } from 'react';
 import { Options } from 'react-use-measure';
 import * as THREE from 'three';
-import { Color as Color$1, ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1, ColorSpace, Texture as Texture$1, CubeTexture, Scene, Object3D } from 'three';
-import { n as Properties, a as Size, F as Frameloop, c as Performance, D as Dpr, d as RootStore, k as EventManager, a6 as RootState, i as ComputeFunction, p as IsAllOptional, g as EventHandlers, u as ObjectMap, a5 as InternalState, M as Mutable, O as Overwrite, f as DomEvent, J as ThreeCore, B as Bridge, U as UnblockProps, w as Disposable, q as ThreeCamera, v as EquConfig } from './fiber.Bw8YnGg5.mjs';
+import { ColorRepresentation, Euler as Euler$1, Loader, RenderTargetOptions as RenderTargetOptions$1, ColorSpace, Texture as Texture$1, CubeTexture, Scene, Object3D } from 'three';
+import { K as Properties, c as Size, F as Frameloop, e as Performance, D as Dpr, g as RootStore, p as EventManager, f as RootState, n as ComputeFunction, C as ConstructorRepresentation, $ as ObjectMap, I as InternalState, M as Mutable, O as Overwrite, z as Args, l as EventHandlers, G as InstanceProps, k as DomEvent, H as Instance, y as Catalogue, w as Root, a7 as ThreeCore, Y as Bridge, _ as UnblockProps, a1 as Disposable, U as ThreeCamera, a0 as EquConfig } from './fiber.CLTHZhZp.cjs';
 import { WebGPURenderer, WebGPURendererParameters } from 'three/webgpu';
-import * as react_jsx_runtime from 'react/jsx-runtime';
 
 //* Base Renderer Types =====================================
 
@@ -156,8 +155,11 @@ interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas$1> {
   /** Dimensions to fit the renderer to. Will measure canvas dimensions if omitted */
   size?: Size
   /**
-   * Enables shadows (by default PCFsoft). Can accept `gl.shadowMap` options for fine-tuning,
-   * but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.
+   * Enables shadows (`true` uses `THREE.PCFShadowMap`). Can accept `renderer.shadowMap` options for
+   * fine-tuning, but also strings: 'basic' | 'percentage' | 'soft' | 'variance'.
+   *
+   * `'soft'` is a deprecated alias of `'percentage'`: both map to `THREE.PCFShadowMap`, because three.js
+   * deprecated `PCFSoftShadowMap` and made `PCFShadowMap` soft. Using `'soft'` logs a deprecation notice.
    * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
    */
   shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>
@@ -235,83 +237,6 @@ type InjectState = Partial<
   }
 >
 
-//* Reconciler Types ==============================
-
-// FiberRoot is an opaque internal React type - we define it locally
-// to avoid bundling @types/react-reconciler which causes absolute path issues
-type FiberRoot = any
-
-interface Root {
-  fiber: FiberRoot
-  store: RootStore
-}
-
-type AttachFnType<O = any> = (parent: any, self: O) => () => void
-type AttachType<O = any> = string | AttachFnType<O>
-
-type ConstructorRepresentation<T = any> = new (...args: any[]) => T
-
-interface Catalogue {
-  [name: string]: ConstructorRepresentation
-}
-
-// TODO: handle constructor overloads
-// https://github.com/pmndrs/react-three-fiber/pull/2931
-// https://github.com/microsoft/TypeScript/issues/37079
-type Args<T> = T extends ConstructorRepresentation
-  ? T extends typeof Color$1
-    ? [r: number, g: number, b: number] | [color: ColorRepresentation]
-    : ConstructorParameters<T>
-  : any[]
-
-type ArgsProp<P> = P extends ConstructorRepresentation
-  ? IsAllOptional<ConstructorParameters<P>> extends true
-    ? { args?: Args<P> }
-    : { args: Args<P> }
-  : { args: unknown[] }
-
-type InstanceProps<T = any, P = any> = ArgsProp<P> & {
-  object?: T
-  dispose?: null
-  attach?: AttachType<T>
-}
-
-interface Instance<O = any> {
-  root: RootStore
-  type: string
-  parent: Instance | null
-  children: Instance[]
-  props: InstanceProps<O> & Record<string, unknown>
-  object: O & { __r3f?: Instance<O> }
-  eventCount: number
-  handlers: Partial<EventHandlers>
-  attach?: AttachType<O>
-  previousAttach?: any
-  isHidden: boolean
-  /** Set of props that have been applied via once() */
-  appliedOnce?: Set<string>
-}
-
-interface HostConfig {
-  type: string
-  props: Instance['props']
-  container: RootStore
-  instance: Instance
-  textInstance: void
-  suspenseInstance: Instance
-  hydratableInstance: never
-  formInstance: never
-  publicInstance: Instance['object']
-  hostContext: {}
-  childSet: never
-  timeoutHandle: number | undefined
-  noTimeout: -1
-  TransitionStatus: null
-}
-declare global {
-  var IS_REACT_ACT_ENVIRONMENT: boolean | undefined
-}
-
 //* Loop Types ==============================
 
 type GlobalRenderCallback = (timestamp: number) => void
@@ -618,8 +543,14 @@ type ThreeElement<T extends ConstructorRepresentation> = Mutable<
   Overwrite<ElementProps<T>, Omit<InstanceProps<InstanceType<T>, T>, 'object'>>
 >
 
+/**
+ * Every constructor export of a three namespace as an uncapitalized JSX element. Non-constructor
+ * exports (constants, functions, nested namespaces) are dropped from the keys rather than mapped
+ * to `never`: a single `never`-valued key in `JSX.IntrinsicElements` collapses the props of any
+ * tag typed `React.ElementType` (#3898).
+ */
 type ThreeToJSXElements<T extends Record<string, any>> = {
-  [K in keyof T & string as Uncapitalize<K>]: T[K] extends ConstructorRepresentation ? ThreeElement<T[K]> : never
+  [K in keyof T & string as T[K] extends ConstructorRepresentation ? Uncapitalize<K> : never]: ThreeElement<T[K]>
 }
 
 /** Method names of Object3D, excluded from the `primitive` element's typed props. */
@@ -875,7 +806,7 @@ declare function EnvironmentCube({ background, scene, blur, backgroundBlurriness
  * </EnvironmentPortal>
  * ```
  */
-declare function EnvironmentPortal({ children, near, far, resolution, frames, map, background, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, scene, files, path, preset, extensions, }: EnvironmentProps): react_jsx_runtime.JSX.Element;
+declare function EnvironmentPortal({ children, near, far, resolution, frames, map, background, blur, backgroundBlurriness, backgroundIntensity, backgroundRotation, environmentIntensity, environmentRotation, scene, files, path, preset, extensions, }: EnvironmentProps): React$1.JSX.Element;
 /**
  * Sets up a global environment map for PBR materials and backgrounds.
  * Affects scene.environment and optionally scene.background unless a custom scene is passed.
@@ -971,7 +902,7 @@ declare function EnvironmentPortal({ children, near, far, resolution, frames, ma
  * />
  * ```
  */
-declare function Environment(props: EnvironmentProps): react_jsx_runtime.JSX.Element;
+declare function Environment(props: EnvironmentProps): React$1.JSX.Element;
 
 /**
  * Moves every trace of interactivity from one object to its replacement, for reconstruction.
@@ -1089,7 +1020,7 @@ declare const Texture: ({ children, input, onLoad, cache, }: {
     input: Parameters<typeof useTexture>[0];
     onLoad?: Parameters<typeof useTexture>[1];
     cache?: boolean;
-}) => react_jsx_runtime.JSX.Element;
+}) => React$1.JSX.Element;
 
 /** Accepted shapes for a registry read: a single key, a list of keys, or a name→key map. */
 type TextureInput = string | string[] | Record<string, string>;
@@ -1876,7 +1807,8 @@ declare namespace ReactReconciler {
     type LanePriority = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17;
 
     type Lanes = number;
-    type Lane = number;
+
+    type Lane = number & { __LaneBrand: any };
 
     type Flags = number;
 
@@ -2207,7 +2139,6 @@ declare namespace ReactReconciler {
             onCaughtError: (error: Error, info: BaseErrorInfo) => void,
             onRecoverableError: (error: Error, info: BaseErrorInfo) => void,
             onDefaultTransitionIndicator: () => void,
-            transitionCallbacks: null | TransitionTracingCallbacks,
         ): OpaqueRoot;
 
         createPortal(
@@ -2217,8 +2148,6 @@ declare namespace ReactReconciler {
             key?: string | null,
         ): ReactPortal;
 
-        registerMutableSourceForHydration(root: FiberRoot, mutableSource: MutableSource): void;
-
         createComponentSelector(component: React$AbstractComponent<never, unknown>): ComponentSelector;
 
         createHasPseudoClassSelector(selectors: Selector[]): HasPseudoClassSelector;
@@ -2253,8 +2182,12 @@ declare namespace ReactReconciler {
             isStrictMode: boolean,
             concurrentUpdatesByDefaultOverride: null | boolean,
             identifierPrefix: string,
-            onRecoverableError: (error: Error) => void,
+            onUncaughtError: (error: Error, info: BaseErrorInfo & { errorBoundary?: Component }) => void,
+            onCaughtError: (error: Error, info: BaseErrorInfo) => void,
+            onRecoverableError: (error: Error, info: BaseErrorInfo) => void,
+            onDefaultTransitionIndicator: () => void,
             transitionCallbacks: null | TransitionTracingCallbacks,
+            formState: unknown,
         ): OpaqueRoot;
 
         updateContainer(
@@ -2264,17 +2197,27 @@ declare namespace ReactReconciler {
             callback?: (() => void) | null,
         ): Lane;
 
+        updateContainerSync(
+            element: ReactNode,
+            container: OpaqueRoot,
+            parentComponent?: Component<any, any> | null,
+            callback?: (() => void) | null,
+        ): Lane;
+
         batchedUpdates<A, R>(fn: (a: A) => R, a: A): R;
 
         deferredUpdates<A>(fn: () => A): A;
 
         discreteUpdates<A, B, C, D, R>(fn: (arg0: A, arg1: B, arg2: C, arg3: D) => R, a: A, b: B, c: C, d: D): R;
 
-        flushControlled(fn: () => any): void;
-
         flushSync(): void;
         flushSync<R>(fn: () => R): R;
 
+        flushSyncFromReconciler(): void;
+        flushSyncFromReconciler<R>(fn: () => R): R;
+
+        flushSyncWork(): boolean;
+
         isAlreadyRendering(): boolean;
 
         flushPassiveEffects(): boolean;
@@ -2283,16 +2226,10 @@ declare namespace ReactReconciler {
 
         attemptSynchronousHydration(fiber: Fiber): void;
 
-        attemptDiscreteHydration(fiber: Fiber): void;
-
         attemptContinuousHydration(fiber: Fiber): void;
 
         attemptHydrationAtCurrentPriority(fiber: Fiber): void;
 
-        getCurrentUpdatePriority(): LanePriority;
-
-        runWithPriority<T>(priority: LanePriority, fn: () => T): T;
-
         findHostInstance(component: any): PublicInstance | null;
 
         findHostInstanceWithWarning(component: any, methodName: string): PublicInstance | null;
@@ -2305,18 +2242,80 @@ declare namespace ReactReconciler {
 
         injectIntoDevTools(devToolsConfig: DevToolsConfig<Instance, TextInstance, any>): boolean;
     }
+
+    function defaultOnUncaughtError(error: Error): void;
+    function defaultOnCaughtError(error: Error): void;
+    function defaultOnRecoverableError(error: Error): void;
+
+    function startHostTransition(
+        formFiber: Fiber,
+        pendingState: unknown,
+        action: ((formData: FormData) => void) | null,
+        formData: FormData,
+    ): void;
 }
 
+/**
+ * Registers constructors so they can be rendered as JSX elements.
+ *
+ * - `extend({ OrbitControls })` makes each constructor available under its camelCased key
+ *   (`<orbitControls />`). Values that are not constructors are skipped, so a whole module
+ *   namespace can be passed.
+ * - `extend(MyClass)` registers one constructor and returns a component to render it with.
+ *
+ * Registrations are global, shared by every copy and entry of fiber, and are checked before the
+ * three namespace of a root's renderer when an element name is resolved.
+ *
+ * @example
+ * import { OrbitControls } from 'three/addons/controls/OrbitControls.js'
+ * extend({ OrbitControls })
+ * // <orbitControls args={[camera, gl.domElement]} />
+ *
+ * @example
+ * const Controls = extend(OrbitControls)
+ * // <Controls args={[camera, gl.domElement]} />
+ *
+ * @see https://docs.pmnd.rs/react-three-fiber/api/objects#using-3rd-party-objects-declaratively
+ */
 declare function extend<T extends ConstructorRepresentation>(objects: T): React$1.ExoticComponent<ThreeElement<T>>;
+/** Registers each constructor in `objects` under its key; see the first overload. */
 declare function extend<T extends Catalogue>(objects: T): void;
+/** Registers every constructor in a module namespace, skipping other exports; see the first overload. */
 declare function extend(objects: Record<string, unknown>): void;
 
+/**
+ * R3F's React reconciler: a mutation-mode host config that turns JSX elements into three.js objects.
+ * Each root's {@link RootStore} is its container, and children attach to `internal.container`
+ * (a portal's target) or else the root's `scene`.
+ *
+ * - **Element names** resolve through `extend()` registrations first, then the three namespace of
+ *   the root's renderer. A `three` prefix (`<threeLine>`) is stripped when no element by the
+ *   prefixed name exists. `<primitive object={...}>` wraps an existing object.
+ * - **Construction is deferred** until an instance is attached to a mounted parent, so a tree that
+ *   Suspense discards never creates three objects.
+ * - **Updates** apply only changed props. Changing `args` (or a primitive's `object`) reconstructs
+ *   the object instead; the swap happens in `resetAfterCommit`, before layout effects, so refs
+ *   already point to the new object.
+ * - **Removal** detaches the object and disposes it (at idle priority, or immediately in an `act`
+ *   test environment), unless it is a primitive, a `Scene`, or it or an ancestor has `dispose={null}`.
+ * - **Priority**: not the primary renderer, so it runs alongside react-dom, and update priority
+ *   follows react-dom's event priorities. View-transition commits are flushed synchronously, since
+ *   three has nothing to animate between commits.
+ *
+ * `createRoot`, `createPortal` and `flushSync` drive it; app code rarely needs it directly.
+ */
 declare const reconciler: ReactReconciler.Reconciler<RootStore, Instance<any>, void, Instance<any>, never, any>;
 
 declare const isRenderer: (def: any) => boolean;
 interface OffscreenCanvas extends EventTarget {
 }
 declare const _roots: Map<HTMLCanvasElement | OffscreenCanvas, Root>;
+/**
+ * Unmount the root on `canvas`. The teardown runs once React has committed the unmount, and waits
+ * for a renderer that is still being created. `callback` runs when the root is gone: after the
+ * teardown, and when it disposed a renderer R3F created whose `dispose()` is async (WebGPURenderer
+ * from three r186), after that dispose has settled.
+ */
 declare function unmountComponentAtNode<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
 declare function createPortal(children: ReactNode, container: THREE.Object3D | RefObject<THREE.Object3D | null> | RefObject<THREE.Object3D>, state?: InjectState): JSX.Element;
 interface PortalProps {
@@ -2333,6 +2332,30 @@ declare function Portal({ children, container, state }: PortalProps): JSX.Elemen
  */
 declare function flushSync<R>(fn: () => R): R;
 
+/**
+ * Creates the Zustand store that holds one root's {@link RootState}.
+ *
+ * The store starts unconfigured: the renderer, `camera`, `scene`, `raycaster`, `frustum` and `pointer`
+ * are `null` placeholders until the root's renderer support has loaded and `configure()` in
+ * `renderer.tsx` fills them in. Only core's part of `RootState` is created here; packages building on
+ * fiber add their own fields through root extensions.
+ *
+ * Besides the initial state, the store wires up:
+ * - `state.gl` and `state.renderer` as accessors over `internal.actualRenderer`. `gl` reports a
+ *   deprecation when user code reads it outside legacy mode.
+ * - `rootScene` following `scene` whenever `scene` is set to a real `THREE.Scene`.
+ * - On a size or DPR change: updating the camera and resizing the root's own canvas target (or the
+ *   renderer when there is none).
+ * - On a camera change: adding an unparented camera to `rootScene`, then refreshing the viewport and
+ *   (when `autoUpdateFrustum` is set) the frustum.
+ * - Calling `invalidate(state)` after every state change.
+ *
+ * `createRoot` calls this once per canvas.
+ *
+ * @param invalidate - Requests frames for a root. Bound into `state.invalidate` and called on every store change.
+ * @param advance - Steps a root manually. Bound into `state.advance`.
+ * @returns The root's store, which is also the reconciler container for that root.
+ */
 declare const createStore: (invalidate: (state?: RootState, frames?: number, stackFrames?: boolean) => void, advance: (timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame) => void) => RootStore;
 
 /** Whether any root has loaded a renderer yet. */
@@ -2848,5 +2871,5 @@ declare function isOnce(value: unknown): value is {
     [ONCE]: any[] | true;
 };
 
-export { getThree as B, hasThree as D, whenThree as F, _roots as a$, swapInteractivity as aB, removeInteractivity as aC, createEvents as aD, useInstanceHandle as aE, useGraph as aF, useLoader as aG, IsObject as aH, useTexture as aK, Texture as aL, useTextures as aQ, useEnvironment as aS, addEffect as aT, addAfterEffect as aU, addTail as aV, invalidate as aW, advance as aX, extend as aY, reconciler as aZ, isRenderer as a_, registerPrimary as ao, getPrimary as ap, waitForPrimary as aq, hasPrimary as ar, unregisterPrimary as as, getPrimaryIds as at, EnvironmentMap as av, EnvironmentCube as aw, EnvironmentPortal as ax, Environment as ay, presetsObj as az, unmountComponentAtNode as b0, createPortal as b1, Portal as b2, flushSync as b3, createStore as b4, useIsomorphicLayoutEffect as b5, useMutableCallback as b6, useBridge as b7, Block as b8, ErrorBoundary as b9, isVectorLike as bA, isCopyable as bB, hasConstructor as bC, FROM_REF as bD, fromRef as bF, isFromRef as bG, ONCE as bH, once as bI, isOnce as bK, REACT_INTERNAL_PROPS as ba, findInitialRoot as bb, getRootState as bc, buildGraph as bd, dispose as be, getInstanceProps as bf, prepare as bg, invalidateInstance as bh, RESERVED_PROPS as bi, resolve as bj, attach as bk, detach as bl, diffProps as bm, applyProps as bn, calculateDpr as bo, getUuidPrefix as bp, updateCamera as bq, updateFrustum as br, is as bs, isOrthographicCamera as bt, isRef as bu, isColorRepresentation as bv, isObject3D as bw, isTexture as bx, isLayers as by, isUniform as bz, createPointerEvents as w };
-export type { CameraProps as $, WebGLShadowConfig as A, Color as C, Euler as E, GeometryTransformProps as G, OffscreenCanvas$1 as H, BaseRendererProps as I, RendererFactory as J, Renderer as K, Layers as L, MutableOrReadonlyParameters as M, NodeProps as N, Object3DMethod as O, ColorManagementConfig as P, Quaternion as Q, RaycastableRepresentation as R, DefaultGLProps as S, TSLNodeInput as T, GLProps as U, VectorRepresentation as V, WebGLProps as W, DefaultRendererProps as X, CanvasSchedulerConfig as Y, RendererConfigExtended as Z, RendererProps as _, MathRepresentation as a, RenderProps as a0, InjectState as a1, FiberRoot as a2, Root as a3, AttachFnType as a4, AttachType as a5, Catalogue as a6, Args as a7, ArgsProp as a8, InstanceProps as a9, PresetsType as aA, MappedTextureType as aI, UseTextureOptions as aJ, TextureInput as aM, TextureResult as aN, DisposeOptions as aO, UseTexturesReturn as aP, EnvironmentLoaderProps as aR, Instance as aa, HostConfig as ab, GlobalRenderCallback as ac, GlobalEffectType as ad, BackgroundConfig as ae, BackgroundProp as af, InputLike as ag, LoaderLike as ah, GLTFLike as ai, LoaderInstance as aj, InferLoadResult as ak, LoaderResult as al, Extensions as am, PrimaryCanvasEntry as an, EnvironmentProps as au, MathTypes as b, FromRefMarker as bE, OnceValue as bJ, MathType as c, MathProps as d, Vector2 as e, Vector3 as f, Vector4 as g, Matrix3 as h, Matrix4 as i, EventProps as j, GeometryProps as k, ReactProps as l, ConstructorRepresentation as m, ElementProps as n, ThreeElement as o, ThreeToJSXElements as p, ThreeElementsOf as q, ElementOf as r, CanvasProps as s, LegacyRootState as t, ReconcilerRoot as u, RenderTargetOptions as v, LegacyInternalState as x, LegacyRenderer as y, WebGLDefaultProps as z };
+export { REACT_INTERNAL_PROPS as a$, Texture as aA, useTextures as aF, useEnvironment as aH, addEffect as aI, addAfterEffect as aJ, addTail as aK, invalidate as aL, advance as aM, extend as aN, reconciler as aO, isRenderer as aP, _roots as aQ, unmountComponentAtNode as aR, createPortal as aS, Portal as aT, flushSync as aU, createStore as aV, useIsomorphicLayoutEffect as aW, useMutableCallback as aX, useBridge as aY, Block as aZ, ErrorBoundary as a_, registerPrimary as ad, getPrimary as ae, waitForPrimary as af, hasPrimary as ag, unregisterPrimary as ah, getPrimaryIds as ai, EnvironmentMap as ak, EnvironmentCube as al, EnvironmentPortal as am, Environment as an, presetsObj as ao, swapInteractivity as aq, removeInteractivity as ar, createEvents as as, useInstanceHandle as at, useGraph as au, useLoader as av, IsObject as aw, useTexture as az, findInitialRoot as b0, getRootState as b1, buildGraph as b2, dispose as b3, getInstanceProps as b4, prepare as b5, invalidateInstance as b6, RESERVED_PROPS as b7, resolve as b8, attach as b9, detach as ba, diffProps as bb, applyProps as bc, calculateDpr as bd, getUuidPrefix as be, updateCamera as bf, updateFrustum as bg, is as bh, isOrthographicCamera as bi, isRef as bj, isColorRepresentation as bk, isObject3D as bl, isTexture as bm, isLayers as bn, isUniform as bo, isVectorLike as bp, isCopyable as bq, hasConstructor as br, FROM_REF as bs, fromRef as bu, isFromRef as bv, ONCE as bw, once as bx, isOnce as bz, createPointerEvents as u, getThree as v, hasThree as w, whenThree as x };
+export type { InputLike as $, Renderer as A, BaseRendererProps as B, Color as C, ColorManagementConfig as D, Euler as E, DefaultGLProps as F, GeometryTransformProps as G, GLProps as H, DefaultRendererProps as I, CanvasSchedulerConfig as J, RendererConfigExtended as K, Layers as L, MutableOrReadonlyParameters as M, NodeProps as N, Object3DMethod as O, RendererProps as P, Quaternion as Q, RaycastableRepresentation as R, CameraProps as S, TSLNodeInput as T, RenderProps as U, VectorRepresentation as V, InjectState as W, GlobalRenderCallback as X, GlobalEffectType as Y, BackgroundConfig as Z, BackgroundProp as _, MathRepresentation as a, LoaderLike as a0, GLTFLike as a1, LoaderInstance as a2, InferLoadResult as a3, LoaderResult as a4, Extensions as a5, WebGLDefaultProps as a6, WebGLProps as a7, WebGLShadowConfig as a8, LegacyRenderer as a9, TextureInput as aB, TextureResult as aC, DisposeOptions as aD, UseTexturesReturn as aE, EnvironmentLoaderProps as aG, LegacyInternalState as aa, LegacyRootState as ab, PrimaryCanvasEntry as ac, EnvironmentProps as aj, PresetsType as ap, MappedTextureType as ax, UseTextureOptions as ay, MathTypes as b, FromRefMarker as bt, OnceValue as by, MathType as c, MathProps as d, Vector2 as e, Vector3 as f, Vector4 as g, Matrix3 as h, Matrix4 as i, EventProps as j, GeometryProps as k, ReactProps as l, ElementProps as m, ThreeElement as n, ThreeToJSXElements as o, ThreeElementsOf as p, ElementOf as q, RenderTargetOptions as r, ReconcilerRoot as s, CanvasProps as t, OffscreenCanvas$1 as y, RendererFactory as z };

package/dist/shared/{fiber.Bw8YnGg5.d.cts → fiber.CLTHZhZp.d.cts}

@@ -1,7 +1,7 @@
 import { FrameTimingState, FrameCallback as FrameCallback$1, SchedulerApi } from '@pmndrs/scheduler';
-import * as React from 'react';
 import * as THREE from 'three';
-import { WebGLRenderer, WebGLRenderTarget } from 'three';
+import { WebGLRenderer, WebGLRenderTarget, Color, ColorRepresentation } from 'three';
+import * as React from 'react';
 import * as ThreeWebGPU from 'three/webgpu';
 import { WebGPURenderer, RenderTarget, CanvasTarget } from 'three/webgpu';
 import { StoreApi } from 'zustand';
@@ -477,6 +477,11 @@ interface InternalState {
    * Selected once, from the entry's provider, and copied into portals with the rest of `internal`.
    */
   support: R3FRendererSupport
+  /**
+   * Releases this root's lease on its renderer. The last release disposes a renderer R3F created;
+   * a renderer passed in as an instance is never disposed by R3F.
+   */
+  releaseRenderer?: () => void | Promise<void>
   /** Global scheduler reference (for useFrame hook) */
   scheduler: SchedulerApi | null
   /**
@@ -489,6 +494,8 @@ interface InternalState {
   rootId?: string
   /** Function to unregister this root from the global scheduler */
   unregisterRoot?: () => void
+  /** Function to stop following devicePixelRatio changes */
+  unwatchDpr?: () => void
   /** Container for child attachment (scene for root, original container for portals) */
   container?: THREE.Object3D
   /**
@@ -530,6 +537,12 @@ interface InternalState {
    * Only set when isSecondary is true.
    */
   targetId?: string
+  /**
+   * This secondary stopped sharing because the primary's renderer fell back to its
+   * WebGL2 backend (#3965): it owns the renderer it constructed, so it is not
+   * `isSecondary` (which marks a canvas borrowing another's renderer).
+   */
+  sharedRendererFallback?: boolean
   /**
    * Function to unregister this primary canvas from the registry.
    * Only set when this canvas has an `id` prop.
@@ -654,6 +667,91 @@ interface RootState {
 
 type RootStore = UseBoundStoreWithEqualityFn<StoreApi<RootState>>
 
+//* Reconciler Types ==============================
+
+// FiberRoot is an opaque internal React type - we define it locally
+// to avoid bundling @types/react-reconciler which causes absolute path issues
+type FiberRoot = any
+
+/** A promise tagged with its state, the protocol React's `use` reads */
+type TrackedPromise<T> = Promise<T> &
+  ({ status: 'pending' } | { status: 'fulfilled'; value: T } | { status: 'rejected'; reason: unknown })
+
+interface Root {
+  fiber: FiberRoot
+  store: RootStore
+  /** Set while a teardown waits on React. Configure and render clear it, which cancels the teardown */
+  unmountClaim: symbol | null
+  /** Pending only while a renderer is being created */
+  ready: TrackedPromise<unknown>
+}
+
+type AttachFnType<O = any> = (parent: any, self: O) => () => void
+type AttachType<O = any> = string | AttachFnType<O>
+
+type ConstructorRepresentation<T = any> = new (...args: any[]) => T
+
+interface Catalogue {
+  [name: string]: ConstructorRepresentation
+}
+
+// TODO: handle constructor overloads
+// https://github.com/pmndrs/react-three-fiber/pull/2931
+// https://github.com/microsoft/TypeScript/issues/37079
+type Args<T> = T extends ConstructorRepresentation
+  ? T extends typeof Color
+    ? [r: number, g: number, b: number] | [color: ColorRepresentation]
+    : ConstructorParameters<T>
+  : any[]
+
+type ArgsProp<P> = P extends ConstructorRepresentation
+  ? IsAllOptional<ConstructorParameters<P>> extends true
+    ? { args?: Args<P> }
+    : { args: Args<P> }
+  : { args: unknown[] }
+
+type InstanceProps<T = any, P = any> = ArgsProp<P> & {
+  object?: T
+  dispose?: null
+  attach?: AttachType<T>
+}
+
+interface Instance<O = any> {
+  root: RootStore
+  type: string
+  parent: Instance | null
+  children: Instance[]
+  props: InstanceProps<O> & Record<string, unknown>
+  object: O & { __r3f?: Instance<O> }
+  eventCount: number
+  handlers: Partial<EventHandlers>
+  attach?: AttachType<O>
+  previousAttach?: any
+  isHidden: boolean
+  /** Set of props that have been applied via once() */
+  appliedOnce?: Set<string>
+}
+
+interface HostConfig {
+  type: string
+  props: Instance['props']
+  container: RootStore
+  instance: Instance
+  textInstance: void
+  suspenseInstance: Instance
+  hydratableInstance: never
+  formInstance: never
+  publicInstance: Instance['object']
+  hostContext: {}
+  childSet: never
+  timeoutHandle: number | undefined
+  noTimeout: -1
+  TransitionStatus: null
+}
+declare global {
+  var IS_REACT_ACT_ENVIRONMENT: boolean | undefined
+}
+
 interface RootExtension {
     /** Unique name. Registering the same name again replaces the entry (HMR-safe); roots it already
      *  set up are not set up a second time, but get the new entry's dispose and hmr. */
@@ -695,7 +793,14 @@ declare function useStore(): RootStore;
  */
 declare function useThree<T = RootState>(selector?: (state: RootState) => T, equalityFn?: <T>(state: T, newState: T) => boolean): T;
 
+/**
+ * React context that carries the current root's {@link RootStore}. Each root provides its store and
+ * each portal provides its own scoped one; `useStore`, and every hook built on it, reads it.
+ *
+ * Stored on `globalThis` under `Symbol.for('@react-three/fiber.context')`, so every copy and entry
+ * of fiber shares a single context.
+ */
 declare const context: React.Context<RootStore>;
 
-export { useStore as a2, context as a3, useThree as a7, registerRootExtension as r, setRenderOverride as s };
-export type { ForRegisteredRenderer as $, Act as A, Bridge as B, Camera as C, Dpr as D, Events as E, Frameloop as F, FrameCallback as G, ThreeNamespace as H, Intersection as I, ThreeCore as J, OcclusionSupport as K, WebGPUSupport as L, Mutable as M, NonFunctionKeys as N, Overwrite as O, PointerState as P, RendererSupport as Q, RootExtension as R, Subscription as S, ThreeEvent as T, UnblockProps as U, Viewport as V, WebGLSupport as W, XRManager as X, RendererProvider as Y, Register as Z, RegisteredRenderer as _, Size as a, R3FRenderTarget as a0, R3FRendererSupport as a1, R3FRenderer as a4, InternalState as a5, RootState as a6, RenderCallback as b, Performance as c, RootStore as d, IntersectionEvent as e, DomEvent as f, EventHandlers as g, FilterFunction as h, ComputeFunction as i, XRPointerConfig as j, EventManager as k, PointerCaptureTarget as l, VisibilityEntry as m, Properties as n, IsOptional as o, IsAllOptional as p, ThreeCamera as q, SetBlock as t, ObjectMap as u, EquConfig as v, Disposable as w, FrameNextState as x, FrameState as y, FrameNextCallback as z };
+export { useStore as ah, useThree as ai, context as aj, registerRootExtension as r, setRenderOverride as s };
+export type { ObjectMap as $, AttachFnType as A, ArgsProp as B, ConstructorRepresentation as C, Dpr as D, Events as E, Frameloop as F, InstanceProps as G, Instance as H, InternalState as I, HostConfig as J, Properties as K, IsOptional as L, Mutable as M, NonFunctionKeys as N, Overwrite as O, PointerState as P, IsAllOptional as Q, R3FRenderTarget as R, Subscription as S, ThreeEvent as T, ThreeCamera as U, Viewport as V, Act as W, XRManager as X, Bridge as Y, SetBlock as Z, UnblockProps as _, RootExtension as a, EquConfig as a0, Disposable as a1, FrameNextState as a2, FrameState as a3, FrameNextCallback as a4, FrameCallback as a5, ThreeNamespace as a6, ThreeCore as a7, OcclusionSupport as a8, WebGLSupport as a9, WebGPUSupport as aa, RendererSupport as ab, RendererProvider as ac, Register as ad, RegisteredRenderer as ae, ForRegisteredRenderer as af, R3FRendererSupport as ag, R3FRenderer as b, Size as c, RenderCallback as d, Performance as e, RootState as f, RootStore as g, Intersection as h, Camera as i, IntersectionEvent as j, DomEvent as k, EventHandlers as l, FilterFunction as m, ComputeFunction as n, XRPointerConfig as o, EventManager as p, PointerCaptureTarget as q, VisibilityEntry as t, FiberRoot as u, TrackedPromise as v, Root as w, AttachType as x, Catalogue as y, Args as z };