@motion-core/motion-gpu 0.3.0 → 0.4.1

package/dist/react/FragCanvas.js

@@ -0,0 +1,218 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createCurrentWritable as currentWritable } from '../core/current-value.js';
+import { toMotionGPUErrorReport } from '../core/error-report.js';
+import { createFrameRegistry } from '../core/frame-registry.js';
+import { createMotionGPURuntimeLoop } from '../core/runtime-loop.js';
+import { useEffect, useRef, useState } from 'react';
+import { FrameRegistryReactContext } from './frame-context.js';
+import { MotionGPUErrorOverlay } from './MotionGPUErrorOverlay.js';
+import { MotionGPUReactContext } from './motiongpu-context.js';
+function getInitialDpr() {
+    if (typeof window === 'undefined') {
+        return 1;
+    }
+    return window.devicePixelRatio ?? 1;
+}
+function createRuntimeState(initialDpr) {
+    const registry = createFrameRegistry({ maxDelta: 0.1 });
+    const canvasRef = { current: undefined };
+    const requestFrameSignalRef = { current: null };
+    const requestFrame = () => {
+        requestFrameSignalRef.current?.();
+    };
+    const invalidateFrame = () => {
+        registry.invalidate();
+        requestFrame();
+    };
+    const advanceFrame = () => {
+        registry.advance();
+        requestFrame();
+    };
+    const size = currentWritable({ width: 0, height: 0 });
+    const dprState = currentWritable(initialDpr, requestFrame);
+    const maxDeltaState = currentWritable(0.1, (value) => {
+        registry.setMaxDelta(value);
+        requestFrame();
+    });
+    const renderModeState = currentWritable('always', (value) => {
+        registry.setRenderMode(value);
+        requestFrame();
+    });
+    const autoRenderState = currentWritable(true, (value) => {
+        registry.setAutoRender(value);
+        requestFrame();
+    });
+    const userState = currentWritable({});
+    const context = {
+        get canvas() {
+            return canvasRef.current;
+        },
+        size,
+        dpr: dprState,
+        maxDelta: maxDeltaState,
+        renderMode: renderModeState,
+        autoRender: autoRenderState,
+        user: userState,
+        invalidate: invalidateFrame,
+        advance: advanceFrame,
+        scheduler: {
+            createStage: registry.createStage,
+            getStage: registry.getStage,
+            setDiagnosticsEnabled: registry.setDiagnosticsEnabled,
+            getDiagnosticsEnabled: registry.getDiagnosticsEnabled,
+            getLastRunTimings: registry.getLastRunTimings,
+            getSchedule: registry.getSchedule,
+            setProfilingEnabled: registry.setProfilingEnabled,
+            setProfilingWindow: registry.setProfilingWindow,
+            resetProfiling: registry.resetProfiling,
+            getProfilingEnabled: registry.getProfilingEnabled,
+            getProfilingWindow: registry.getProfilingWindow,
+            getProfilingSnapshot: registry.getProfilingSnapshot
+        }
+    };
+    return {
+        registry,
+        context,
+        canvasRef,
+        size,
+        dprState,
+        maxDeltaState,
+        renderModeState,
+        autoRenderState,
+        requestFrameSignalRef,
+        requestFrame,
+        invalidateFrame,
+        advanceFrame
+    };
+}
+function getNormalizedErrorHistoryLimit(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        return 0;
+    }
+    return Math.floor(value);
+}
+export function FragCanvas({ material, renderTargets = {}, passes = [], clearColor = [0, 0, 0, 1], outputColorSpace = 'srgb', renderMode = 'always', autoRender = true, maxDelta = 0.1, adapterOptions = undefined, deviceDescriptor = undefined, dpr = getInitialDpr(), showErrorOverlay = true, errorRenderer, onError = undefined, errorHistoryLimit = 0, onErrorHistory = undefined, className = '', style, children }) {
+    const runtimeRef = useRef(null);
+    if (!runtimeRef.current) {
+        runtimeRef.current = createRuntimeState(getInitialDpr());
+    }
+    const runtime = runtimeRef.current;
+    const runtimePropsRef = useRef({
+        material,
+        renderTargets,
+        passes,
+        clearColor,
+        outputColorSpace,
+        adapterOptions,
+        deviceDescriptor,
+        onError,
+        errorHistoryLimit,
+        onErrorHistory
+    });
+    runtimePropsRef.current = {
+        material,
+        renderTargets,
+        passes,
+        clearColor,
+        outputColorSpace,
+        adapterOptions,
+        deviceDescriptor,
+        onError,
+        errorHistoryLimit,
+        onErrorHistory
+    };
+    const [errorReport, setErrorReport] = useState(null);
+    const [errorHistory, setErrorHistory] = useState([]);
+    useEffect(() => {
+        runtime.renderModeState.set(renderMode);
+    }, [renderMode, runtime]);
+    useEffect(() => {
+        runtime.autoRenderState.set(autoRender);
+    }, [autoRender, runtime]);
+    useEffect(() => {
+        runtime.maxDeltaState.set(maxDelta);
+    }, [maxDelta, runtime]);
+    useEffect(() => {
+        runtime.dprState.set(dpr);
+    }, [dpr, runtime]);
+    useEffect(() => {
+        const limit = getNormalizedErrorHistoryLimit(errorHistoryLimit);
+        if (limit <= 0) {
+            if (errorHistory.length === 0) {
+                return;
+            }
+            setErrorHistory([]);
+            onErrorHistory?.([]);
+            return;
+        }
+        if (errorHistory.length <= limit) {
+            return;
+        }
+        const trimmed = errorHistory.slice(errorHistory.length - limit);
+        setErrorHistory(trimmed);
+        onErrorHistory?.(trimmed);
+    }, [errorHistory, errorHistoryLimit, onErrorHistory]);
+    useEffect(() => {
+        const canvas = runtime.canvasRef.current;
+        if (!canvas) {
+            const report = toMotionGPUErrorReport(new Error('Canvas element is not available'), 'initialization');
+            setErrorReport(report);
+            const historyLimit = getNormalizedErrorHistoryLimit(runtimePropsRef.current.errorHistoryLimit);
+            if (historyLimit > 0) {
+                const nextHistory = [report].slice(-historyLimit);
+                setErrorHistory(nextHistory);
+                runtimePropsRef.current.onErrorHistory?.(nextHistory);
+            }
+            runtimePropsRef.current.onError?.(report);
+            return () => {
+                runtime.registry.clear();
+            };
+        }
+        const runtimeLoop = createMotionGPURuntimeLoop({
+            canvas,
+            registry: runtime.registry,
+            size: runtime.size,
+            dpr: runtime.dprState,
+            maxDelta: runtime.maxDeltaState,
+            getMaterial: () => runtimePropsRef.current.material,
+            getRenderTargets: () => runtimePropsRef.current.renderTargets,
+            getPasses: () => runtimePropsRef.current.passes,
+            getClearColor: () => runtimePropsRef.current.clearColor,
+            getOutputColorSpace: () => runtimePropsRef.current.outputColorSpace,
+            getAdapterOptions: () => runtimePropsRef.current.adapterOptions,
+            getDeviceDescriptor: () => runtimePropsRef.current.deviceDescriptor,
+            getOnError: () => runtimePropsRef.current.onError,
+            getErrorHistoryLimit: () => runtimePropsRef.current.errorHistoryLimit,
+            getOnErrorHistory: () => runtimePropsRef.current.onErrorHistory,
+            reportErrorHistory: (history) => {
+                setErrorHistory(history);
+            },
+            reportError: (report) => {
+                setErrorReport(report);
+            }
+        });
+        runtime.requestFrameSignalRef.current = runtimeLoop.requestFrame;
+        return () => {
+            runtime.requestFrameSignalRef.current = null;
+            runtimeLoop.destroy();
+        };
+    }, [runtime]);
+    const canvasStyle = {
+        position: 'absolute',
+        inset: 0,
+        display: 'block',
+        width: '100%',
+        height: '100%',
+        ...style
+    };
+    return (_jsx(FrameRegistryReactContext.Provider, { value: runtime.registry, children: _jsx(MotionGPUReactContext.Provider, { value: runtime.context, children: _jsxs("div", { className: "motiongpu-canvas-wrap", style: {
+                    position: 'relative',
+                    width: '100%',
+                    height: '100%',
+                    minWidth: 0,
+                    minHeight: 0,
+                    overflow: 'hidden'
+                }, children: [_jsx("canvas", { className: className, style: canvasStyle, ref: (node) => {
+                            runtime.canvasRef.current = node ?? undefined;
+                        } }), showErrorOverlay && errorReport ? (errorRenderer ? (errorRenderer(errorReport)) : (_jsx(MotionGPUErrorOverlay, { report: errorReport }))) : null, children] }) }) }));
+}

