@motion-core/motion-gpu 0.1.0 → 0.3.0

package/dist/svelte/FragCanvas.svelte

@@ -0,0 +1,263 @@
+<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;
+		errorHistoryLimit?: number;
+		onErrorHistory?: (history: 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,
+		errorHistoryLimit = 0,
+		onErrorHistory = undefined,
+		class: className = '',
+		style = '',
+		children
+	}: Props = $props();
+
+	let canvas: HTMLCanvasElement | undefined;
+	let errorReport = $state<MotionGPUErrorReport | null>(null);
+	let errorHistory = $state<MotionGPUErrorReport[]>([]);
+
+	const getNormalizedErrorHistoryLimit = (): number => {
+		if (!Number.isFinite(errorHistoryLimit) || errorHistoryLimit <= 0) {
+			return 0;
+		}
+		return Math.floor(errorHistoryLimit);
+	};
+
+	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();
+	});
+
+	$effect(() => {
+		const limit = getNormalizedErrorHistoryLimit();
+		if (limit <= 0) {
+			if (errorHistory.length === 0) {
+				return;
+			}
+			errorHistory = [];
+			onErrorHistory?.([]);
+			return;
+		}
+
+		if (errorHistory.length <= limit) {
+			return;
+		}
+
+		const trimmed = errorHistory.slice(errorHistory.length - limit);
+		errorHistory = trimmed;
+		onErrorHistory?.(trimmed);
+	});
+
+	onMount(() => {
+		if (!canvas) {
+			const report = toMotionGPUErrorReport(
+				new Error('Canvas element is not available'),
+				'initialization'
+			);
+			errorReport = report;
+			const historyLimit = getNormalizedErrorHistoryLimit();
+			if (historyLimit > 0) {
+				const nextHistory = [report].slice(-historyLimit);
+				errorHistory = nextHistory;
+				onErrorHistory?.(nextHistory);
+			}
+			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,
+			getErrorHistoryLimit: () => errorHistoryLimit,
+			getOnErrorHistory: () => onErrorHistory,
+			reportErrorHistory: (history) => {
+				errorHistory = history;
+			},
+			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;
@@ -17,6 +17,8 @@ interface Props {
     showErrorOverlay?: boolean;
     errorRenderer?: Snippet<[MotionGPUErrorReport]>;
     onError?: (report: MotionGPUErrorReport) => void;
+    errorHistoryLimit?: number;
+    onErrorHistory?: (history: MotionGPUErrorReport[]) => void;
     class?: string;
     style?: string;
     children?: Snippet;

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 {
@@ -53,9 +53,8 @@
 								class="motiongpu-error-source-tab motiongpu-error-source-tab-active"
 								role="tab"
 								aria-selected="true"
-								>{report.source.component} (fragment line {report.source
-									.line}{#if report.source.column}, col
-									{report.source.column}{/if})</span
+								>{report.source.location}{#if report.source.column}, col {report.source
+										.column}{/if}</span
 							>
 							<span class="motiongpu-error-source-tab-spacer" aria-hidden="true"></span>
 						</div>
@@ -117,21 +116,13 @@
 		--motiongpu-radius-xl: var(--radius-xl, 1rem);
 		--motiongpu-font-sans: var(
 			--font-sans,
-			'Aeonik Pro',
 			'Inter',
 			'Segoe UI',
 			'Helvetica Neue',
 			Arial,
 			sans-serif
 		);
-		--motiongpu-font-mono: var(
-			--font-mono,
-			'Aeonik font-mono',
-			'SFMono-Regular',
-			'Menlo',
-			'Consolas',
-			monospace
-		);
+		--motiongpu-font-mono: var(--font-mono, 'SFMono-Regular', 'Menlo', 'Consolas', monospace);
 		position: fixed;
 		inset: 0;
 		display: grid;
@@ -156,7 +147,7 @@
 		max-width: calc(100vw - 1.5rem);
 		box-sizing: border-box;
 		font-size: 0.875rem;
-		font-weight: 300;
+		font-weight: 400;
 		line-height: 1.45;
 		background: linear-gradient(
 			180deg,
@@ -229,7 +220,7 @@
 		background: color-mix(in srgb, var(--motiongpu-color-accent) 9%, var(--motiongpu-color-card));
 		font-size: 0.82rem;
 		line-height: 1.4;
-		font-weight: 300;
+		font-weight: 400;
 		color: var(--motiongpu-color-foreground);
 	}
 
@@ -237,7 +228,7 @@
 		margin: 0;
 		font-size: 0.82rem;
 		line-height: 1.45;
-		font-weight: 300;
+		font-weight: 400;
 		color: var(--motiongpu-color-foreground-muted);
 	}
 
@@ -282,7 +273,7 @@
 		align-items: center;
 		padding: 0.5rem 0.68rem;
 		font-size: 0.76rem;
-		font-weight: 300;
+		font-weight: 400;
 		line-height: 1.2;
 		color: var(--motiongpu-color-foreground-muted);
 		border-right: 1px solid var(--motiongpu-color-border);
@@ -317,7 +308,7 @@
 	.motiongpu-error-source-line {
 		font-family: var(--motiongpu-font-mono);
 		font-size: 0.77rem;
-		font-weight: 300;
+		font-weight: 400;
 		line-height: 1.3;
 		font-variant-numeric: tabular-nums;
 		font-feature-settings: 'tnum' 1;
@@ -329,7 +320,7 @@
 	.motiongpu-error-source-code {
 		font-family: var(--motiongpu-font-mono);
 		font-size: 0.77rem;
-		font-weight: 350;
+		font-weight: 400;
 		line-height: 1.3;
 		color: var(--motiongpu-color-foreground);
 		white-space: pre-wrap;
@@ -367,7 +358,7 @@
 		background: var(--motiongpu-color-background-muted);
 		font-size: 0.74rem;
 		line-height: 1.4;
-		font-weight: 300;
+		font-weight: 400;
 		color: var(--motiongpu-color-foreground);
 		font-family: var(--motiongpu-font-mono);
 	}

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

@@ -1,4 +1,4 @@
-import type { MotionGPUErrorReport } from './core/error-report';
+import type { MotionGPUErrorReport } from '../core/error-report';
 interface Props {
     report: MotionGPUErrorReport;
 }

package/dist/svelte/advanced.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Svelte adapter advanced entrypoint for MotionGPU.
+ */
+export * from './index.js';
+export { applySchedulerPreset, captureSchedulerDebugSnapshot } from '../core/scheduler-helpers.js';
+export { setMotionGPUUserContext, useMotionGPUUserContext } 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/svelte/advanced.js

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

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

@@ -0,0 +1,14 @@
+import { createFrameRegistry, type FrameCallback, type FrameKey, type FrameProfilingSnapshot, type FrameRegistry, type FrameRunTimings, type FrameScheduleSnapshot, type FrameStage, type FrameStageCallback, type FrameTask, type FrameTaskInvalidation, type FrameTaskInvalidationToken, type UseFrameOptions, type UseFrameResult } from '../core/frame-registry.js';
+export { createFrameRegistry, type FrameCallback, type FrameKey, type FrameProfilingSnapshot, type FrameRegistry, type FrameRunTimings, type FrameScheduleSnapshot, type FrameStage, type FrameStageCallback, type FrameTask, type FrameTaskInvalidation, type FrameTaskInvalidationToken, type UseFrameOptions, type UseFrameResult };
+/**
+ * Provides a frame registry through Svelte context.
+ */
+export declare function provideFrameRegistry(registry: FrameRegistry): void;
+/**
+ * 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;

package/dist/svelte/frame-context.js

@@ -0,0 +1,32 @@
+import { getContext, onDestroy, setContext } from 'svelte';
+import { createFrameRegistry } from '../core/frame-registry.js';
+/**
+ * Svelte context key for the active frame registry.
+ */
+const FRAME_CONTEXT_KEY = Symbol('motiongpu.frame-context');
+export { createFrameRegistry };
+/**
+ * Provides a frame registry through Svelte context.
+ */
+export function provideFrameRegistry(registry) {
+    setContext(FRAME_CONTEXT_KEY, registry);
+}
+/**
+ * Registers a callback in the active frame registry and auto-unsubscribes on destroy.
+ */
+export function useFrame(keyOrCallback, callbackOrOptions, maybeOptions) {
+    const registry = getContext(FRAME_CONTEXT_KEY);
+    if (!registry) {
+        throw new Error('useFrame must be used inside <FragCanvas>');
+    }
+    const registration = typeof keyOrCallback === 'function'
+        ? registry.register(keyOrCallback, callbackOrOptions)
+        : registry.register(keyOrCallback, callbackOrOptions, maybeOptions);
+    onDestroy(registration.unsubscribe);
+    return {
+        task: registration.task,
+        start: registration.start,
+        stop: registration.stop,
+        started: registration.started
+    };
+}

package/dist/svelte/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Svelte adapter entrypoint for MotionGPU.
+ */
+export { default as FragCanvas } from './FragCanvas.svelte';
+export { defineMaterial } from '../core/material.js';
+export { BlitPass, CopyPass, ShaderPass } from '../passes/index.js';
+export { useMotionGPU } from './motiongpu-context.js';
+export { useFrame } from './frame-context.js';
+export { useTexture } from './use-texture.js';
+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.js';
+export type { LoadedTexture, TextureDecodeOptions, TextureLoadOptions } from '../core/texture-loader.js';
+export type { FragMaterial, FragMaterialInput, MaterialIncludes, MaterialDefineValue, MaterialDefines, TypedMaterialDefineValue } from '../core/material.js';
+export type { MotionGPUContext } from './motiongpu-context.js';
+export type { UseFrameOptions, UseFrameResult } from './frame-context.js';
+export type { TextureUrlInput, UseTextureResult } from './use-texture.js';

package/dist/svelte/index.js

@@ -0,0 +1,9 @@
+/**
+ * Svelte adapter entrypoint for MotionGPU.
+ */
+export { default as FragCanvas } from './FragCanvas.svelte';
+export { defineMaterial } from '../core/material.js';
+export { BlitPass, CopyPass, ShaderPass } from '../passes/index.js';
+export { useMotionGPU } from './motiongpu-context.js';
+export { useFrame } from './frame-context.js';
+export { useTexture } from './use-texture.js';

package/dist/{motiongpu-context.d.ts → svelte/motiongpu-context.d.ts}

@@ -1,10 +1,8 @@
-import type { RenderMode } from './core/types';
-import type { CurrentReadable, CurrentWritable } from './current-writable';
-import type { FrameProfilingSnapshot, FrameRegistry, FrameRunTimings, FrameScheduleSnapshot } from './frame-context';
-/**
- * Exposed subset of frame scheduler controls intended for public consumption.
- */
-export type MotionGPUScheduler = Pick<FrameRegistry, 'createStage' | 'getStage' | 'setDiagnosticsEnabled' | 'getDiagnosticsEnabled' | 'getLastRunTimings' | 'getSchedule' | 'setProfilingEnabled' | 'setProfilingWindow' | 'resetProfiling' | 'getProfilingEnabled' | 'getProfilingWindow' | 'getProfilingSnapshot'>;
+import type { RenderMode } from '../core/types.js';
+import type { CurrentReadable, CurrentWritable } from '../core/current-value.js';
+import type { FrameProfilingSnapshot, FrameRunTimings, FrameScheduleSnapshot } from '../core/frame-registry.js';
+import type { MotionGPUScheduler as CoreMotionGPUScheduler } from '../core/scheduler-helpers.js';
+export type MotionGPUScheduler = CoreMotionGPUScheduler;
 export type { FrameProfilingSnapshot, FrameRunTimings, FrameScheduleSnapshot };
 /**
  * Namespace identifier for user-owned context entries.

package/dist/{use-motiongpu-user-context.d.ts → svelte/use-motiongpu-user-context.d.ts}

@@ -1,5 +1,5 @@
-import type { CurrentReadable } from './current-writable';
-import { type MotionGPUUserNamespace } from './motiongpu-context';
+import type { CurrentReadable } from '../core/current-value.js';
+import { type MotionGPUUserNamespace } from './motiongpu-context.js';
 /**
  * Internal shape of the user context store.
  */

package/dist/{use-motiongpu-user-context.js → svelte/use-motiongpu-user-context.js}

@@ -1,4 +1,4 @@
-import { useMotionGPU } from './motiongpu-context';
+import { useMotionGPU } from './motiongpu-context.js';
 /**
  * Checks whether a value is a non-array object suitable for shallow merge.
  */

package/dist/{use-texture.d.ts → svelte/use-texture.d.ts}

@@ -1,5 +1,6 @@
-import type { CurrentReadable } from './current-writable';
-import { type LoadedTexture, type TextureLoadOptions } from './core/texture-loader';
+import { type CurrentReadable } from '../core/current-value.js';
+import { type LoadedTexture, type TextureLoadOptions } from '../core/texture-loader.js';
+import { type MotionGPUErrorReport } from '../core/error-report.js';
 /**
  * Reactive state returned by {@link useTexture}.
  */
@@ -16,6 +17,10 @@ export interface UseTextureResult {
      * Last loading error.
      */
     error: CurrentReadable<Error | null>;
+    /**
+     * Last loading error normalized to MotionGPU diagnostics report shape.
+     */
+    errorReport: CurrentReadable<MotionGPUErrorReport | null>;
     /**
      * Reloads all textures using current URL input.
      */

package/dist/{use-texture.js → svelte/use-texture.js}

@@ -1,6 +1,7 @@
 import { onDestroy } from 'svelte';
-import { currentWritable } from './current-writable';
-import { isAbortError, loadTexturesFromUrls } from './core/texture-loader';
+import { createCurrentWritable as currentWritable } from '../core/current-value.js';
+import { isAbortError, loadTexturesFromUrls } from '../core/texture-loader.js';
+import { toMotionGPUErrorReport } from '../core/error-report.js';
 /**
  * Normalizes unknown thrown values to an `Error` instance.
  */
@@ -60,6 +61,7 @@ export function useTexture(urlInput, options = {}) {
     const textures = currentWritable(null);
     const loading = currentWritable(true);
     const error = currentWritable(null);
+    const errorReport = currentWritable(null);
     let disposed = false;
     let requestVersion = 0;
     let activeController = null;
@@ -75,6 +77,7 @@ export function useTexture(urlInput, options = {}) {
         activeController = controller;
         loading.set(true);
         error.set(null);
+        errorReport.set(null);
         const previous = textures.current;
         const mergedSignal = mergeAbortSignals(controller.signal, options.signal);
         try {
@@ -98,7 +101,9 @@ export function useTexture(urlInput, options = {}) {
             }
             disposeTextures(previous);
             textures.set(null);
-            error.set(toError(nextError));
+            const normalizedError = toError(nextError);
+            error.set(normalizedError);
+            errorReport.set(toMotionGPUErrorReport(normalizedError, 'initialization'));
         }
         finally {
             if (!disposed && version === requestVersion) {
@@ -142,6 +147,7 @@ export function useTexture(urlInput, options = {}) {
         textures,
         loading,
         error,
+        errorReport,
         reload: load
     };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@motion-core/motion-gpu",
-	"version": "0.1.0",
-	"description": "Svelte 5 package for fullscreen WGSL shaders with a WebGPU runtime, scheduler, and render graph.",
+	"version": "0.3.0",
+	"description": "Framework-agnostic WebGPU runtime for fullscreen WGSL shaders with explicit Svelte adapter entrypoints.",
 	"keywords": [
 		"svelte",
 		"svelte5",
@@ -26,18 +26,33 @@
 		"access": "public"
 	},
 	"type": "module",
-	"svelte": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
-			"svelte": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
 		"./advanced": {
 			"types": "./dist/advanced.d.ts",
-			"svelte": "./dist/advanced.js",
 			"default": "./dist/advanced.js"
+		},
+		"./svelte": {
+			"types": "./dist/svelte/index.d.ts",
+			"svelte": "./dist/svelte/index.js",
+			"default": "./dist/svelte/index.js"
+		},
+		"./svelte/advanced": {
+			"types": "./dist/svelte/advanced.d.ts",
+			"svelte": "./dist/svelte/advanced.js",
+			"default": "./dist/svelte/advanced.js"
+		},
+		"./core": {
+			"types": "./dist/core/index.d.ts",
+			"default": "./dist/core/index.js"
+		},
+		"./core/advanced": {
+			"types": "./dist/core/advanced.d.ts",
+			"default": "./dist/core/advanced.js"
 		}
 	},
 	"files": [
@@ -65,6 +80,11 @@
 	"peerDependencies": {
 		"svelte": "^5.0.0"
 	},
+	"peerDependenciesMeta": {
+		"svelte": {
+			"optional": true
+		}
+	},
 	"devDependencies": {
 		"@eslint/compat": "^2.0.2",
 		"@eslint/js": "^10.0.1",