@motion-core/motion-gpu 0.1.0 → 0.2.0

package/dist/core/runtime-loop.js

@@ -0,0 +1,294 @@
+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;
+    const setError = (error, phase) => {
+        const report = toMotionGPUErrorReport(error, phase);
+        options.reportError(report);
+        options.getOnError()?.(report);
+    };
+    const clearError = () => {
+        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;
+        }
+        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,
+                            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/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';

package/dist/index.js

@@ -1,11 +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 * from './core/index.js';

package/dist/passes/BlitPass.d.ts

@@ -1,4 +1,4 @@
-import type { RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot } from '../core/types';
+import type { RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot } from '../core/types.js';
 export interface BlitPassOptions extends RenderPassFlags {
     enabled?: boolean;
     needsSwap?: boolean;

package/dist/passes/CopyPass.d.ts

@@ -1,4 +1,4 @@
-import type { RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot } from '../core/types';
+import type { RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot } from '../core/types.js';
 export interface CopyPassOptions extends RenderPassFlags {
     enabled?: boolean;
     needsSwap?: boolean;

package/dist/passes/CopyPass.js

@@ -1,4 +1,4 @@
-import { BlitPass } from './BlitPass';
+import { BlitPass } from './BlitPass.js';
 /**
  * Texture copy pass with fullscreen-blit fallback.
  */

package/dist/passes/ShaderPass.d.ts

@@ -1,4 +1,4 @@
-import type { RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot } from '../core/types';
+import type { RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot } from '../core/types.js';
 export interface ShaderPassOptions extends RenderPassFlags {
     fragment: string;
     enabled?: boolean;

package/dist/passes/index.d.ts

@@ -1,3 +1,3 @@
-export { BlitPass, type BlitPassOptions } from './BlitPass';
-export { CopyPass, type CopyPassOptions } from './CopyPass';
-export { ShaderPass, type ShaderPassOptions } from './ShaderPass';
+export { BlitPass, type BlitPassOptions } from './BlitPass.js';
+export { CopyPass, type CopyPassOptions } from './CopyPass.js';
+export { ShaderPass, type ShaderPassOptions } from './ShaderPass.js';

package/dist/passes/index.js

@@ -1,3 +1,3 @@
-export { BlitPass } from './BlitPass';
-export { CopyPass } from './CopyPass';
-export { ShaderPass } from './ShaderPass';
+export { BlitPass } from './BlitPass.js';
+export { CopyPass } from './CopyPass.js';
+export { ShaderPass } from './ShaderPass.js';

package/dist/svelte/FragCanvas.svelte

@@ -0,0 +1,220 @@
+<script lang="ts">
+	import { onMount } from 'svelte';
+	import type { Snippet } from 'svelte';
+	import type { FragMaterial } from '../core/material';
+	import { createCurrentWritable as currentWritable } from '../core/current-value';
+	import { toMotionGPUErrorReport, type MotionGPUErrorReport } from '../core/error-report';
+	import MotionGPUErrorOverlay from './MotionGPUErrorOverlay.svelte';
+	import { createMotionGPURuntimeLoop } from '../core/runtime-loop';
+	import type {
+		FrameInvalidationToken,
+		OutputColorSpace,
+		RenderPass,
+		RenderMode,
+		RenderTargetDefinitionMap
+	} from '../core/types';
+	import { provideMotionGPUContext } from './motiongpu-context';
+	import { createFrameRegistry, provideFrameRegistry } from './frame-context';
+
+	interface Props {
+		material: FragMaterial;
+		renderTargets?: RenderTargetDefinitionMap;
+		passes?: RenderPass[];
+		clearColor?: [number, number, number, number];
+		outputColorSpace?: OutputColorSpace;
+		renderMode?: RenderMode;
+		autoRender?: boolean;
+		maxDelta?: number;
+		adapterOptions?: GPURequestAdapterOptions;
+		deviceDescriptor?: GPUDeviceDescriptor;
+		dpr?: number;
+		showErrorOverlay?: boolean;
+		errorRenderer?: Snippet<[MotionGPUErrorReport]>;
+		onError?: (report: MotionGPUErrorReport) => void;
+		class?: string;
+		style?: string;
+		children?: Snippet;
+	}
+
+	const initialDpr = typeof window === 'undefined' ? 1 : (window.devicePixelRatio ?? 1);
+
+	let {
+		material,
+		renderTargets = {},
+		passes = [],
+		clearColor = [0, 0, 0, 1],
+		outputColorSpace = 'srgb',
+		renderMode = 'always',
+		autoRender = true,
+		maxDelta = 0.1,
+		adapterOptions = undefined,
+		deviceDescriptor = undefined,
+		dpr = initialDpr,
+		showErrorOverlay = true,
+		errorRenderer = undefined,
+		onError = undefined,
+		class: className = '',
+		style = '',
+		children
+	}: Props = $props();
+
+	let canvas: HTMLCanvasElement | undefined;
+	let errorReport = $state<MotionGPUErrorReport | null>(null);
+
+	const bindCanvas = (node: HTMLCanvasElement) => {
+		canvas = node;
+		return {
+			destroy: () => {
+				if (canvas === node) {
+					canvas = undefined;
+				}
+			}
+		};
+	};
+
+	const registry = createFrameRegistry({ maxDelta: 0.1 });
+	provideFrameRegistry(registry);
+	let requestFrameSignal: (() => void) | null = null;
+	const requestFrame = (): void => {
+		requestFrameSignal?.();
+	};
+	const invalidateFrame = (token?: FrameInvalidationToken): void => {
+		registry.invalidate(token);
+		requestFrame();
+	};
+	const advanceFrame = (): void => {
+		registry.advance();
+		requestFrame();
+	};
+	const size = currentWritable({ width: 0, height: 0 });
+	const dprState = currentWritable(initialDpr, requestFrame);
+	const maxDeltaState = currentWritable<number>(0.1, (value) => {
+		registry.setMaxDelta(value);
+		requestFrame();
+	});
+	const renderModeState = currentWritable<RenderMode>('always', (value) => {
+		registry.setRenderMode(value);
+		requestFrame();
+	});
+	const autoRenderState = currentWritable<boolean>(true, (value) => {
+		registry.setAutoRender(value);
+		requestFrame();
+	});
+	const userState = currentWritable<Record<string | symbol, unknown>>({});
+
+	provideMotionGPUContext({
+		get canvas() {
+			return canvas;
+		},
+		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
+		}
+	});
+
+	$effect(() => {
+		renderModeState.set(renderMode);
+		requestFrame();
+	});
+
+	$effect(() => {
+		autoRenderState.set(autoRender);
+		requestFrame();
+	});
+
+	$effect(() => {
+		maxDeltaState.set(maxDelta);
+		requestFrame();
+	});
+
+	$effect(() => {
+		dprState.set(dpr);
+		requestFrame();
+	});
+
+	onMount(() => {
+		if (!canvas) {
+			const report = toMotionGPUErrorReport(
+				new Error('Canvas element is not available'),
+				'initialization'
+			);
+			errorReport = report;
+			onError?.(report);
+			return () => registry.clear();
+		}
+
+		const runtimeLoop = createMotionGPURuntimeLoop({
+			canvas,
+			registry,
+			size,
+			dpr: dprState,
+			maxDelta: maxDeltaState,
+			getMaterial: () => material,
+			getRenderTargets: () => renderTargets,
+			getPasses: () => passes,
+			getClearColor: () => clearColor,
+			getOutputColorSpace: () => outputColorSpace,
+			getAdapterOptions: () => adapterOptions,
+			getDeviceDescriptor: () => deviceDescriptor,
+			getOnError: () => onError,
+			reportError: (report) => {
+				errorReport = report;
+			}
+		});
+		requestFrameSignal = runtimeLoop.requestFrame;
+
+		return () => {
+			requestFrameSignal = null;
+			runtimeLoop.destroy();
+		};
+	});
+</script>
+
+<div class="motiongpu-canvas-wrap">
+	<canvas use:bindCanvas class={className} {style}></canvas>
+	{#if showErrorOverlay && errorReport}
+		{#if errorRenderer}
+			{@render errorRenderer(errorReport)}
+		{:else}
+			<MotionGPUErrorOverlay report={errorReport} />
+		{/if}
+	{/if}
+	{@render children?.()}
+</div>
+
+<style>
+	.motiongpu-canvas-wrap {
+		position: relative;
+		width: 100%;
+		height: 100%;
+		min-width: 0;
+		min-height: 0;
+		overflow: hidden;
+	}
+
+	canvas {
+		position: absolute;
+		inset: 0;
+		display: block;
+		width: 100%;
+		height: 100%;
+	}
+</style>

package/dist/{FragCanvas.svelte.d.ts → svelte/FragCanvas.svelte.d.ts}

@@ -1,7 +1,7 @@
 import type { Snippet } from 'svelte';
-import { type FragMaterial } from './core/material';
-import { type MotionGPUErrorReport } from './core/error-report';
-import type { OutputColorSpace, RenderPass, RenderMode, RenderTargetDefinitionMap } from './core/types';
+import type { FragMaterial } from '../core/material';
+import { type MotionGPUErrorReport } from '../core/error-report';
+import type { OutputColorSpace, RenderPass, RenderMode, RenderTargetDefinitionMap } from '../core/types';
 interface Props {
     material: FragMaterial;
     renderTargets?: RenderTargetDefinitionMap;

package/dist/{MotionGPUErrorOverlay.svelte → svelte/MotionGPUErrorOverlay.svelte}

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import type { MotionGPUErrorReport } from './core/error-report';
+	import type { MotionGPUErrorReport } from '../core/error-report';
 	import Portal from './Portal.svelte';
 
 	interface Props {