package/dist/react/MotionGPUErrorOverlay.d.ts

@@ -0,0 +1,6 @@
+import type { MotionGPUErrorReport } from '../core/error-report.js';
+interface MotionGPUErrorOverlayProps {
+    report: MotionGPUErrorReport;
+}
+export declare function MotionGPUErrorOverlay({ report }: MotionGPUErrorOverlayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/react/MotionGPUErrorOverlay.js

@@ -0,0 +1,305 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Portal } from './Portal.js';
+const MOTIONGPU_ERROR_OVERLAY_STYLES = `
+.motiongpu-error-overlay {
+	--motiongpu-base-hue: var(--base-hue, 265);
+	--motiongpu-color-background: oklch(0.2178 0.0056 var(--motiongpu-base-hue));
+	--motiongpu-color-background-muted: oklch(0.261 0.007 var(--motiongpu-base-hue));
+	--motiongpu-color-foreground: oklch(1 0 0);
+	--motiongpu-color-foreground-muted: oklch(0.6699 0.0081 var(--motiongpu-base-hue));
+	--motiongpu-color-card: var(--motiongpu-color-background);
+	--motiongpu-color-accent: oklch(0.6996 0.181959 44.4414);
+	--motiongpu-color-accent-secondary: oklch(0.5096 0.131959 44.4414);
+	--motiongpu-color-border: oklch(0.928 0.013 var(--motiongpu-base-hue) / 0.05);
+	--motiongpu-color-white-fixed: oklch(1 0 0);
+	--motiongpu-shadow-card: var(
+		--shadow-2xl,
+		0px 1px 1px -0.5px rgba(0, 0, 0, 0.06),
+		0px 3px 3px -1.5px rgba(0, 0, 0, 0.06),
+		0px 6px 6px -3px rgba(0, 0, 0, 0.06),
+		0px 12px 12px -6px rgba(0, 0, 0, 0.06),
+		0px 24px 24px -12px rgba(0, 0, 0, 0.05),
+		0px 48px 48px -24px rgba(0, 0, 0, 0.06)
+	);
+	--motiongpu-radius-md: var(--radius-md, 0.5rem);
+	--motiongpu-radius-lg: var(--radius-lg, 0.75rem);
+	--motiongpu-radius-xl: var(--radius-xl, 1rem);
+	--motiongpu-font-sans: var(
+		--font-sans,
+		'Inter',
+		'Segoe UI',
+		'Helvetica Neue',
+		Arial,
+		sans-serif
+	);
+	--motiongpu-font-mono: var(--font-mono, 'SFMono-Regular', 'Menlo', 'Consolas', monospace);
+	position: fixed;
+	inset: 0;
+	display: grid;
+	place-items: center;
+	padding: clamp(0.75rem, 1.4vw, 1.5rem);
+	background: rgba(0, 0, 0, 0.8);
+	backdrop-filter: blur(10px);
+	z-index: 2147483647;
+	font-family: var(--motiongpu-font-sans);
+	color-scheme: dark;
+}
+
+.motiongpu-error-dialog {
+	width: min(52rem, calc(100vw - 1.5rem));
+	max-height: min(84vh, 44rem);
+	overflow: auto;
+	margin: 0;
+	padding: 1.1rem;
+	border: 1px solid var(--motiongpu-color-border);
+	border-radius: var(--motiongpu-radius-xl);
+	max-width: calc(100vw - 1.5rem);
+	box-sizing: border-box;
+	font-size: 0.875rem;
+	font-weight: 400;
+	line-height: 1.45;
+	background: var(--motiongpu-color-card);
+	color: var(--motiongpu-color-foreground);
+	box-shadow: var(--motiongpu-shadow-card);
+}
+
+.motiongpu-error-header {
+	display: grid;
+	gap: 0.55rem;
+	padding-bottom: 0.9rem;
+	border-bottom: 1px solid var(--motiongpu-color-border);
+}
+
+.motiongpu-error-badge-wrap {
+	display: inline-flex;
+	align-items: center;
+	gap: 0.4rem;
+	width: fit-content;
+	padding: 0.18rem;
+	border-radius: 999px;
+	border: 1px solid var(--motiongpu-color-border);
+	background: var(--motiongpu-color-background-muted);
+}
+
+.motiongpu-error-phase {
+	display: inline-flex;
+	align-items: center;
+	margin: 0;
+	padding: 0.22rem 0.56rem;
+	border-radius: 999px;
+	font-size: 0.66rem;
+	letter-spacing: 0.08em;
+	line-height: 1;
+	font-weight: 500;
+	text-transform: uppercase;
+	color: var(--motiongpu-color-white-fixed);
+	background: linear-gradient(
+		180deg,
+		var(--motiongpu-color-accent) 0%,
+		var(--motiongpu-color-accent-secondary) 100%
+	);
+	box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.24);
+}
+
+.motiongpu-error-title {
+	margin: 0;
+	font-size: clamp(1.02rem, 1vw + 0.72rem, 1.32rem);
+	font-weight: 500;
+	line-height: 1.18;
+	letter-spacing: -0.02em;
+	text-wrap: balance;
+	color: var(--motiongpu-color-foreground);
+}
+
+.motiongpu-error-body {
+	display: grid;
+	gap: 0.62rem;
+	margin-top: 0.92rem;
+}
+
+.motiongpu-error-message {
+	margin: 0;
+	padding: 0.72rem 0.78rem;
+	border: 1px solid color-mix(in oklch, var(--motiongpu-color-accent) 28%, transparent);
+	border-radius: var(--motiongpu-radius-md);
+	background: color-mix(in oklch, var(--motiongpu-color-accent) 10%, transparent);
+	font-size: 0.82rem;
+	line-height: 1.4;
+	font-weight: 400;
+	color: var(--motiongpu-color-foreground);
+}
+
+.motiongpu-error-hint {
+	margin: 0;
+	font-size: 0.82rem;
+	line-height: 1.45;
+	font-weight: 400;
+	color: var(--motiongpu-color-foreground-muted);
+}
+
+.motiongpu-error-sections {
+	display: grid;
+	gap: 0.62rem;
+	margin-top: 0.95rem;
+}
+
+.motiongpu-error-source {
+	display: grid;
+	gap: 0.48rem;
+	margin-top: 0.96rem;
+}
+
+.motiongpu-error-source-title {
+	margin: 0;
+	font-size: 0.8rem;
+	font-weight: 500;
+	line-height: 1.3;
+	letter-spacing: 0.045em;
+	text-transform: uppercase;
+	color: var(--motiongpu-color-foreground);
+}
+
+.motiongpu-error-source-frame {
+	border: 1px solid var(--motiongpu-color-border);
+	border-radius: var(--motiongpu-radius-lg);
+	overflow: hidden;
+	background: var(--motiongpu-color-background-muted);
+}
+
+.motiongpu-error-source-tabs {
+	display: flex;
+	align-items: stretch;
+	border-bottom: 1px solid var(--motiongpu-color-border);
+	background: var(--motiongpu-color-background);
+}
+
+.motiongpu-error-source-tab {
+	display: inline-flex;
+	align-items: center;
+	padding: 0.5rem 0.68rem;
+	font-size: 0.76rem;
+	font-weight: 400;
+	line-height: 1.2;
+	color: var(--motiongpu-color-foreground-muted);
+	border-right: 1px solid var(--motiongpu-color-border);
+}
+
+.motiongpu-error-source-tab-active {
+	color: var(--motiongpu-color-foreground);
+	background: var(--motiongpu-color-background-muted);
+}
+
+.motiongpu-error-source-tab-spacer {
+	flex: 1 1 auto;
+}
+
+.motiongpu-error-source-snippet {
+	display: grid;
+	background: var(--motiongpu-color-background-muted);
+}
+
+.motiongpu-error-source-row {
+	display: grid;
+	grid-template-columns: 2rem minmax(0, 1fr);
+	align-items: start;
+	gap: 0.42rem;
+	padding: 0.2rem 0.68rem;
+}
+
+.motiongpu-error-source-row-active {
+	background: color-mix(in oklch, var(--motiongpu-color-accent) 10%, transparent);
+}
+
+.motiongpu-error-source-line {
+	font-family: var(--motiongpu-font-mono);
+	font-size: 0.77rem;
+	font-weight: 400;
+	line-height: 1.3;
+	font-variant-numeric: tabular-nums;
+	font-feature-settings: 'tnum' 1;
+	border-right: 1px solid var(--motiongpu-color-border);
+	color: var(--motiongpu-color-foreground-muted);
+	text-align: left;
+}
+
+.motiongpu-error-source-code {
+	font-family: var(--motiongpu-font-mono);
+	font-size: 0.77rem;
+	font-weight: 400;
+	line-height: 1.3;
+	color: var(--motiongpu-color-foreground);
+	white-space: pre-wrap;
+	word-break: break-word;
+}
+
+.motiongpu-error-details {
+	border: 1px solid var(--motiongpu-color-border);
+	border-radius: var(--motiongpu-radius-lg);
+	overflow: hidden;
+	background: var(--motiongpu-color-background);
+}
+
+.motiongpu-error-details summary {
+	cursor: pointer;
+	padding: 0.56rem 0.68rem;
+	font-size: 0.7rem;
+	letter-spacing: 0.07em;
+	line-height: 1.2;
+	font-weight: 500;
+	text-transform: uppercase;
+	color: var(--motiongpu-color-foreground);
+}
+
+.motiongpu-error-details[open] summary {
+	border-bottom: 1px solid var(--motiongpu-color-border);
+}
+
+.motiongpu-error-details pre {
+	margin: 0;
+	padding: 0.62rem 0.68rem;
+	white-space: pre-wrap;
+	word-break: break-word;
+	overflow: auto;
+	background: var(--motiongpu-color-background-muted);
+	font-size: 0.74rem;
+	line-height: 1.4;
+	font-weight: 400;
+	color: var(--motiongpu-color-foreground);
+	font-family: var(--motiongpu-font-mono);
+}
+
+@media (max-width: 42rem) {
+	.motiongpu-error-overlay {
+		padding: 0.62rem;
+	}
+
+	.motiongpu-error-dialog {
+		padding: 0.85rem;
+	}
+
+	.motiongpu-error-title {
+		font-size: 1.02rem;
+	}
+}
+
+@media (prefers-reduced-motion: reduce) {
+	.motiongpu-error-overlay {
+		backdrop-filter: none;
+	}
+}
+`;
+function normalizeErrorText(value) {
+    return value
+        .trim()
+        .replace(/[.:!]+$/g, '')
+        .toLowerCase();
+}
+function shouldShowErrorMessage(value) {
+    return normalizeErrorText(value.message) !== normalizeErrorText(value.title);
+}
+export function MotionGPUErrorOverlay({ report }) {
+    const detailsSummary = report.source ? 'Additional diagnostics' : 'Technical details';
+    return (_jsxs(Portal, { children: [_jsx("style", { children: MOTIONGPU_ERROR_OVERLAY_STYLES }), _jsx("div", { className: "motiongpu-error-overlay", role: "presentation", children: _jsxs("section", { className: "motiongpu-error-dialog", role: "alertdialog", "aria-live": "assertive", "aria-modal": "true", "data-testid": "motiongpu-error", children: [_jsxs("header", { className: "motiongpu-error-header", children: [_jsx("div", { className: "motiongpu-error-badge-wrap", children: _jsx("p", { className: "motiongpu-error-phase", children: report.phase }) }), _jsx("h2", { className: "motiongpu-error-title", children: report.title })] }), _jsxs("div", { className: "motiongpu-error-body", children: [shouldShowErrorMessage(report) ? (_jsx("p", { className: "motiongpu-error-message", children: report.message })) : null, _jsx("p", { className: "motiongpu-error-hint", children: report.hint })] }), report.source ? (_jsxs("section", { className: "motiongpu-error-source", "aria-label": "Source", children: [_jsx("h3", { className: "motiongpu-error-source-title", children: "Source" }), _jsxs("div", { className: "motiongpu-error-source-frame", role: "presentation", children: [_jsxs("div", { className: "motiongpu-error-source-tabs", role: "tablist", "aria-label": "Source files", children: [_jsxs("span", { className: "motiongpu-error-source-tab motiongpu-error-source-tab-active", role: "tab", "aria-selected": "true", children: [report.source.location, report.source.column ? `, col ${report.source.column}` : ''] }), _jsx("span", { className: "motiongpu-error-source-tab-spacer", "aria-hidden": "true" })] }), _jsx("div", { className: "motiongpu-error-source-snippet", children: report.source.snippet.map((snippetLine) => (_jsxs("div", { className: snippetLine.highlight
+                                                    ? 'motiongpu-error-source-row motiongpu-error-source-row-active'
+                                                    : 'motiongpu-error-source-row', children: [_jsx("span", { className: "motiongpu-error-source-line", children: snippetLine.number }), _jsx("span", { className: "motiongpu-error-source-code", children: snippetLine.code || ' ' })] }, `snippet-${snippetLine.number}`))) })] })] })) : null, _jsxs("div", { className: "motiongpu-error-sections", children: [report.details.length > 0 ? (_jsxs("details", { className: "motiongpu-error-details", open: true, children: [_jsx("summary", { children: detailsSummary }), _jsx("pre", { children: report.details.join('\n') })] })) : null, report.stack.length > 0 ? (_jsxs("details", { className: "motiongpu-error-details", children: [_jsx("summary", { children: "Stack trace" }), _jsx("pre", { children: report.stack.join('\n') })] })) : null] })] }) })] }));
+}

