@motion-core/motion-gpu 0.5.0 → 0.7.0

package/src/lib/core/runtime-loop.ts

@@ -54,6 +54,8 @@ function getRendererRetryDelayMs(attempt: number): number {
 	return Math.min(8000, 250 * 2 ** Math.max(0, attempt - 1));
 }
 
+const ERROR_CLEAR_GRACE_MS = 750;
+
 export function createMotionGPURuntimeLoop(
 	options: MotionGPURuntimeLoopOptions
 ): MotionGPURuntimeLoop {
@@ -90,6 +92,16 @@ export function createMotionGPURuntimeLoop(
 	let shouldContinueAfterFrame = false;
 	let activeErrorKey: string | null = null;
 	let errorHistory: MotionGPUErrorReport[] = [];
+	let errorClearReadyAtMs = 0;
+	let lastFrameTimestampMs = performance.now();
+
+	const resolveNowMs = (nowMs?: number): number => {
+		if (typeof nowMs === 'number' && Number.isFinite(nowMs)) {
+			return nowMs;
+		}
+
+		return lastFrameTimestampMs;
+	};
 
 	const getHistoryLimit = (): number => {
 		const value = options.getErrorHistoryLimit?.() ?? 0;
@@ -129,12 +141,13 @@ export function createMotionGPURuntimeLoop(
 			return;
 		}
 
-		errorHistory = errorHistory.slice(errorHistory.length - limit);
+		errorHistory.splice(0, errorHistory.length - limit);
 		publishErrorHistory();
 	};
 
-	const setError = (error: unknown, phase: MotionGPUErrorPhase): void => {
+	const setError = (error: unknown, phase: MotionGPUErrorPhase, nowMs?: number): void => {
 		const report = toMotionGPUErrorReport(error, phase);
+		errorClearReadyAtMs = resolveNowMs(nowMs) + ERROR_CLEAR_GRACE_MS;
 		const reportKey = JSON.stringify({
 			phase: report.phase,
 			title: report.title,
@@ -147,9 +160,9 @@ export function createMotionGPURuntimeLoop(
 		activeErrorKey = reportKey;
 		const historyLimit = getHistoryLimit();
 		if (historyLimit > 0) {
-			errorHistory = [...errorHistory, report];
+			errorHistory.push(report);
 			if (errorHistory.length > historyLimit) {
-				errorHistory = errorHistory.slice(errorHistory.length - historyLimit);
+				errorHistory.splice(0, errorHistory.length - historyLimit);
 			}
 			publishErrorHistory();
 		}
@@ -166,12 +179,16 @@ export function createMotionGPURuntimeLoop(
 		}
 	};
 
-	const clearError = (): void => {
+	const maybeClearError = (nowMs?: number): void => {
 		if (activeErrorKey === null) {
 			return;
 		}
+		if (resolveNowMs(nowMs) < errorClearReadyAtMs) {
+			return;
+		}
 
 		activeErrorKey = null;
+		errorClearReadyAtMs = 0;
 		options.reportError(null);
 	};
 
@@ -200,13 +217,13 @@ export function createMotionGPURuntimeLoop(
 	const resetRuntimeMaps = (): void => {
 		for (const key of Object.keys(runtimeUniforms)) {
 			if (!uniformKeySet.has(key)) {
-				Reflect.deleteProperty(runtimeUniforms, key);
+				delete runtimeUniforms[key];
 			}
 		}
 
 		for (const key of Object.keys(runtimeTextures)) {
 			if (!textureKeySet.has(key)) {
-				Reflect.deleteProperty(runtimeTextures, key);
+				delete runtimeTextures[key];
 			}
 		}
 	};
@@ -214,13 +231,13 @@ export function createMotionGPURuntimeLoop(
 	const resetRenderPayloadMaps = (): void => {
 		for (const key of Object.keys(renderUniforms)) {
 			if (!uniformKeySet.has(key)) {
-				Reflect.deleteProperty(renderUniforms, key);
+				delete renderUniforms[key];
 			}
 		}
 
 		for (const key of Object.keys(renderTextures)) {
 			if (!textureKeySet.has(key)) {
-				Reflect.deleteProperty(renderTextures, key);
+				delete renderTextures[key];
 			}
 		}
 	};
@@ -345,13 +362,14 @@ export function createMotionGPURuntimeLoop(
 		if (isDisposed) {
 			return;
 		}
+		lastFrameTimestampMs = timestamp;
 		syncErrorHistory();
 
 		let materialState: ResolvedMaterial;
 		try {
 			materialState = resolveActiveMaterial();
 		} catch (error) {
-			setError(error, 'initialization');
+			setError(error, 'initialization', timestamp);
 			scheduleFrame();
 			return;
 		}
@@ -418,7 +436,7 @@ export function createMotionGPURuntimeLoop(
 						failedRendererSignature = null;
 						failedRendererAttempts = 0;
 						nextRendererRetryAt = 0;
-						clearError();
+						maybeClearError(performance.now());
 					} catch (error) {
 						failedRendererSignature = rendererSignature;
 						failedRendererAttempts += 1;
@@ -490,15 +508,18 @@ export function createMotionGPURuntimeLoop(
 					uniforms: renderUniforms,
 					textures: renderTextures,
 					canvasSize,
-					...(pendingStorageWrites.length > 0
-						? { pendingStorageWrites: pendingStorageWrites.splice(0) }
-						: {})
+					pendingStorageWrites: pendingStorageWrites.length > 0 ? pendingStorageWrites : undefined
 				});
+				// Clear in-place after synchronous render() completes — avoids
+				// the splice(0) copy and eliminates the conditional spread object.
+				if (pendingStorageWrites.length > 0) {
+					pendingStorageWrites.length = 0;
+				}
 			}
 
-			clearError();
+			maybeClearError(timestamp);
 		} catch (error) {
-			setError(error, 'render');
+			setError(error, 'render', timestamp);
 		} finally {
 			registry.endFrame();
 		}

package/src/lib/core/shader.ts

@@ -2,6 +2,11 @@ import { assertUniformName } from './uniforms.js';
 import type { MaterialLineMap, MaterialSourceLocation } from './material-preprocess.js';
 import type { StorageBufferType, UniformLayout } from './types.js';
 
+type ComputeShaderSourceLocation = {
+	kind: 'compute';
+	line: number;
+};
+
 /**
  * Fallback uniform field used when no custom uniforms are provided.
  */
@@ -146,7 +151,7 @@ function buildFragmentOutput(keepAliveExpression: string, enableSrgbTransform: b
 /**
  * 1-based map from generated WGSL lines to original material source lines.
  */
-export type ShaderLineMap = Array<MaterialSourceLocation | null>;
+export type ShaderLineMap = Array<(MaterialSourceLocation | ComputeShaderSourceLocation) | null>;
 
 /**
  * Result of shader source generation with line mapping metadata.
@@ -284,7 +289,9 @@ export function buildShaderSourceWithMap(
 /**
  * Converts source location metadata to user-facing diagnostics label.
  */
-export function formatShaderSourceLocation(location: MaterialSourceLocation | null): string | null {
+export function formatShaderSourceLocation(
+	location: (MaterialSourceLocation | ComputeShaderSourceLocation) | null
+): string | null {
 	if (!location) {
 		return null;
 	}
@@ -297,5 +304,9 @@ export function formatShaderSourceLocation(location: MaterialSourceLocation | nu
 		return `include <${location.include}> line ${location.line}`;
 	}
 
+	if (location.kind === 'compute') {
+		return `compute line ${location.line}`;
+	}
+
 	return `define "${location.define}" line ${location.line}`;
 }

package/src/lib/core/textures.ts

@@ -59,6 +59,10 @@ export interface NormalizedTextureDefinition {
 	 * Whether this texture is a storage texture (writable by compute).
 	 */
 	storage: boolean;
+	/**
+	 * Whether this texture should be exposed as a fragment-stage sampled binding.
+	 */
+	fragmentVisible: boolean;
 	/**
 	 * Explicit width for storage textures. Undefined when derived from source.
 	 */
@@ -115,7 +119,8 @@ export function normalizeTextureDefinition(
 		filter: definition?.filter ?? DEFAULT_TEXTURE_FILTER,
 		addressModeU: definition?.addressModeU ?? DEFAULT_TEXTURE_ADDRESS_MODE,
 		addressModeV: definition?.addressModeV ?? DEFAULT_TEXTURE_ADDRESS_MODE,
-		storage: isStorage
+		storage: isStorage,
+		fragmentVisible: definition?.fragmentVisible ?? true
 	};
 
 	if (definition?.width !== undefined) {

package/src/lib/core/types.ts

@@ -726,7 +726,7 @@ export interface Renderer {
 			width: number;
 			height: number;
 		};
-		pendingStorageWrites?: PendingStorageWrite[];
+		pendingStorageWrites?: PendingStorageWrite[] | undefined;
 	}) => void;
 	/**
 	 * Returns the GPU buffer for a named storage buffer, if allocated.

package/src/lib/react/index.ts

@@ -12,6 +12,7 @@ export {
 } from '../passes/index.js';
 export { useMotionGPU } from './motiongpu-context.js';
 export { useFrame } from './frame-context.js';
+export { usePointer } from './use-pointer.js';
 export { useTexture } from './use-texture.js';
 export type {
 	FrameInvalidationToken,
@@ -56,6 +57,15 @@ export type {
 } from '../core/material.js';
 export type { MotionGPUContext } from './motiongpu-context.js';
 export type { UseFrameOptions, UseFrameResult } from './frame-context.js';
+export type {
+	PointerClick,
+	PointerFrameRequestMode,
+	PointerKind,
+	PointerPoint,
+	PointerState,
+	UsePointerOptions,
+	UsePointerResult
+} from './use-pointer.js';
 export type { TextureUrlInput, UseTextureResult } from './use-texture.js';
 export type {
 	StorageBufferAccess,