@react-three/fiber 9.8.0 → 9.8.2

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @react-three/fiber
 
+## 9.8.2
+
+### Patch Changes
+
+- Include native build output explicitly in published packages so workspace ignore rules cannot omit the React Native entry points.
+- 77406776ae0ee61a4ca73e92082929f9a54359ab: Keep pointer capture working when an object's `args` change during a drag (#3985), and request a frame when an object is removed with `frameloop="demand"` so it disappears immediately (#3976).
+- d74622ea8ed717f7212d7e19d65ff3e325508389: Fix `createPortal` memory leaks: parent subscriptions are cleaned up when a portal unmounts or is hidden by Activity (#3676), and event setters no longer retain earlier portal states (#3751). Portal state survives Activity hide/show, and parent changes made before subscribing or while hidden are applied when the subscription starts. Ports the leak fixes from v10.
+- db8fdf21fa46e3b40d2791e0ea7a684d878ae404: Only register three.js constructors as JSX intrinsic elements. Non-constructor exports such as constants and `MathUtils` were previously registered with `never` props, which collapsed the props of any `React.ElementType` to `never` once `@react-three/fiber` was imported.
+- bffddfaafbf9a5e1f749cb6612d6b1f0189b26a9: fix: follow devicePixelRatio changes when the canvas moves to another display or the page is zoomed.
+
+  Neither resizes the canvas, so nothing re-rendered it and the `dpr` prop stayed resolved against the old ratio: blurry on a denser display, four times the pixels on a coarser one. Roots now watch the ratio and re-resolve the prop the same way a re-render does. A fixed `dpr` is unaffected and never touches `matchMedia`, changes during an XR session apply once it ends, and environments without a working `matchMedia`, such as test setups with a partial mock, behave as before.
+
+## 9.8.1
+
+### Patch Changes
+
+- 2bcc153b52213535e2149d70f6c01d7dcaee58a2: fix: keep a Canvas root alive while `<Activity>` hides it.
+
+  React destroys a hidden `<Activity>` tree's effects but keeps its DOM. The Canvas unmounted its root in that effect cleanup, which lost the WebGL context and disposed the scene. When the tree was shown again, the Canvas still held the unmounted root and stayed blank.
+
+  Canvas now keeps its renderer and scene state while hidden. A Canvas removed while hidden still releases its renderer.
+
+- 138bfb0055a2534103686454c5e1f22bcdbf4537: Canvas and `root.configure()` now apply only the configuration props that changed. Runtime changes made through setters such as `setFrameloop`, or directly to `gl.shadowMap`, last through rerenders and resizes until their prop changes. The pixel ratio still follows `dpr` and the device pixel ratio on every render. Inline option objects compare by value. Changing `flat` or `linear` after creation now updates the renderer, unless `gl` sets `toneMapping` or `outputColorSpace` explicitly.
+
+  Configuration applies in call order, including calls made from a renderer factory or a store subscriber while another configuration is running.
+
+- e0e9c2dbb5b9f1567f43ffe97205d29a4094028a: Update its-fine to 2.1.1 and bridge ancestor Activity visibility into the Canvas scene on React 19.2 and later. Hiding an Activity disconnects scene effects and useFrame subscriptions; revealing it reconnects them without resetting scene state. Keep the existing context and StrictMode bridges, and fall back to their previous behavior on React 19.0 and 19.1.
+- 9ac75626b2191c65698d3bfb27c2e43d6e3c8891: fix: dispose the renderer R3F creates when its root unmounts.
+
+  Teardown only called `forceContextLoss()`, never `dispose()`. A `WebGPURenderer` built in a `gl` factory, which has no `forceContextLoss`, was never released at all: its GPU device and every allocation on it outlived the canvas. A `WebGLRenderer` lost its context while three's listener was still attached, which logged `THREE.WebGLRenderer: Context Lost.` on every unmount.
+
+  A renderer R3F builds, from its defaults, a props object or a factory, is now disposed, and then its context is lost. A renderer passed in as an instance keeps its previous teardown. Each teardown step now runs on its own, so one that throws no longer skips the rest.
+
+- 8965ba4f05eab91c605fe0dfaaa58453c1ede7c9: Preserve an object's visibility across Activity and Suspense hiding. Visibility prop changes made while hidden take effect when the object is shown.
+- 9ac75626b2191c65698d3bfb27c2e43d6e3c8891: Model root teardown with explicit open, closing, disposing, and disposed states. Allow pending unmounts to be cancelled, wait for React cleanups and queued configuration before disposing, and prevent disposed root handles from configuring or unmounting replacement roots. Complete teardown callbacks after asynchronous renderer disposal settles, and release the context even if renderer disposal fails.
+
 ## 9.8.0
 
 ### Minor Changes

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

@@ -0,0 +1,91 @@
+import * as THREE from 'three';
+import type { ThreeElement } from "../three-types.js";
+import type { EventManager } from "./events.js";
+import { type Dpr, type Frameloop, type Performance, type Renderer, type RootState, type RootStore, type Size } from "./store.js";
+import { type Camera, type Properties } from "./utils.js";
+interface OffscreenCanvas extends EventTarget {
+}
+export type DefaultGLProps = Omit<THREE.WebGLRendererParameters, 'canvas'> & {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+};
+export type GLProps = Renderer | ((defaultProps: DefaultGLProps) => Renderer) | ((defaultProps: DefaultGLProps) => Promise<Renderer>) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters>;
+export type CameraProps = (Camera | Partial<ThreeElement<typeof THREE.Camera> & ThreeElement<typeof THREE.PerspectiveCamera> & ThreeElement<typeof THREE.OrthographicCamera>>) & {
+    /** Flags the camera as manual, putting projection into your own hands */
+    manual?: boolean;
+};
+export interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
+    /** A threejs renderer instance or props that go into the default renderer */
+    gl?: GLProps;
+    /** 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'.
+     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
+     */
+    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;
+    /**
+     * Disables three r139 color management.
+     * @see https://threejs.org/manual/#en/color-management
+     */
+    legacy?: boolean;
+    /** Switch off automatic sRGB encoding and gamma correction */
+    linear?: boolean;
+    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
+    flat?: boolean;
+    /** Creates an orthographic camera */
+    orthographic?: boolean;
+    /**
+     * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
+     */
+    frameloop?: Frameloop;
+    /**
+     * R3F performance options for adaptive performance.
+     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression
+     */
+    performance?: Partial<Omit<Performance, 'regress'>>;
+    /** Target pixel ratio. Can clamp between a range: `[min, max]` */
+    dpr?: Dpr;
+    /** Props that go into the default raycaster */
+    raycaster?: Partial<THREE.Raycaster>;
+    /** A `THREE.Scene` instance or props that go into the default scene */
+    scene?: THREE.Scene | Partial<THREE.Scene>;
+    /** A `THREE.Camera` instance or props that go into the default camera */
+    camera?: CameraProps;
+    /** An R3F event manager to manage elements' pointer events */
+    events?: (store: RootStore) => EventManager<HTMLElement>;
+    /** Callback after the canvas has rendered (but not yet committed) */
+    onCreated?: (state: RootState) => void;
+    /** Response for pointer clicks that have missed any target */
+    onPointerMissed?: (event: MouseEvent) => void;
+}
+type Canvas = DefaultGLProps['canvas'];
+export type Configuration = RenderProps<Canvas>;
+/** What a root has applied, so its next configuration applies only what changed */
+export interface AppliedConfiguration {
+    /** The last configuration applied in full */
+    previous?: Configuration;
+    /** The camera prop that set the current camera */
+    camera?: Configuration['camera'];
+}
+/**
+ * Applies the inputs that changed since the last configuration applied in full, to a root whose
+ * renderer is installed. A runtime change, such as setFrameloop or an edit to gl.shadowMap, lasts
+ * until its input changes. The pixel ratio instead follows the device on every call. Objects and
+ * arrays compare shallowly, so an equal inline value is unchanged.
+ */
+export declare function applyRootConfiguration({ store, configuration }: {
+    store: RootStore;
+    configuration: AppliedConfiguration;
+}, canvas: Canvas, props: Configuration): void;
+/**
+ * Moving to another display or zooming changes window.devicePixelRatio without resizing the canvas,
+ * so nothing configures the root again. Resolves the ratio the way configuration does, from the last
+ * applied dpr. Returns the function that stops following.
+ */
+export declare function followDpr(root: {
+    store: RootStore;
+    configuration: AppliedConfiguration;
+}): () => void;
+export {};

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

