@motion-core/motion-gpu 0.1.0 → 0.3.0

package/dist/core/material.js

@@ -1,6 +1,6 @@
-import { normalizeTextureDefinition } from './textures';
-import { assertUniformName, assertUniformValueForType, inferUniformType, resolveUniformLayout } from './uniforms';
-import { normalizeDefines, normalizeIncludes, preprocessMaterialFragment, toDefineLine } from './material-preprocess';
+import { normalizeTextureDefinition } from './textures.js';
+import { assertUniformName, assertUniformValueForType, inferUniformType, resolveUniformLayout } from './uniforms.js';
+import { normalizeDefines, normalizeIncludes, preprocessMaterialFragment, toDefineLine } from './material-preprocess.js';
 /**
  * Strict fragment contract used by MotionGPU.
  */

package/dist/core/recompile-policy.d.ts

@@ -1,4 +1,4 @@
-import type { OutputColorSpace } from './types';
+import type { OutputColorSpace } from './types.js';
 /**
  * Inputs that affect renderer pipeline compilation.
  */

package/dist/core/render-graph.d.ts

@@ -1,4 +1,4 @@
-import type { RenderPass, RenderPassInputSlot, RenderPassOutputSlot } from './types';
+import type { RenderPass, RenderPassInputSlot, RenderPassOutputSlot } from './types.js';
 /**
  * Resolved render-pass step with defaults applied.
  */

package/dist/core/render-targets.d.ts

@@ -1,4 +1,4 @@
-import type { RenderTargetDefinitionMap } from './types';
+import type { RenderTargetDefinitionMap } from './types.js';
 /**
  * Concrete render target configuration resolved for current canvas size.
  */

package/dist/core/render-targets.js

@@ -1,4 +1,4 @@
-import { assertUniformName } from './uniforms';
+import { assertUniformName } from './uniforms.js';
 /**
  * Asserts positive finite numeric input for render target options.
  */

package/dist/core/renderer.d.ts

@@ -1,4 +1,14 @@
-import type { Renderer, RendererOptions } from './types';
+import type { Renderer, RendererOptions } from './types.js';
+/**
+ * Computes dirty float ranges between two uniform snapshots.
+ *
+ * Adjacent dirty ranges separated by a gap smaller than or equal to
+ * {@link DIRTY_RANGE_MERGE_GAP} are merged to reduce `writeBuffer` calls.
+ */
+export declare function findDirtyFloatRanges(previous: Float32Array, next: Float32Array, mergeGapThreshold?: number): Array<{
+    start: number;
+    count: number;
+}>;
 /**
  * Creates the WebGPU renderer used by `FragCanvas`.
  *

package/dist/core/renderer.js

@@ -1,9 +1,9 @@
-import { buildRenderTargetSignature, resolveRenderTargetDefinitions } from './render-targets';
-import { planRenderGraph } from './render-graph';
-import { buildShaderSourceWithMap, formatShaderSourceLocation } from './shader';
-import { attachShaderCompilationDiagnostics } from './error-diagnostics';
-import { getTextureMipLevelCount, normalizeTextureDefinitions, resolveTextureUpdateMode, resolveTextureSize, toTextureData } from './textures';
-import { packUniformsInto } from './uniforms';
+import { buildRenderTargetSignature, resolveRenderTargetDefinitions } from './render-targets.js';
+import { planRenderGraph } from './render-graph.js';
+import { buildShaderSourceWithMap, formatShaderSourceLocation } from './shader.js';
+import { attachShaderCompilationDiagnostics } from './error-diagnostics.js';
+import { getTextureMipLevelCount, normalizeTextureDefinitions, resolveTextureUpdateMode, resolveTextureSize, toTextureData } from './textures.js';
+import { packUniformsInto } from './uniforms.js';
 /**
  * Binding index for frame uniforms (`time`, `delta`, `resolution`).
  */
