@react-three/fiber 9.6.1 → 9.8.0

package/dist/declarations/react-reconciler/index.d.ts

@@ -610,7 +610,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;
 
@@ -941,7 +942,6 @@ declare namespace ReactReconciler {
             onCaughtError: (error: Error, info: BaseErrorInfo) => void,
             onRecoverableError: (error: Error, info: BaseErrorInfo) => void,
             onDefaultTransitionIndicator: () => void,
-            transitionCallbacks: null | TransitionTracingCallbacks,
         ): OpaqueRoot;
 
         createPortal(
@@ -951,8 +951,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;
@@ -987,8 +985,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(
@@ -998,17 +1000,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;
@@ -1017,16 +1029,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;
@@ -1039,6 +1045,17 @@ 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;
 }
 
 export = ReactReconciler;

package/dist/declarations/src/core/events.d.ts

@@ -1,94 +1,94 @@
-import * as THREE from 'three';
-import { type Properties } from "./utils.js";
-import type { RootState, RootStore } from "./store.js";
-export interface Intersection extends THREE.Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: THREE.Object3D;
-}
-export interface IntersectionEvent<TSourceEvent> extends Intersection {
-    /** The event source (the object which registered the handler) */
-    eventObject: THREE.Object3D;
-    /** An array of intersections */
-    intersections: Intersection[];
-    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
-    unprojectedPoint: THREE.Vector3;
-    /** Normalized event coordinates */
-    pointer: THREE.Vector2;
-    /** Delta between first click and this event */
-    delta: number;
-    /** The ray that pierced it */
-    ray: THREE.Ray;
-    /** The camera that was used by the raycaster */
-    camera: Camera;
-    /** stopPropagation will stop underlying handlers from firing */
-    stopPropagation: () => void;
-    /** The original host event */
-    nativeEvent: TSourceEvent;
-    /** If the event was stopped by calling stopPropagation */
-    stopped: boolean;
-}
-export type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
-export type ThreeEvent<TEvent> = IntersectionEvent<TEvent> & Properties<TEvent>;
-export type DomEvent = PointerEvent | MouseEvent | WheelEvent;
-export interface Events {
-    onClick: EventListener;
-    onContextMenu: EventListener;
-    onDoubleClick: EventListener;
-    onWheel: EventListener;
-    onPointerDown: EventListener;
-    onPointerUp: EventListener;
-    onPointerLeave: EventListener;
-    onPointerMove: EventListener;
-    onPointerCancel: EventListener;
-    onLostPointerCapture: EventListener;
-}
-export interface EventHandlers {
-    onClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
-    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
-    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
-    onPointerMissed?: (event: MouseEvent) => void;
-    onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
-    onWheel?: (event: ThreeEvent<WheelEvent>) => void;
-    onLostPointerCapture?: (event: ThreeEvent<PointerEvent>) => void;
-}
-export type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
-export type ComputeFunction = (event: DomEvent, root: RootState, previous?: RootState) => void;
-export interface EventManager<TTarget> {
-    /** Determines if the event layer is active */
-    enabled: boolean;
-    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
-    priority: number;
-    /** The compute function needs to set up the raycaster and an xy- pointer  */
-    compute?: ComputeFunction;
-    /** The filter can re-order or re-structure the intersections  */
-    filter?: FilterFunction;
-    /** The target node the event layer is tied to */
-    connected?: TTarget;
-    /** All the pointer event handlers through which the host forwards native events */
-    handlers?: Events;
-    /** Allows re-connecting to another target */
-    connect?: (target: TTarget) => void;
-    /** Removes all existing events handlers from the target */
-    disconnect?: () => void;
-    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
-     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
-     */
-    update?: () => void;
-}
-export interface PointerCaptureTarget {
-    intersection: Intersection;
-    target: Element;
-}
-/** This function transfers all interactivity state from one object instance to another. Used when swapping instances due to reconstruction. */
-export declare function swapInteractivity(store: RootStore, object: THREE.Object3D, newObject: THREE.Object3D): void;
-export declare function removeInteractivity(store: RootStore, object: THREE.Object3D): void;
-export declare function createEvents(store: RootStore): {
-    handlePointer: (name: string) => (event: DomEvent) => void;
-};
+import * as THREE from 'three';
+import { type Properties } from "./utils.js";
+import type { RootState, RootStore } from "./store.js";
+export interface Intersection extends THREE.Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+}
+export interface IntersectionEvent<TSourceEvent> extends Intersection {
+    /** The event source (the object which registered the handler) */
+    eventObject: THREE.Object3D;
+    /** An array of intersections */
+    intersections: Intersection[];
+    /** vec3.set(pointer.x, pointer.y, 0).unproject(camera) */
+    unprojectedPoint: THREE.Vector3;
+    /** Normalized event coordinates */
+    pointer: THREE.Vector2;
+    /** Delta between first click and this event */
+    delta: number;
+    /** The ray that pierced it */
+    ray: THREE.Ray;
+    /** The camera that was used by the raycaster */
+    camera: Camera;
+    /** stopPropagation will stop underlying handlers from firing */
+    stopPropagation: () => void;
+    /** The original host event */
+    nativeEvent: TSourceEvent;
+    /** If the event was stopped by calling stopPropagation */
+    stopped: boolean;
+}
+export type Camera = THREE.OrthographicCamera | THREE.PerspectiveCamera;
+export type ThreeEvent<TEvent> = IntersectionEvent<TEvent> & Properties<TEvent>;
+export type DomEvent = PointerEvent | MouseEvent | WheelEvent;
+export interface Events {
+    onClick: EventListener;
+    onContextMenu: EventListener;
+    onDoubleClick: EventListener;
+    onWheel: EventListener;
+    onPointerDown: EventListener;
+    onPointerUp: EventListener;
+    onPointerLeave: EventListener;
+    onPointerMove: EventListener;
+    onPointerCancel: EventListener;
+    onLostPointerCapture: EventListener;
+}
+export interface EventHandlers {
+    onClick?: (event: ThreeEvent<MouseEvent>) => void;
+    onContextMenu?: (event: ThreeEvent<MouseEvent>) => void;
+    onDoubleClick?: (event: ThreeEvent<MouseEvent>) => void;
+    onPointerUp?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerDown?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerOver?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerOut?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerEnter?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerLeave?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerMove?: (event: ThreeEvent<PointerEvent>) => void;
+    onPointerMissed?: (event: MouseEvent) => void;
+    onPointerCancel?: (event: ThreeEvent<PointerEvent>) => void;
+    onWheel?: (event: ThreeEvent<WheelEvent>) => void;
+    onLostPointerCapture?: (event: ThreeEvent<PointerEvent>) => void;
+}
+export type FilterFunction = (items: THREE.Intersection[], state: RootState) => THREE.Intersection[];
+export type ComputeFunction = (event: DomEvent, root: RootState, previous?: RootState) => void;
+export interface EventManager<TTarget> {
+    /** Determines if the event layer is active */
+    enabled: boolean;
+    /** Event layer priority, higher prioritized layers come first and may stop(-propagate) lower layer  */
+    priority: number;
+    /** The compute function needs to set up the raycaster and an xy- pointer  */
+    compute?: ComputeFunction;
+    /** The filter can re-order or re-structure the intersections  */
+    filter?: FilterFunction;
+    /** The target node the event layer is tied to */
+    connected?: TTarget;
+    /** All the pointer event handlers through which the host forwards native events */
+    handlers?: Events;
+    /** Allows re-connecting to another target */
+    connect?: (target: TTarget) => void;
+    /** Removes all existing events handlers from the target */
+    disconnect?: () => void;
+    /** Triggers a onPointerMove with the last known event. This can be useful to enable raycasting without
+     *  explicit user interaction, for instance when the camera moves a hoverable object underneath the cursor.
+     */
+    update?: () => void;
+}
+export interface PointerCaptureTarget {
+    intersection: Intersection;
+    target: Element;
+}
+/** This function transfers all interactivity state from one object instance to another. Used when swapping instances due to reconstruction. */
+export declare function swapInteractivity(store: RootStore, object: THREE.Object3D, newObject: THREE.Object3D): void;
+export declare function removeInteractivity(store: RootStore, object: THREE.Object3D): void;
+export declare function createEvents(store: RootStore): {
+    handlePointer: (name: string) => (event: DomEvent) => void;
+};