package/dist/react/Portal.d.ts

@@ -0,0 +1,6 @@
+import { type ReactNode } from 'react';
+export interface PortalProps {
+    target?: string | HTMLElement | null;
+    children?: ReactNode;
+}
+export declare function Portal({ target, children }: PortalProps): import("react").ReactPortal | null;

package/dist/react/Portal.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { createPortal } from 'react-dom';
+function resolveTargetElement(input) {
+    if (typeof document === 'undefined') {
+        throw new Error('Portal target resolution requires a browser environment');
+    }
+    return typeof input === 'string'
+        ? (document.querySelector(input) ?? document.body)
+        : (input ?? document.body);
+}
+export function Portal({ target = 'body', children }) {
+    const [targetElement, setTargetElement] = useState(null);
+    useEffect(() => {
+        if (typeof document === 'undefined') {
+            return;
+        }
+        setTargetElement(resolveTargetElement(target));
+    }, [target]);
+    if (!targetElement) {
+        return null;
+    }
+    return createPortal(_jsx("div", { children: children ?? null }), targetElement);
+}

package/dist/react/advanced.d.ts

@@ -0,0 +1,11 @@
+/**
+ * React adapter advanced entrypoint for MotionGPU.
+ */
+export * from './index.js';
+export { applySchedulerPreset, captureSchedulerDebugSnapshot } from '../core/scheduler-helpers.js';
+export { setMotionGPUUserContext, useMotionGPUUserContext, useSetMotionGPUUserContext } from './use-motiongpu-user-context.js';
+export type { ApplySchedulerPresetOptions, SchedulerDebugSnapshot, SchedulerPreset, SchedulerPresetConfig } from '../core/scheduler-helpers.js';
+export type { MotionGPUUserContext, MotionGPUUserNamespace } from './motiongpu-context.js';
+export type { FrameProfilingSnapshot, FrameKey, FrameTaskInvalidation, FrameTaskInvalidationToken, FrameRunTimings, FrameScheduleSnapshot, FrameStage, FrameStageCallback, FrameTimingStats, FrameTask } from '../core/frame-registry.js';
+export type { SetMotionGPUUserContextOptions } from './use-motiongpu-user-context.js';
+export type { RenderPassContext, RenderTarget, UniformLayout, UniformLayoutEntry } from '../core/types.js';