@@ -0,0 +1,12 @@
+/** Constructor registration and lookup for JSX elements. */
+import type * as React from 'react';
+import type { ThreeElement } from "../three-types.js";
+export type ConstructorRepresentation<T = any> = new (...args: any[]) => T;
+export interface Catalogue {
+    [name: string]: ConstructorRepresentation;
+}
+export declare const toPascalCase: (type: string) => string;
+export declare function hasConstructor(name: string): boolean;
+export declare function resolveConstructor(name: string): ConstructorRepresentation | undefined;
+export declare function extend<T extends ConstructorRepresentation>(objects: T): React.ExoticComponent<ThreeElement<T>>;
+export declare function extend<T extends Catalogue>(objects: T): void;

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

@@ -2,7 +2,8 @@ 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";
+import type { Instance } from "./reconciler.js";
+import type { ConstructorRepresentation } from "./extend.js";
 /**
  * Exposes an object's {@link Instance}.
  * @see https://docs.pmnd.rs/react-three-fiber/api/additional-exports#useInstanceHandle

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

@@ -3,12 +3,17 @@ 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 { AttachFnType, AttachType, Args, InstanceProps, Instance } from "./reconciler.js";
+export type { ConstructorRepresentation, Catalogue } from "./extend.js";
+export { extend } from "./extend.js";
+export { reconciler, flushSync } from "./reconciler.js";
+export type { GLProps, CameraProps, RenderProps } from "./configuration.js";
+export type { ReconcilerRoot } from "./root.js";
+export { _roots, createRoot, unmountComponentAtNode } from "./root.js";
+export type { InjectState } from "./portal.js";
+export { createPortal } from "./portal.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";
+export type { TrackedPromise } from "./utils/promise.js";

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

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import * as THREE from 'three';
+import type { ComputeFunction } from "./events.js";
+import { type RootState } from "./store.js";
+export type InjectState = Partial<Omit<RootState, 'events'> & {
+    events?: {
+        enabled?: boolean;
+        priority?: number;
+        compute?: ComputeFunction;
+        connected?: any;
+    };
+}>;
+export declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): React.JSX.Element;

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

@@ -1,24 +1,13 @@
 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>;
-}
+import { type ConstructorRepresentation } from "./extend.js";
+export { extend } from "./extend.js";
+export type { ConstructorRepresentation, Catalogue } from "./extend.js";
 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>;
@@ -46,9 +35,14 @@ export interface Instance<O = any> {
     handlers: Partial<EventHandlers>;
     attach?: AttachType<O>;
     previousAttach?: any;
+    previousVisible: boolean | undefined;
     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 {};
+/**
+ * Force React to flush any updates inside the provided callback synchronously and immediately.
+ * All the same caveats documented for react-dom's `flushSync` apply here (see https://react.dev/reference/react-dom/flushSync).
+ * Nevertheless, sometimes one needs to render synchronously, for example to keep DOM and 3D changes in lock-step without
+ * having to revert to a non-React solution. Note: this will only flush updates within the `Canvas` root.
+ */
+export declare function flushSync<R>(fn: () => R): R;

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