package/dist/declarations/src/core/hooks.d.ts

@@ -1,53 +1,53 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import { RootState, RenderCallback, RootStore } from "./store.js";
-import { ObjectMap } from "./utils.js";
-import type { Instance, ConstructorRepresentation } from "./reconciler.js";
-/**
- * Exposes an object's {@link Instance}.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useInstanceHandle
- *
- * **Note**: this is an escape hatch to react-internal fields. Expect this to change significantly between versions.
- */
-export declare function useInstanceHandle<T>(ref: React.RefObject<T>): React.RefObject<Instance<T>>;
-/**
- * Returns the R3F Canvas' Zustand store. Useful for [transient updates](https://github.com/pmndrs/zustand#transient-updates-for-often-occurring-state-changes).
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usestore
- */
-export declare function useStore(): RootStore;
-/**
- * Accesses R3F's internal state, containing renderer, canvas, scene, etc.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usethree
- */
-export declare function useThree<T = RootState>(selector?: (state: RootState) => T, equalityFn?: <T>(state: T, newState: T) => boolean): T;
-/**
- * Executes a callback before render in a shared frame loop.
- * Can order effects with render priority or manually render with a positive priority.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe
- */
-export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
-/**
- * Returns a node graph of an object with named nodes & materials.
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usegraph
- */
-export declare function useGraph(object: THREE.Object3D): ObjectMap;
-type InputLike = string | string[] | string[][] | Readonly<string | string[] | string[][]>;
-type LoaderLike = THREE.Loader<any, InputLike>;
-type GLTFLike = {
-    scene: THREE.Object3D;
-};
-type LoaderInstance<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> = T extends ConstructorRepresentation<LoaderLike> ? InstanceType<T> : T;
-export type LoaderResult<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> = Awaited<ReturnType<LoaderInstance<T>['loadAsync']>> extends infer R ? R extends GLTFLike ? R & ObjectMap : R : never;
-export type Extensions<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> = (loader: LoaderInstance<T>) => void;
-/**
- * Synchronously loads and caches assets with a three loader.
- *
- * Note: this hook's caller must be wrapped with `React.Suspense`
- * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useloader
- */
-export declare function useLoader<I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void): I extends any[] ? LoaderResult<L>[] : LoaderResult<L>;
-export declare namespace useLoader {
-    var preload: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L> | undefined) => void;
-    var clear: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I) => void;
-}
-export {};
+import * as THREE from 'three';
+import * as React from 'react';
+import { RootState, RenderCallback, RootStore } from "./store.js";
+import { ObjectMap } from "./utils.js";
+import type { Instance, ConstructorRepresentation } from "./reconciler.js";
+/**
+ * Exposes an object's {@link Instance}.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useInstanceHandle
+ *
+ * **Note**: this is an escape hatch to react-internal fields. Expect this to change significantly between versions.
+ */
+export declare function useInstanceHandle<T>(ref: React.RefObject<T>): React.RefObject<Instance<T>>;
+/**
+ * Returns the R3F Canvas' Zustand store. Useful for [transient updates](https://github.com/pmndrs/zustand#transient-updates-for-often-occurring-state-changes).
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usestore
+ */
+export declare function useStore(): RootStore;
+/**
+ * Accesses R3F's internal state, containing renderer, canvas, scene, etc.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usethree
+ */
+export declare function useThree<T = RootState>(selector?: (state: RootState) => T, equalityFn?: <T>(state: T, newState: T) => boolean): T;
+/**
+ * Executes a callback before render in a shared frame loop.
+ * Can order effects with render priority or manually render with a positive priority.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useframe
+ */
+export declare function useFrame(callback: RenderCallback, renderPriority?: number): null;
+/**
+ * Returns a node graph of an object with named nodes & materials.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#usegraph
+ */
+export declare function useGraph(object: THREE.Object3D): ObjectMap;
+type InputLike = string | string[] | string[][] | Readonly<string | string[] | string[][]>;
+type LoaderLike = THREE.Loader<any, InputLike>;
+type GLTFLike = {
+    scene: THREE.Object3D;
+};
+type LoaderInstance<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> = T extends ConstructorRepresentation<LoaderLike> ? InstanceType<T> : T;
+export type LoaderResult<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> = Awaited<ReturnType<LoaderInstance<T>['loadAsync']>> extends infer R ? R extends GLTFLike ? R & ObjectMap : R : never;
+export type Extensions<T extends LoaderLike | ConstructorRepresentation<LoaderLike>> = (loader: LoaderInstance<T>) => void;
+/**
+ * Synchronously loads and caches assets with a three loader.
+ *
+ * Note: this hook's caller must be wrapped with `React.Suspense`
+ * @see https://docs.pmnd.rs/react-three-fiber/api/hooks#useloader
+ */
+export declare function useLoader<I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L>, onProgress?: (event: ProgressEvent<EventTarget>) => void): I extends any[] ? LoaderResult<L>[] : LoaderResult<L>;
+export declare namespace useLoader {
+    var preload: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I, extensions?: Extensions<L> | undefined) => void;
+    var clear: <I extends InputLike, L extends LoaderLike | ConstructorRepresentation<LoaderLike>>(loader: L, input: I) => void;
+}
+export {};