package/dist/react/advanced.js

@@ -0,0 +1,6 @@
+/**
+ * React adapter advanced entrypoint for MotionGPU.
+ */
+export * from './index.js';
+export { applySchedulerPreset, captureSchedulerDebugSnapshot } from '../core/scheduler-helpers.js';
+export { setMotionGPUUserContext, useMotionGPUUserContext, useSetMotionGPUUserContext } from './use-motiongpu-user-context.js';

package/dist/react/frame-context.d.ts

@@ -0,0 +1,14 @@
+import type { FrameCallback, FrameKey, FrameProfilingSnapshot, FrameRegistry, FrameRunTimings, FrameScheduleSnapshot, FrameStage, FrameStageCallback, FrameTask, FrameTaskInvalidation, FrameTaskInvalidationToken, UseFrameOptions, UseFrameResult } from '../core/frame-registry.js';
+/**
+ * React context container for the active frame registry.
+ */
+export declare const FrameRegistryReactContext: import("react").Context<FrameRegistry | null>;
+export type { FrameCallback, FrameKey, FrameProfilingSnapshot, FrameRegistry, FrameRunTimings, FrameScheduleSnapshot, FrameStage, FrameStageCallback, FrameTask, FrameTaskInvalidation, FrameTaskInvalidationToken, UseFrameOptions, UseFrameResult };
+/**
+ * Registers a frame callback using an auto-generated task key.
+ */
+export declare function useFrame(callback: FrameCallback, options?: UseFrameOptions): UseFrameResult;
+/**
+ * Registers a frame callback with an explicit task key.
+ */
+export declare function useFrame(key: FrameKey, callback: FrameCallback, options?: UseFrameOptions): UseFrameResult;