@@ -78,9 +78,45 @@ async function assertCompilation(module, options) {
         ...(options?.defineBlockSource !== undefined
             ? { defineBlockSource: options.defineBlockSource }
             : {}),
-        materialSource: options?.materialSource ?? null
+        materialSource: options?.materialSource ?? null,
+        ...(options?.runtimeContext !== undefined ? { runtimeContext: options.runtimeContext } : {})
     });
 }
+function toSortedUniqueStrings(values) {
+    return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b));
+}
+function buildPassGraphSnapshot(passes) {
+    const declaredPasses = passes ?? [];
+    let enabledPassCount = 0;
+    const inputs = [];
+    const outputs = [];
+    for (const pass of declaredPasses) {
+        if (pass.enabled === false) {
+            continue;
+        }
+        enabledPassCount += 1;
+        const needsSwap = pass.needsSwap ?? true;
+        const input = pass.input ?? 'source';
+        const output = pass.output ?? (needsSwap ? 'target' : 'source');
+        inputs.push(input);
+        outputs.push(output);
+    }
+    return {
+        passCount: declaredPasses.length,
+        enabledPassCount,
+        inputs: toSortedUniqueStrings(inputs),
+        outputs: toSortedUniqueStrings(outputs)
+    };
+}
+function buildShaderCompilationRuntimeContext(options) {
+    const passList = options.getPasses?.() ?? options.passes;
+    const renderTargetMap = options.getRenderTargets?.() ?? options.renderTargets;
+    return {
+        ...(options.materialSignature ? { materialSignature: options.materialSignature } : {}),
+        passGraph: buildPassGraphSnapshot(passList),
+        activeRenderTargets: Object.keys(renderTargetMap ?? {}).sort((a, b) => a.localeCompare(b))
+    };
+}
 /**
  * Creates a 1x1 white fallback texture used before user textures become available.
  */
@@ -182,10 +218,19 @@ function createBindGroupLayoutEntries(textureBindings) {
     }
     return entries;
 }
+/**
+ * Maximum gap (in floats) between two dirty ranges that triggers merge.
+ *
+ * Set to 4 (16 bytes) which covers one vec4f alignment slot.
+ */
+const DIRTY_RANGE_MERGE_GAP = 4;
 /**
  * Computes dirty float ranges between two uniform snapshots.
+ *
+ * Adjacent dirty ranges separated by a gap smaller than or equal to
+ * {@link DIRTY_RANGE_MERGE_GAP} are merged to reduce `writeBuffer` calls.
  */