package/dist/declarations/src/core/index.d.ts

@@ -1,13 +1,14 @@
-export type { Intersection, ThreeEvent, DomEvent, Events, EventHandlers, FilterFunction, ComputeFunction, EventManager, } from "./events.js";
-export { createEvents } from "./events.js";
-export * from "./hooks.js";
-export type { GlobalRenderCallback, GlobalEffectType } from "./loop.js";
-export { flushGlobalEffects, addEffect, addAfterEffect, addTail, invalidate, advance } from "./loop.js";
-export type { AttachFnType, AttachType, ConstructorRepresentation, Catalogue, Args, InstanceProps, Instance, } from "./reconciler.js";
-export { extend, reconciler } from "./reconciler.js";
-export type { ReconcilerRoot, GLProps, CameraProps, RenderProps, InjectState } from "./renderer.js";
-export { _roots, createRoot, unmountComponentAtNode, createPortal, flushSync } from "./renderer.js";
-export type { Subscription, Dpr, Size, Viewport, RenderCallback, Frameloop, Performance, Renderer, XRManager, RootState, RootStore, } from "./store.js";
-export { context } from "./store.js";
-export type { ObjectMap, Camera, Disposable, Act } from "./utils.js";
-export { applyProps, getRootState, dispose, act, buildGraph } from "./utils.js";
+export type { Intersection, ThreeEvent, DomEvent, Events, EventHandlers, FilterFunction, ComputeFunction, EventManager, } from "./events.js";
+export { createEvents } from "./events.js";
+export * from "./hooks.js";
+export type { GlobalRenderCallback, GlobalEffectType } from "./loop.js";
+export { flushGlobalEffects, addEffect, addAfterEffect, addTail, invalidate, advance } from "./loop.js";
+export type { AttachFnType, AttachType, ConstructorRepresentation, Catalogue, Args, InstanceProps, Instance, } from "./reconciler.js";
+export { extend, reconciler } from "./reconciler.js";
+export type { ReconcilerRoot, GLProps, CameraProps, RenderProps, InjectState } from "./renderer.js";
+export { _roots, createRoot, unmountComponentAtNode, createPortal, flushSync } from "./renderer.js";
+export type { Subscription, Dpr, Size, Viewport, RenderCallback, Frameloop, Performance, Renderer, XRManager, RootState, RootStore, } from "./store.js";
+export { context } from "./store.js";
+export type { ObjectMap, Camera, Disposable, Act } from "./utils.js";
+export { applyProps, getRootState, dispose, act, buildGraph } from "./utils.js";
+export type { TrackedPromise } from "./promise.js";