@@ -1,91 +1,9 @@
-import * as React from 'react';
+/** Renderer creation and resource release. Root lifetime decides when release is safe. */
 import * as THREE from 'three';
-import type { ThreeElement } from "../three-types.js";
-import { ComputeFunction, EventManager } from "./events.js";
-import { Root } from "./reconciler.js";
-import { Dpr, Frameloop, Performance, Renderer, RootState, RootStore, Size } from "./store.js";
-import { type Properties, Camera } from "./utils.js";
-import { TrackedPromise } from "./promise.js";
-interface OffscreenCanvas extends EventTarget {
-}
-export declare const _roots: Map<HTMLCanvasElement | OffscreenCanvas, Root>;
-export type DefaultGLProps = Omit<THREE.WebGLRendererParameters, 'canvas'> & {
-    canvas: HTMLCanvasElement | OffscreenCanvas;
-};
-export type GLProps = Renderer | ((defaultProps: DefaultGLProps) => Renderer) | ((defaultProps: DefaultGLProps) => Promise<Renderer>) | Partial<Properties<THREE.WebGLRenderer> | THREE.WebGLRendererParameters>;
-export type CameraProps = (Camera | Partial<ThreeElement<typeof THREE.Camera> & ThreeElement<typeof THREE.PerspectiveCamera> & ThreeElement<typeof THREE.OrthographicCamera>>) & {
-    /** Flags the camera as manual, putting projection into your own hands */
-    manual?: boolean;
-};
-export interface RenderProps<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
-    /** A threejs renderer instance or props that go into the default renderer */
-    gl?: GLProps;
-    /** 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'.
-     * @see https://threejs.org/docs/#api/en/renderers/WebGLRenderer.shadowMap
-     */
-    shadows?: boolean | 'basic' | 'percentage' | 'soft' | 'variance' | Partial<THREE.WebGLShadowMap>;
-    /**
-     * Disables three r139 color management.
-     * @see https://threejs.org/manual/#en/color-management
-     */
-    legacy?: boolean;
-    /** Switch off automatic sRGB encoding and gamma correction */
-    linear?: boolean;
-    /** Use `THREE.NoToneMapping` instead of `THREE.ACESFilmicToneMapping` */
-    flat?: boolean;
-    /** Creates an orthographic camera */
-    orthographic?: boolean;
-    /**
-     * R3F's render mode. Set to `demand` to only render on state change or `never` to take control.
-     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#on-demand-rendering
-     */
-    frameloop?: Frameloop;
-    /**
-     * R3F performance options for adaptive performance.
-     * @see https://docs.pmnd.rs/react-three-fiber/advanced/scaling-performance#movement-regression
-     */
-    performance?: Partial<Omit<Performance, 'regress'>>;
-    /** Target pixel ratio. Can clamp between a range: `[min, max]` */
-    dpr?: Dpr;
-    /** Props that go into the default raycaster */
-    raycaster?: Partial<THREE.Raycaster>;
-    /** A `THREE.Scene` instance or props that go into the default scene */
-    scene?: THREE.Scene | Partial<THREE.Scene>;
-    /** A `THREE.Camera` instance or props that go into the default camera */
-    camera?: CameraProps;
-    /** An R3F event manager to manage elements' pointer events */
-    events?: (store: RootStore) => EventManager<HTMLElement>;
-    /** Callback after the canvas has rendered (but not yet committed) */
-    onCreated?: (state: RootState) => void;
-    /** Response for pointer clicks that have missed any target */
-    onPointerMissed?: (event: MouseEvent) => void;
-}
-export interface ReconcilerRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
-    ready: TrackedPromise<unknown>;
-    configure: (config?: RenderProps<TCanvas>) => TrackedPromise<ReconcilerRoot<TCanvas>>;
-    render: (element: React.ReactNode) => RootStore;
-    unmount: () => void;
-}
-export declare function createRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
-export declare function unmountComponentAtNode<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
-export type InjectState = Partial<Omit<RootState, 'events'> & {
-    events?: {
-        enabled?: boolean;
-        priority?: number;
-        compute?: ComputeFunction;
-        connected?: any;
-    };
-}>;
-export declare function createPortal(children: React.ReactNode, container: THREE.Object3D, state?: InjectState): React.JSX.Element;
-/**
- * Force React to flush any updates inside the provided callback synchronously and immediately.
- * All the same caveats documented for react-dom's `flushSync` apply here (see https://react.dev/reference/react-dom/flushSync).
- * Nevertheless, sometimes one needs to render synchronously, for example to keep DOM and 3D changes in lock-step without
- * having to revert to a non-React solution. Note: this will only flush updates within the `Canvas` root.
- */
-export declare function flushSync<R>(fn: () => R): R;
-export {};
+import type { DefaultGLProps, GLProps } from "./configuration.js";
+import type { Renderer } from "./store.js";
+export declare const isRenderer: (def: any) => boolean;
+/** The renderer to configure, or a promise for one from an async factory */
+export declare function createRenderer(canvas: DefaultGLProps['canvas'], gl?: GLProps): Renderer | PromiseLike<Renderer>;
+/** Owned renderers are disposed. Caller-provided renderers release caches and their context. */
+export declare function releaseRenderer(gl: THREE.WebGLRenderer | undefined, owned: boolean): void | Promise<void>;

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