-function findDirtyFloatRanges(previous, next) {
+export function findDirtyFloatRanges(previous, next, mergeGapThreshold = DIRTY_RANGE_MERGE_GAP) {
     const ranges = [];
     let start = -1;
     for (let index = 0; index < next.length; index += 1) {
@@ -203,7 +248,22 @@ function findDirtyFloatRanges(previous, next) {
     if (start !== -1) {
         ranges.push({ start, count: next.length - start });
     }
-    return ranges;
+    if (ranges.length <= 1) {
+        return ranges;
+    }
+    const merged = [ranges[0]];
+    for (let index = 1; index < ranges.length; index += 1) {
+        const prev = merged[merged.length - 1];
+        const curr = ranges[index];
+        const gap = curr.start - (prev.start + prev.count);
+        if (gap <= mergeGapThreshold) {
+            prev.count = curr.start + curr.count - prev.start;
+        }
+        else {
+            merged.push(curr);
+        }
+    }
+    return merged;
 }
 /**
  * Determines whether shader output should perform linear-to-sRGB conversion.
@@ -339,6 +399,7 @@ export async function createRenderer(options) {
     };
     device.addEventListener('uncapturederror', handleUncapturedError);
     try {
+        const runtimeContext = buildShaderCompilationRuntimeContext(options);
         const convertLinearToSrgb = shouldConvertLinearToSrgb(options.outputColorSpace, format);
         const builtShader = buildShaderSourceWithMap(options.fragmentWgsl, options.uniformLayout, options.textureKeys, {
             convertLinearToSrgb,
@@ -352,7 +413,8 @@ export async function createRenderer(options) {
             ...(options.defineBlockSource !== undefined
                 ? { defineBlockSource: options.defineBlockSource }
                 : {}),
-            materialSource: options.materialSource ?? null
+            materialSource: options.materialSource ?? null,
+            runtimeContext
         });
         const normalizedTextureDefinitions = normalizeTextureDefinitions(options.textureDefinitions, options.textureKeys);
         const textureBindings = options.textureKeys.map((key, index) => {

package/dist/core/runtime-loop.d.ts

@@ -0,0 +1,34 @@
+import type { CurrentReadable, CurrentWritable } from './current-value.js';
+import { type FragMaterial } from './material.js';
+import { type MotionGPUErrorReport } from './error-report.js';
+import type { FrameRegistry } from './frame-registry.js';
+import type { FrameInvalidationToken, OutputColorSpace, RenderPass, RenderTargetDefinitionMap } from './types.js';
+export interface MotionGPURuntimeLoopOptions {
+    canvas: HTMLCanvasElement;
+    registry: FrameRegistry;
+    size: CurrentWritable<{
+        width: number;
+        height: number;
+    }>;
+    dpr: CurrentReadable<number>;
+    maxDelta: CurrentReadable<number>;
+    getMaterial: () => FragMaterial;
+    getRenderTargets: () => RenderTargetDefinitionMap;
+    getPasses: () => RenderPass[];
+    getClearColor: () => [number, number, number, number];
+    getOutputColorSpace: () => OutputColorSpace;
+    getAdapterOptions: () => GPURequestAdapterOptions | undefined;
+    getDeviceDescriptor: () => GPUDeviceDescriptor | undefined;
+    getOnError: () => ((report: MotionGPUErrorReport) => void) | undefined;
+    reportError: (report: MotionGPUErrorReport | null) => void;
+    getErrorHistoryLimit?: () => number | undefined;
+    getOnErrorHistory?: () => ((history: MotionGPUErrorReport[]) => void) | undefined;
+    reportErrorHistory?: (history: MotionGPUErrorReport[]) => void;
+}
+export interface MotionGPURuntimeLoop {
+    requestFrame: () => void;
+    invalidate: (token?: FrameInvalidationToken) => void;
+    advance: () => void;
+    destroy: () => void;
+}
+export declare function createMotionGPURuntimeLoop(options: MotionGPURuntimeLoopOptions): MotionGPURuntimeLoop;

package/dist/core/runtime-loop.js

@@ -0,0 +1,365 @@
+import { resolveMaterial } from './material.js';
+import { toMotionGPUErrorReport } from './error-report.js';
+import { createRenderer } from './renderer.js';
+import { buildRendererPipelineSignature } from './recompile-policy.js';
+import { assertUniformValueForType } from './uniforms.js';
+function getRendererRetryDelayMs(attempt) {
+    return Math.min(8000, 250 * 2 ** Math.max(0, attempt - 1));
+}
+export function createMotionGPURuntimeLoop(options) {
+    const { canvas: canvasElement, registry, size } = options;
+    let frameId = null;
+    let renderer = null;
+    let isDisposed = false;
+    let previousTime = performance.now() / 1000;
+    let activeRendererSignature = '';
+    let failedRendererSignature = null;
+    let failedRendererAttempts = 0;
+    let nextRendererRetryAt = 0;
+    let rendererRebuildPromise = null;
+    const runtimeUniforms = {};
+    const runtimeTextures = {};
+    let activeUniforms = {};
+    let activeTextures = {};
+    let uniformKeys = [];
+    let uniformKeySet = new Set();
+    let uniformTypes = new Map();
+    let textureKeys = [];
+    let textureKeySet = new Set();
+    let activeMaterialSignature = '';
+    let currentCssWidth = -1;
+    let currentCssHeight = -1;
+    const renderUniforms = {};
+    const renderTextures = {};
+    const canvasSize = { width: 0, height: 0 };
+    let shouldContinueAfterFrame = false;
+    let activeErrorKey = null;
+    let errorHistory = [];
+    const getHistoryLimit = () => {
+        const value = options.getErrorHistoryLimit?.() ?? 0;
+        if (!Number.isFinite(value) || value <= 0) {
+            return 0;
+        }
+        return Math.floor(value);
+    };
+    const publishErrorHistory = () => {
+        options.reportErrorHistory?.(errorHistory);
+        const onErrorHistory = options.getOnErrorHistory?.();
+        if (!onErrorHistory) {
+            return;
+        }
+        try {
+            onErrorHistory(errorHistory);
+        }
+        catch {
+            // User-provided error history handlers must not break runtime error recovery.
+        }
+    };
+    const syncErrorHistory = () => {
+        const limit = getHistoryLimit();
+        if (limit <= 0) {
+            if (errorHistory.length === 0) {
+                return;
+            }
+            errorHistory = [];
+            publishErrorHistory();
+            return;
+        }
+        if (errorHistory.length <= limit) {
+            return;
+        }
+        errorHistory = errorHistory.slice(errorHistory.length - limit);
+        publishErrorHistory();
+    };
+    const setError = (error, phase) => {
+        const report = toMotionGPUErrorReport(error, phase);
+        const reportKey = JSON.stringify({
+            phase: report.phase,
+            title: report.title,
+            message: report.message,
+            rawMessage: report.rawMessage
+        });
+        if (activeErrorKey === reportKey) {
+            return;
+        }
+        activeErrorKey = reportKey;
+        const historyLimit = getHistoryLimit();
+        if (historyLimit > 0) {
+            errorHistory = [...errorHistory, report];
+            if (errorHistory.length > historyLimit) {
+                errorHistory = errorHistory.slice(errorHistory.length - historyLimit);
+            }
+            publishErrorHistory();
+        }
+        options.reportError(report);
+        const onError = options.getOnError();
+        if (!onError) {
+            return;
+        }
+        try {
+            onError(report);
+        }
+        catch {
+            // User-provided error handlers must not break runtime error recovery.
+        }
+    };
+    const clearError = () => {
+        if (activeErrorKey === null) {
+            return;
+        }
+        activeErrorKey = null;
+        options.reportError(null);
+    };
+    const scheduleFrame = () => {
+        if (isDisposed || frameId !== null) {
+            return;
+        }
+        frameId = requestAnimationFrame(renderFrame);
+    };
+    const requestFrame = () => {
+        scheduleFrame();
+    };
+    const invalidate = (token) => {
+        registry.invalidate(token);
+        requestFrame();
+    };
+    const advance = () => {
+        registry.advance();
+        requestFrame();
+    };
+    const resetRuntimeMaps = () => {
+        for (const key of Object.keys(runtimeUniforms)) {
+            if (!uniformKeySet.has(key)) {
+                Reflect.deleteProperty(runtimeUniforms, key);
+            }
+        }
+        for (const key of Object.keys(runtimeTextures)) {
+            if (!textureKeySet.has(key)) {
+                Reflect.deleteProperty(runtimeTextures, key);
+            }
+        }
+    };
+    const resetRenderPayloadMaps = () => {
+        for (const key of Object.keys(renderUniforms)) {
+            if (!uniformKeySet.has(key)) {
+                Reflect.deleteProperty(renderUniforms, key);
+            }
+        }
+        for (const key of Object.keys(renderTextures)) {
+            if (!textureKeySet.has(key)) {
+                Reflect.deleteProperty(renderTextures, key);
+            }
+        }
+    };
+    const syncMaterialRuntimeState = (materialState) => {
+        const signatureChanged = activeMaterialSignature !== materialState.signature;
+        const defaultsChanged = activeUniforms !== materialState.uniforms || activeTextures !== materialState.textures;
+        if (!signatureChanged && !defaultsChanged) {
+            return;
+        }
+        activeUniforms = materialState.uniforms;
+        activeTextures = materialState.textures;
+        if (!signatureChanged) {
+            return;
+        }
+        uniformKeys = materialState.uniformLayout.entries.map((entry) => entry.name);
+        uniformTypes = new Map(materialState.uniformLayout.entries.map((entry) => [entry.name, entry.type]));
+        textureKeys = materialState.textureKeys;
+        uniformKeySet = new Set(uniformKeys);
+        textureKeySet = new Set(textureKeys);
+        resetRuntimeMaps();
+        resetRenderPayloadMaps();
+        activeMaterialSignature = materialState.signature;
+    };
+    const resolveActiveMaterial = () => {
+        return resolveMaterial(options.getMaterial());
+    };
+    const setUniform = (name, value) => {
+        if (!uniformKeySet.has(name)) {
+            throw new Error(`Unknown uniform "${name}". Declare it in material.uniforms first.`);
+        }
+        const expectedType = uniformTypes.get(name);
+        if (!expectedType) {
+            throw new Error(`Unknown uniform type for "${name}"`);
+        }
+        assertUniformValueForType(expectedType, value);
+        runtimeUniforms[name] = value;
+    };
+    const setTexture = (name, value) => {
+        if (!textureKeySet.has(name)) {
+            throw new Error(`Unknown texture "${name}". Declare it in material.textures first.`);
+        }
+        runtimeTextures[name] = value;
+    };
+    const renderFrame = (timestamp) => {
+        frameId = null;
+        if (isDisposed) {
+            return;
+        }
+        syncErrorHistory();
+        let materialState;
+        try {
+            materialState = resolveActiveMaterial();
+        }
+        catch (error) {
+            setError(error, 'initialization');
+            scheduleFrame();
+            return;
+        }
+        shouldContinueAfterFrame = false;
+        const outputColorSpace = options.getOutputColorSpace();
+        const rendererSignature = buildRendererPipelineSignature({
+            materialSignature: materialState.signature,
+            outputColorSpace
+        });
+        syncMaterialRuntimeState(materialState);
+        if (failedRendererSignature && failedRendererSignature !== rendererSignature) {
+            failedRendererSignature = null;
+            failedRendererAttempts = 0;
+            nextRendererRetryAt = 0;
+        }
+        if (!renderer || activeRendererSignature !== rendererSignature) {
+            if (failedRendererSignature === rendererSignature &&
+                performance.now() < nextRendererRetryAt) {
+                scheduleFrame();
+                return;
+            }
+            if (!rendererRebuildPromise) {
+                rendererRebuildPromise = (async () => {
+                    try {
+                        const nextRenderer = await createRenderer({
+                            canvas: canvasElement,
+                            fragmentWgsl: materialState.fragmentWgsl,
+                            fragmentLineMap: materialState.fragmentLineMap,
+                            fragmentSource: materialState.fragmentSource,
+                            includeSources: materialState.includeSources,
+                            defineBlockSource: materialState.defineBlockSource,
+                            materialSource: materialState.source,
+                            materialSignature: materialState.signature,
+                            uniformLayout: materialState.uniformLayout,
+                            textureKeys: materialState.textureKeys,
+                            textureDefinitions: materialState.textures,
+                            getRenderTargets: options.getRenderTargets,
+                            getPasses: options.getPasses,
+                            outputColorSpace,
+                            getClearColor: options.getClearColor,
+                            getDpr: () => options.dpr.current,
+                            adapterOptions: options.getAdapterOptions(),
+                            deviceDescriptor: options.getDeviceDescriptor()
+                        });
+                        if (isDisposed) {
+                            nextRenderer.destroy();
+                            return;
+                        }
+                        renderer?.destroy();
+                        renderer = nextRenderer;
+                        activeRendererSignature = rendererSignature;
+                        failedRendererSignature = null;
+                        failedRendererAttempts = 0;
+                        nextRendererRetryAt = 0;
+                        clearError();
+                    }
+                    catch (error) {
+                        failedRendererSignature = rendererSignature;
+                        failedRendererAttempts += 1;
+                        const retryDelayMs = getRendererRetryDelayMs(failedRendererAttempts);
+                        nextRendererRetryAt = performance.now() + retryDelayMs;
+                        setError(error, 'initialization');
+                    }
+                    finally {
+                        rendererRebuildPromise = null;
+                        scheduleFrame();
+                    }
+                })();
+            }
+            return;
+        }
+        const time = timestamp / 1000;
+        const rawDelta = Math.max(0, time - previousTime);
+        const delta = Math.min(rawDelta, options.maxDelta.current);
+        previousTime = time;
+        const rect = canvasElement.getBoundingClientRect();
+        const width = Math.max(0, Math.floor(rect.width));
+        const height = Math.max(0, Math.floor(rect.height));
+        if (width !== currentCssWidth || height !== currentCssHeight) {
+            currentCssWidth = width;
+            currentCssHeight = height;
+            size.set({ width, height });
+        }
+        try {
+            registry.run({
+                time,
+                delta,
+                setUniform,
+                setTexture,
+                invalidate,
+                advance,
+                renderMode: registry.getRenderMode(),
+                autoRender: registry.getAutoRender(),
+                canvas: canvasElement
+            });
+            const shouldRenderFrame = registry.shouldRender();
+            shouldContinueAfterFrame =
+                registry.getRenderMode() === 'always' ||
+                    (registry.getRenderMode() === 'on-demand' && shouldRenderFrame);
+            if (shouldRenderFrame) {
+                for (const key of uniformKeys) {
+                    const runtimeValue = runtimeUniforms[key];
+                    renderUniforms[key] =
+                        runtimeValue === undefined ? activeUniforms[key] : runtimeValue;
+                }
+                for (const key of textureKeys) {
+                    const runtimeValue = runtimeTextures[key];
+                    renderTextures[key] =
+                        runtimeValue === undefined ? (activeTextures[key]?.source ?? null) : runtimeValue;
+                }
+                canvasSize.width = width;
+                canvasSize.height = height;
+                renderer.render({
+                    time,
+                    delta,
+                    renderMode: registry.getRenderMode(),
+                    uniforms: renderUniforms,
+                    textures: renderTextures,
+                    canvasSize
+                });
+            }
+            clearError();
+        }
+        catch (error) {
+            setError(error, 'render');
+        }
+        finally {
+            registry.endFrame();
+        }
+        if (shouldContinueAfterFrame) {
+            scheduleFrame();
+        }
+    };
+    (async () => {
+        try {
+            const initialMaterial = resolveActiveMaterial();
+            syncMaterialRuntimeState(initialMaterial);
+            activeRendererSignature = '';
+            scheduleFrame();
+        }
+        catch (error) {
+            setError(error, 'initialization');
+            scheduleFrame();
+        }
+    })();
+    return {
+        requestFrame,
+        invalidate,
+        advance,
+        destroy: () => {
+            isDisposed = true;
+            if (frameId !== null) {
+                cancelAnimationFrame(frameId);
+                frameId = null;
+            }
+            renderer?.destroy();
+            registry.clear();
+        }
+    };
+}

package/dist/{advanced-scheduler.d.ts → core/scheduler-helpers.d.ts}

@@ -1,6 +1,10 @@
-import type { FrameProfilingSnapshot, FrameRunTimings, FrameScheduleSnapshot, MotionGPUScheduler } from './motiongpu-context';
+import type { FrameProfilingSnapshot, FrameRegistry, FrameRunTimings, FrameScheduleSnapshot } from './frame-registry.js';
 /**
- * Named scheduler presets exposed from the advanced entrypoint.
+ * Public scheduler control surface shared by framework adapters.
+ */
+export type MotionGPUScheduler = Pick<FrameRegistry, 'createStage' | 'getStage' | 'setDiagnosticsEnabled' | 'getDiagnosticsEnabled' | 'getLastRunTimings' | 'getSchedule' | 'setProfilingEnabled' | 'setProfilingWindow' | 'resetProfiling' | 'getProfilingEnabled' | 'getProfilingWindow' | 'getProfilingSnapshot'>;
+/**
+ * Named scheduler presets exposed from advanced entrypoints.
  */
 export type SchedulerPreset = 'balanced' | 'debug' | 'performance';
 /**

package/dist/core/shader.d.ts

@@ -1,5 +1,5 @@
-import type { MaterialLineMap, MaterialSourceLocation } from './material-preprocess';
-import type { UniformLayout } from './types';
+import type { MaterialLineMap, MaterialSourceLocation } from './material-preprocess.js';
+import type { UniformLayout } from './types.js';
 /**
  * 1-based map from generated WGSL lines to original material source lines.
  */

package/dist/core/shader.js

@@ -1,4 +1,4 @@
-import { assertUniformName } from './uniforms';
+import { assertUniformName } from './uniforms.js';
 /**
  * Fallback uniform field used when no custom uniforms are provided.
  */

package/dist/core/texture-loader.d.ts

@@ -1,4 +1,4 @@
-import type { TextureUpdateMode } from './types';
+import type { TextureUpdateMode } from './types.js';
 /**
  * Options controlling bitmap decode behavior.
  */

package/dist/core/textures.d.ts

@@ -1,4 +1,4 @@
-import type { TextureData, TextureDefinition, TextureDefinitionMap, TextureUpdateMode, TextureValue } from './types';
+import type { TextureData, TextureDefinition, TextureDefinitionMap, TextureUpdateMode, TextureValue } from './types.js';
 /**
  * Texture definition with defaults and normalized numeric limits applied.
  */

package/dist/core/textures.js

@@ -1,4 +1,4 @@
-import { assertUniformName } from './uniforms';
+import { assertUniformName } from './uniforms.js';
 /**
  * Default sampling filter for textures when no explicit value is provided.
  */

package/dist/core/types.d.ts

@@ -443,6 +443,10 @@ export interface RendererOptions {
         column?: number;
         functionName?: string;
     } | null;
+    /**
+     * Stable material signature captured during resolution.
+     */
+    materialSignature?: string;
     /**
      * Resolved uniform layout.
      */

package/dist/core/uniforms.d.ts

@@ -1,4 +1,4 @@
-import type { UniformLayout, UniformMap, UniformType, UniformValue } from './types';
+import type { UniformLayout, UniformMap, UniformType, UniformValue } from './types.js';
 /**
  * Asserts that a name can be safely used as a WGSL identifier.
  *

package/dist/index.d.ts

@@ -1,17 +1,6 @@
 /**
- * Public MotionGPU package entrypoint.
+ * Root package entrypoint.
  *
- * Exposes the production-ready core API for fullscreen WGSL rendering workflows.
+ * Framework-agnostic core entrypoint.
  */
-export { default as FragCanvas } from './FragCanvas.svelte';
-export { defineMaterial } from './core/material';
-export { BlitPass, CopyPass, ShaderPass } from './passes';
-export { useMotionGPU } from './motiongpu-context';
-export { useFrame } from './frame-context';
-export { useTexture } from './use-texture';
-export type { FrameInvalidationToken, FrameState, OutputColorSpace, RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot, RenderMode, RenderTarget, RenderTargetDefinition, RenderTargetDefinitionMap, TextureData, TextureDefinition, TextureDefinitionMap, TextureUpdateMode, TextureMap, TextureSource, TextureValue, TypedUniform, UniformMat4Value, UniformMap, UniformType, UniformValue } from './core/types';
-export type { LoadedTexture, TextureDecodeOptions, TextureLoadOptions } from './core/texture-loader';
-export type { FragMaterial, FragMaterialInput, MaterialIncludes, MaterialDefineValue, MaterialDefines, TypedMaterialDefineValue } from './core/material';
-export type { MotionGPUContext } from './motiongpu-context';
-export type { UseFrameOptions, UseFrameResult } from './frame-context';
-export type { TextureUrlInput, UseTextureResult } from './use-texture';
+export * from './core/index.js';