package/dist/declarations/src/core/loop.d.ts

@@ -1,31 +1,31 @@
-/// <reference types="webxr" />
-import type { RootState } from "./store.js";
-export type GlobalRenderCallback = (timestamp: number) => void;
-/**
- * Adds a global render callback which is called each frame.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
- */
-export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
-/**
- * Adds a global after-render callback which is called each frame.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
- */
-export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
-/**
- * Adds a global callback which is called when rendering stops.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
- */
-export declare const addTail: (callback: GlobalRenderCallback) => () => void;
-export type GlobalEffectType = 'before' | 'after' | 'tail';
-export declare function flushGlobalEffects(type: GlobalEffectType, timestamp: number): void;
-export declare function loop(timestamp: number): void;
-/**
- * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
- */
-export declare function invalidate(state?: RootState, frames?: number): void;
-/**
- * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
- * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
- */
-export declare function advance(timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame): void;
+/// <reference types="webxr" />
+import type { RootState } from "./store.js";
+export type GlobalRenderCallback = (timestamp: number) => void;
+/**
+ * Adds a global render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addEffect
+ */
+export declare const addEffect: (callback: GlobalRenderCallback) => () => void;
+/**
+ * Adds a global after-render callback which is called each frame.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addAfterEffect
+ */
+export declare const addAfterEffect: (callback: GlobalRenderCallback) => () => void;
+/**
+ * Adds a global callback which is called when rendering stops.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#addTail
+ */
+export declare const addTail: (callback: GlobalRenderCallback) => () => void;
+export type GlobalEffectType = 'before' | 'after' | 'tail';
+export declare function flushGlobalEffects(type: GlobalEffectType, timestamp: number): void;
+export declare function loop(timestamp: number): void;
+/**
+ * Invalidates the view, requesting a frame to be rendered. Will globally invalidate unless passed a root's state.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#invalidate
+ */
+export declare function invalidate(state?: RootState, frames?: number): void;
+/**
+ * Advances the frameloop and runs render effects, useful for when manually rendering via `frameloop="never"`.
+ * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#advance
+ */
+export declare function advance(timestamp: number, runGlobalEffects?: boolean, state?: RootState, frame?: XRFrame): void;