@@ -0,0 +1,37 @@
+import * as React from 'react';
+import type Reconciler from '../../react-reconciler/index.js';
+import { type AppliedConfiguration, type RenderProps } from "./configuration.js";
+import { type TrackedPromise } from "./utils/promise.js";
+import { type RootStore } from "./store.js";
+interface OffscreenCanvas extends EventTarget {
+}
+export interface Root {
+    fiber: Reconciler.FiberRoot;
+    store: RootStore;
+    state: RootStateMachine;
+    /** Settles once all accepted configuration has been applied */
+    ready: TrackedPromise<unknown>;
+    configuration: AppliedConfiguration;
+    /** Whether R3F built `gl` (from defaults, props or a factory) and so disposes it on unmount */
+    ownsRenderer: boolean;
+    /** Stops following devicePixelRatio changes */
+    unwatchDpr?: () => void;
+}
+export declare const _roots: Map<HTMLCanvasElement | OffscreenCanvas, Root>;
+export type RootStateMachine = {
+    status: 'open';
+} | {
+    status: 'closing';
+    token: symbol;
+} | {
+    status: 'disposed';
+};
+export interface ReconcilerRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas> {
+    ready: TrackedPromise<unknown>;
+    configure: (config?: RenderProps<TCanvas>) => TrackedPromise<ReconcilerRoot<TCanvas>>;
+    render: (element: React.ReactNode) => RootStore;
+    unmount: () => void;
+}
+export declare function createRoot<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas): ReconcilerRoot<TCanvas>;
+export declare function unmountComponentAtNode<TCanvas extends HTMLCanvasElement | OffscreenCanvas>(canvas: TCanvas, callback?: (canvas: TCanvas) => void): void;
+export {};

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