package/dist/declarations/src/core/promise.d.ts

@@ -0,0 +1,15 @@
+export declare const isPromiseLike: (value: unknown) => value is PromiseLike<unknown>;
+/** A promise tagged with its state, the protocol React's `use` reads */
+export type TrackedPromise<T> = Promise<T> & ({
+    status: 'pending';
+} | {
+    status: 'fulfilled';
+    value: T;
+} | {
+    status: 'rejected';
+    reason: unknown;
+});
+export declare const fulfilled: <T>(value: T) => TrackedPromise<T>;
+export declare const rejected: <T>(reason: unknown) => TrackedPromise<T>;
+/** Tags `promise` in place once it settles. */
+export declare const tracked: <T>(promise: PromiseLike<T>) => TrackedPromise<T>;

package/dist/declarations/src/core/reconciler.d.ts

@@ -1,50 +1,54 @@
-import * as THREE from 'three';
-import * as React from 'react';
-import Reconciler from '../../react-reconciler/index.js';
-import { IsAllOptional } from "./utils.js";
-import type { RootStore } from "./store.js";
-import { type EventHandlers } from "./events.js";
-import type { ThreeElement } from "../three-types.js";
-export interface Root {
-    fiber: Reconciler.FiberRoot;
-    store: RootStore;
-}
-export type AttachFnType<O = any> = (parent: any, self: O) => () => void;
-export type AttachType<O = any> = string | AttachFnType<O>;
-export type ConstructorRepresentation<T = any> = new (...args: any[]) => T;
-export interface Catalogue {
-    [name: string]: ConstructorRepresentation;
-}
-export type Args<T> = T extends ConstructorRepresentation ? T extends typeof THREE.Color ? [r: number, g: number, b: number] | [color: THREE.ColorRepresentation] : ConstructorParameters<T> : any[];
-type ArgsProp<P> = P extends ConstructorRepresentation ? IsAllOptional<ConstructorParameters<P>> extends true ? {
-    args?: Args<P>;
-} : {
-    args: Args<P>;
-} : {
-    args: unknown[];
-};
-export type InstanceProps<T = any, P = any> = ArgsProp<P> & {
-    object?: T;
-    dispose?: null;
-    attach?: AttachType<T>;
-    onUpdate?: (self: T) => void;
-};
-export 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;
-}
-export declare function extend<T extends ConstructorRepresentation>(objects: T): React.ExoticComponent<ThreeElement<T>>;
-export declare function extend<T extends Catalogue>(objects: T): void;
-export declare const reconciler: Reconciler.Reconciler<RootStore, Instance<any>, void, Instance<any>, never, any>;
-export {};
+import * as THREE from 'three';
+import * as React from 'react';
+import Reconciler from '../../react-reconciler/index.js';
+import type { TrackedPromise } from "./promise.js";
+import { IsAllOptional } from "./utils.js";
+import type { RootStore } from "./store.js";
+import { type EventHandlers } from "./events.js";
+import type { ThreeElement } from "../three-types.js";
+export interface Root {
+    fiber: Reconciler.FiberRoot;
+    store: RootStore;
+    unmountClaim: symbol | null;
+    /** Pending only while an async renderer is being created */
+    ready: TrackedPromise<unknown>;
+}
+export type AttachFnType<O = any> = (parent: any, self: O) => () => void;
+export type AttachType<O = any> = string | AttachFnType<O>;
+export type ConstructorRepresentation<T = any> = new (...args: any[]) => T;
+export interface Catalogue {
+    [name: string]: ConstructorRepresentation;
+}
+export type Args<T> = T extends ConstructorRepresentation ? T extends typeof THREE.Color ? [r: number, g: number, b: number] | [color: THREE.ColorRepresentation] : ConstructorParameters<T> : any[];
+type ArgsProp<P> = P extends ConstructorRepresentation ? IsAllOptional<ConstructorParameters<P>> extends true ? {
+    args?: Args<P>;
+} : {
+    args: Args<P>;
+} : {
+    args: unknown[];
+};
+export type InstanceProps<T = any, P = any> = ArgsProp<P> & {
+    object?: T;
+    dispose?: null;
+    attach?: AttachType<T>;
+    onUpdate?: (self: T) => void;
+};
+export 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;
+}
+export declare function extend<T extends ConstructorRepresentation>(objects: T): React.ExoticComponent<ThreeElement<T>>;
+export declare function extend<T extends Catalogue>(objects: T): void;
+export declare const reconciler: Reconciler.Reconciler<RootStore, Instance<any>, void, Instance<any>, never, any>;
+export {};