@@ -49,7 +49,7 @@ export interface Performance {
 export interface Renderer {
     render: (scene: THREE.Scene, camera: THREE.Camera) => any;
 }
-export declare const isRenderer: (def: any) => boolean;
+export { isRenderer } from "./renderer.js";
 export interface InternalState {
     interaction: THREE.Object3D[];
     hovered: Map<string, ThreeEvent<DomEvent>>;

package/dist/declarations/src/core/{promise.d.ts → utils/promise.d.ts}

@@ -1,4 +1,4 @@
-export declare const isPromiseLike: (value: unknown) => value is PromiseLike<unknown>;
+export declare const isPromiseLike: <T>(value: T | PromiseLike<T>) => value is PromiseLike<T>;
 /** A promise tagged with its state, the protocol React's `use` reads */
 export type TrackedPromise<T> = Promise<T> & ({
     status: 'pending';
@@ -11,5 +11,9 @@ export type TrackedPromise<T> = Promise<T> & ({
 });
 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>;
+/** A pending promise, settled once from outside. Its `status` updates the moment it settles */
+export declare const deferred: <T>() => {
+    promise: TrackedPromise<T>;
+    resolve: (_value: T) => void;
+    reject: (_reason: unknown) => void;
+};

package/dist/declarations/src/core/utils/react.d.ts

@@ -0,0 +1,184 @@
+import * as React from 'react';
+export type Act = <T = any>(cb: () => Promise<T>) => Promise<T>;
+/**
+ * Safely flush async effects when testing, simulating a legacy root.
+ * @deprecated Import from React instead. import { act } from 'react'
+ */
+export declare const act: Act;
+/**
+ * An SSR-friendly useLayoutEffect.
+ *
+ * React currently throws a warning when using useLayoutEffect on the server.
+ * To get around it, we can conditionally useEffect on the server (no-op) and
+ * useLayoutEffect elsewhere.
+ *
+ * @see https://github.com/facebook/react/issues/14927
+ */
+export declare const useIsomorphicLayoutEffect: typeof React.useLayoutEffect;
+export declare function useMutableCallback<T>(fn: T): React.RefObject<T>;
+/** Waits for a promise in a null subtree, re-rendering the caller once it settles either way. */
+export declare function useGate(): [gate: React.ReactNode, waitFor: (promise: PromiseLike<unknown>) => void];
+export type Bridge = React.FC<{
+    children?: React.ReactNode;
+}>;
+/**
+ * Bridges Context, StrictMode, and Activity visibility from a primary renderer.
+ */
+export declare function useBridge(): Bridge;
+export type SetBlock = false | Promise<null> | null;
+export type UnblockProps = {
+    set: React.Dispatch<React.SetStateAction<SetBlock>>;
+    children: React.ReactNode;
+};
+export declare function Block({ set }: Omit<UnblockProps, 'children'>): null;
+export declare const ErrorBoundary: {
+    new (props: {
+        set: React.Dispatch<Error | undefined>;
+        children: React.ReactNode;
+    }): {
+        state: {
+            error: boolean;
+        };
+        componentDidCatch(err: Error): void;
+        render(): React.ReactNode;
+        context: unknown;
+        setState<K extends "error">(state: {
+            error: boolean;
+        } | ((prevState: Readonly<{
+            error: boolean;
+        }>, props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>) => {
+            error: boolean;
+        } | Pick<{
+            error: boolean;
+        }, K> | null) | Pick<{
+            error: boolean;
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>): any;
+        componentDidUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+    };
+    new (props: {
+        set: React.Dispatch<Error | undefined>;
+        children: React.ReactNode;
+    }, context: any): {
+        state: {
+            error: boolean;
+        };
+        componentDidCatch(err: Error): void;
+        render(): React.ReactNode;
+        context: unknown;
+        setState<K extends "error">(state: {
+            error: boolean;
+        } | ((prevState: Readonly<{
+            error: boolean;
+        }>, props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>) => {
+            error: boolean;
+        } | Pick<{
+            error: boolean;
+        }, K> | null) | Pick<{
+            error: boolean;
+        }, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>;
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>): any;
+        componentDidUpdate?(prevProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, prevState: Readonly<{
+            error: boolean;
+        }>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
+            set: React.Dispatch<Error | undefined>;
+            children: React.ReactNode;
+        }>, nextState: Readonly<{
+            error: boolean;
+        }>, nextContext: any): void;
+    };
+    getDerivedStateFromError: () => {
+        error: boolean;
+    };
+    contextType?: React.Context<any> | undefined;
+    propTypes?: any;
+};