@motion-core/motion-gpu 0.1.0 → 0.3.0

package/README.md

@@ -12,8 +12,8 @@
 
 **A tiny WebGPU runtime for writing Shadertoy-style fullscreen shaders in pure WGSL.**
 
-`@motion-core/motion-gpu` is a Svelte 5 package for building fullscreen shader pipelines using WebGPU and WGSL.
-It provides a minimal runtime, scheduler, and render graph designed specifically for fragment-driven GPU programs.
+`@motion-core/motion-gpu` ships a framework-agnostic core plus a Svelte 5 adapter for building fullscreen shader pipelines using WebGPU and WGSL.
+It provides a minimal runtime loop, scheduler, and render graph designed specifically for fragment-driven GPU programs.
 
 Unlike general-purpose 3D engines, Motion GPU focuses on a very narrow problem: **running fullscreen fragment shaders and multi-pass GPU pipelines**.
 
@@ -87,9 +87,9 @@ Motion GPU follows a simple three-step flow:
 
 # Entrypoints
 
-## Root (`@motion-core/motion-gpu`)
+## Svelte adapter
 
-Primary runtime API:
+`@motion-core/motion-gpu/svelte` exposes the runtime API for Svelte:
 
 - `FragCanvas`
 - `defineMaterial`
@@ -110,9 +110,7 @@ Also exports runtime/core types:
 
 ---
 
-## Advanced (`@motion-core/motion-gpu/advanced`)
-
-Re-exports everything from root, plus:
+`@motion-core/motion-gpu/svelte/advanced` re-exports everything above, plus:
 
 - `useMotionGPUUserContext`
 - `setMotionGPUUserContext`
@@ -121,9 +119,31 @@ Re-exports everything from root, plus:
 
 ---
 
+## Framework-agnostic core
+
+`@motion-core/motion-gpu` (and explicit alias `@motion-core/motion-gpu/core`) exposes adapter-building primitives:
+
+- `defineMaterial`
+- `resolveMaterial`
+- `createCurrentWritable`
+- `createFrameRegistry`
+- `createMotionGPURuntimeLoop`
+- `loadTexturesFromUrls`
+- `toMotionGPUErrorReport`
+- `ShaderPass`
+- `BlitPass`
+- `CopyPass`
+
+`@motion-core/motion-gpu/advanced` (and explicit alias `@motion-core/motion-gpu/core/advanced`) re-exports core plus:
+
+- `applySchedulerPreset`
+- `captureSchedulerDebugSnapshot`
+
+---
+
 # Requirements
 
-- Svelte 5 (`peerDependency: svelte ^5`)
+- Svelte 5 is required only for the Svelte adapter entrypoints (`/svelte`, `/svelte/advanced`)
 - A browser/runtime with WebGPU support
 - Secure context (`https://` or `localhost`)
 
@@ -137,6 +157,12 @@ npm i @motion-core/motion-gpu
 
 ---
 
+# AI Documentation
+
+MotionGPU documentation is also available for AI tools via [Context7](https://context7.com/motion-core/motion-gpu).
+
+---
+
 # Quick Start
 
 ## 1. Create a material and render it
@@ -144,7 +170,7 @@ npm i @motion-core/motion-gpu
 ```svelte
 <!-- App.svelte -->
 <script lang="ts">
-	import { FragCanvas, defineMaterial } from '@motion-core/motion-gpu';
+	import { FragCanvas, defineMaterial } from '@motion-core/motion-gpu/svelte';
 
 	const material = defineMaterial({
 		fragment: `
@@ -167,7 +193,7 @@ fn frag(uv: vec2f) -> vec4f {
 ```svelte
 <!-- App.svelte -->
 <script lang="ts">
-	import { FragCanvas, defineMaterial } from '@motion-core/motion-gpu';
+	import { FragCanvas, defineMaterial } from '@motion-core/motion-gpu/svelte';
 	import Runtime from './Runtime.svelte';
 
 	const material = defineMaterial({
@@ -191,7 +217,7 @@ fn frag(uv: vec2f) -> vec4f {
 ```svelte
 <!-- Runtime.svelte -->
 <script lang="ts">
-	import { useFrame } from '@motion-core/motion-gpu';
+	import { useFrame } from '@motion-core/motion-gpu/svelte';
 
 	useFrame((state) => {
 		state.setUniform('uTime', state.time);

package/dist/advanced.d.ts

@@ -1,14 +1,6 @@
 /**
- * Advanced MotionGPU entrypoint.
+ * Root advanced package entrypoint.
  *
- * Includes power-user hooks and diagnostics-oriented types that are not part of the
- * minimal root API surface.
+ * Framework-agnostic advanced core entrypoint.
  */
-export * from './index';
-export { applySchedulerPreset, captureSchedulerDebugSnapshot } from './advanced-scheduler';
-export { setMotionGPUUserContext, useMotionGPUUserContext } from './use-motiongpu-user-context';
-export type { ApplySchedulerPresetOptions, SchedulerDebugSnapshot, SchedulerPreset, SchedulerPresetConfig } from './advanced-scheduler';
-export type { MotionGPUUserContext, MotionGPUUserNamespace } from './motiongpu-context';
-export type { FrameProfilingSnapshot, FrameKey, FrameTaskInvalidation, FrameTaskInvalidationToken, FrameRunTimings, FrameScheduleSnapshot, FrameStage, FrameStageCallback, FrameTimingStats, FrameTask } from './frame-context';
-export type { SetMotionGPUUserContextOptions } from './use-motiongpu-user-context';
-export type { RenderPassContext, RenderTarget, UniformLayout, UniformLayoutEntry } from './core/types';
+export * from './core/advanced.js';

package/dist/advanced.js

@@ -1,9 +1,6 @@
 /**
- * Advanced MotionGPU entrypoint.
+ * Root advanced package entrypoint.
  *
- * Includes power-user hooks and diagnostics-oriented types that are not part of the
- * minimal root API surface.
+ * Framework-agnostic advanced core entrypoint.
  */
-export * from './index';
-export { applySchedulerPreset, captureSchedulerDebugSnapshot } from './advanced-scheduler';
-export { setMotionGPUUserContext, useMotionGPUUserContext } from './use-motiongpu-user-context';
+export * from './core/advanced.js';

package/dist/core/advanced.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Framework-agnostic advanced MotionGPU core entrypoint.
+ */
+export * from './index.js';
+export { applySchedulerPreset, captureSchedulerDebugSnapshot } from './scheduler-helpers.js';
+export type { ApplySchedulerPresetOptions, MotionGPUScheduler, SchedulerDebugSnapshot, SchedulerPreset, SchedulerPresetConfig } from './scheduler-helpers.js';

package/dist/core/advanced.js

@@ -0,0 +1,5 @@
+/**
+ * Framework-agnostic advanced MotionGPU core entrypoint.
+ */
+export * from './index.js';
+export { applySchedulerPreset, captureSchedulerDebugSnapshot } from './scheduler-helpers.js';

package/dist/core/current-value.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal subscribe contract used by MotionGPU core.
+ */
+export interface Subscribable<T> {
+    subscribe: (run: (value: T) => void) => () => void;
+}
+/**
+ * Readable value with synchronous access to the latest value.
+ */
+export interface CurrentReadable<T> extends Subscribable<T> {
+    readonly current: T;
+}
+/**
+ * Writable extension of {@link CurrentReadable}.
+ */
+export interface CurrentWritable<T> extends CurrentReadable<T> {
+    set: (value: T) => void;
+    update: (updater: (value: T) => T) => void;
+}
+/**
+ * Creates a writable value with immediate subscription semantics.
+ */
+export declare function createCurrentWritable<T>(initialValue: T, onChange?: (value: T) => void): CurrentWritable<T>;

package/dist/core/current-value.js

@@ -0,0 +1,36 @@
+/**
+ * Creates a writable value with immediate subscription semantics.
+ */
+export function createCurrentWritable(initialValue, onChange) {
+    let current = initialValue;
+    const subscribers = new Set();
+    const notify = (value) => {
+        for (const run of subscribers) {
+            run(value);
+        }
+    };
+    const set = (value) => {
+        if (Object.is(current, value)) {
+            return;
+        }
+        current = value;
+        notify(value);
+        onChange?.(value);
+    };
+    return {
+        get current() {
+            return current;
+        },
+        subscribe(run) {
+            subscribers.add(run);
+            run(current);
+            return () => {
+                subscribers.delete(run);
+            };
+        },
+        set,
+        update(updater) {
+            set(updater(current));
+        }
+    };
+}

package/dist/core/error-diagnostics.d.ts

@@ -1,4 +1,4 @@
-import type { MaterialSourceLocation } from './material-preprocess';
+import type { MaterialSourceLocation } from './material-preprocess.js';
 /**
  * Source metadata for material declaration callsite.
  */
@@ -19,6 +19,19 @@ export interface ShaderCompilationDiagnostic {
     lineLength?: number;
     sourceLocation: MaterialSourceLocation | null;
 }
+/**
+ * Runtime context snapshot captured for shader compilation diagnostics.
+ */
+export interface ShaderCompilationRuntimeContext {
+    materialSignature?: string;
+    passGraph?: {
+        passCount: number;
+        enabledPassCount: number;
+        inputs: string[];
+        outputs: string[];
+    };
+    activeRenderTargets: string[];
+}
 /**
  * Structured payload attached to WGSL compilation errors.
  */
@@ -29,6 +42,7 @@ export interface ShaderCompilationDiagnosticsPayload {
     includeSources: Record<string, string>;
     defineBlockSource?: string;
     materialSource: MaterialSourceMetadata | null;
+    runtimeContext?: ShaderCompilationRuntimeContext;
 }
 /**
  * Attaches structured diagnostics payload to an Error.

package/dist/core/error-diagnostics.js

@@ -56,6 +56,39 @@ function isShaderCompilationDiagnostic(value) {
     }
     return true;
 }
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+}
+function isShaderCompilationRuntimeContext(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    if (record.materialSignature !== undefined && typeof record.materialSignature !== 'string') {
+        return false;
+    }
+    if (!isStringArray(record.activeRenderTargets)) {
+        return false;
+    }
+    const passGraph = record.passGraph;
+    if (passGraph === undefined) {
+        return true;
+    }
+    if (passGraph === null || typeof passGraph !== 'object') {
+        return false;
+    }
+    const passGraphRecord = passGraph;
+    if (typeof passGraphRecord.passCount !== 'number') {
+        return false;
+    }
+    if (typeof passGraphRecord.enabledPassCount !== 'number') {
+        return false;
+    }
+    if (!isStringArray(passGraphRecord.inputs) || !isStringArray(passGraphRecord.outputs)) {
+        return false;
+    }
+    return true;
+}
 /**
  * Attaches structured diagnostics payload to an Error.
  */
@@ -98,6 +131,10 @@ export function getShaderCompilationDiagnostics(error) {
     if (record.materialSource !== null && !isMaterialSourceMetadata(record.materialSource)) {
         return null;
     }
+    if (record.runtimeContext !== undefined &&
+        !isShaderCompilationRuntimeContext(record.runtimeContext)) {
+        return null;
+    }
     return {
         kind: 'shader-compilation',
         diagnostics: record.diagnostics,
@@ -106,6 +143,9 @@ export function getShaderCompilationDiagnostics(error) {
         ...(record.defineBlockSource !== undefined
             ? { defineBlockSource: record.defineBlockSource }
             : {}),
-        materialSource: (record.materialSource ?? null)
+        materialSource: (record.materialSource ?? null),
+        ...(record.runtimeContext !== undefined
+            ? { runtimeContext: record.runtimeContext }
+            : {})
     };
 }

package/dist/core/error-report.d.ts

@@ -2,6 +2,14 @@
  * Runtime phase in which an error occurred.
  */
 export type MotionGPUErrorPhase = 'initialization' | 'render';
+/**
+ * Stable machine-readable error category code.
+ */
+export type MotionGPUErrorCode = 'WEBGPU_UNAVAILABLE' | 'WEBGPU_ADAPTER_UNAVAILABLE' | 'WEBGPU_CONTEXT_UNAVAILABLE' | 'WGSL_COMPILATION_FAILED' | 'WEBGPU_DEVICE_LOST' | 'WEBGPU_UNCAPTURED_ERROR' | 'BIND_GROUP_MISMATCH' | 'TEXTURE_USAGE_INVALID' | 'TEXTURE_REQUEST_FAILED' | 'TEXTURE_DECODE_UNAVAILABLE' | 'TEXTURE_REQUEST_ABORTED' | 'MOTIONGPU_RUNTIME_ERROR';
+/**
+ * Severity level for user-facing diagnostics.
+ */
+export type MotionGPUErrorSeverity = 'error' | 'fatal';
 /**
  * One source-code line displayed in diagnostics snippet.
  */
@@ -20,10 +28,35 @@ export interface MotionGPUErrorSource {
     column?: number;
     snippet: MotionGPUErrorSourceLine[];
 }
+/**
+ * Optional runtime context captured with diagnostics payload.
+ */
+export interface MotionGPUErrorContext {
+    materialSignature?: string;
+    passGraph?: {
+        passCount: number;
+        enabledPassCount: number;
+        inputs: string[];
+        outputs: string[];
+    };
+    activeRenderTargets: string[];
+}
 /**
  * Structured error payload used by UI diagnostics.
  */
 export interface MotionGPUErrorReport {
+    /**
+     * Stable machine-readable category code.
+     */
+    code: MotionGPUErrorCode;
+    /**
+     * Severity level used by diagnostics UIs and telemetry.
+     */
+    severity: MotionGPUErrorSeverity;
+    /**
+     * Whether runtime may recover without full renderer re-creation.
+     */
+    recoverable: boolean;
     /**
      * Short category title.
      */
@@ -56,6 +89,10 @@ export interface MotionGPUErrorReport {
      * Optional source context for shader-related diagnostics.
      */
     source: MotionGPUErrorSource | null;
+    /**
+     * Optional runtime context snapshot (material/pass graph/render targets).
+     */
+    context: MotionGPUErrorContext | null;
 }
 /**
  * Converts unknown errors to a consistent, display-ready error report.

package/dist/core/error-report.js

@@ -1,5 +1,5 @@
-import { getShaderCompilationDiagnostics } from './error-diagnostics';
-import { formatShaderSourceLocation } from './shader';
+import { getShaderCompilationDiagnostics } from './error-diagnostics.js';
+import { formatShaderSourceLocation } from './shader.js';
 /**
  * Splits multi-line values into trimmed non-empty lines.
  */
@@ -98,53 +98,107 @@ function formatDiagnosticMessage(entry) {
 function classifyErrorMessage(message) {
     if (message.includes('WebGPU is not available in this browser')) {
         return {
+            code: 'WEBGPU_UNAVAILABLE',
+            severity: 'fatal',
+            recoverable: false,
             title: 'WebGPU unavailable',
             hint: 'Use a browser with WebGPU enabled (latest Chrome/Edge/Safari TP) and secure context.'
         };
     }
     if (message.includes('Unable to acquire WebGPU adapter')) {
         return {
+            code: 'WEBGPU_ADAPTER_UNAVAILABLE',
+            severity: 'fatal',
+            recoverable: false,
             title: 'WebGPU adapter unavailable',
             hint: 'GPU adapter request failed. Check browser permissions, flags and device support.'
         };
     }
     if (message.includes('Canvas does not support webgpu context')) {
         return {
+            code: 'WEBGPU_CONTEXT_UNAVAILABLE',
+            severity: 'error',
+            recoverable: true,
             title: 'Canvas cannot create WebGPU context',
             hint: 'Make sure this canvas is attached to DOM and not using an unsupported context option.'
         };
     }
     if (message.includes('WGSL compilation failed')) {
         return {
+            code: 'WGSL_COMPILATION_FAILED',
+            severity: 'error',
+            recoverable: true,
             title: 'WGSL compilation failed',
             hint: 'Check WGSL line numbers below and verify struct/binding/function signatures.'
         };
     }
     if (message.includes('WebGPU device lost') || message.includes('Device Lost')) {
         return {
+            code: 'WEBGPU_DEVICE_LOST',
+            severity: 'fatal',
+            recoverable: false,
             title: 'WebGPU device lost',
             hint: 'GPU device/context was lost. Recreate the renderer and check OS/GPU stability.'
         };
     }
     if (message.includes('WebGPU uncaptured error')) {
         return {
+            code: 'WEBGPU_UNCAPTURED_ERROR',
+            severity: 'error',
+            recoverable: true,
             title: 'WebGPU uncaptured error',
             hint: 'A GPU command failed asynchronously. Review details and validate resource/state usage.'
         };
     }
     if (message.includes('CreateBindGroup') || message.includes('bind group layout')) {
         return {
+            code: 'BIND_GROUP_MISMATCH',
+            severity: 'error',
+            recoverable: true,
             title: 'Bind group mismatch',
             hint: 'Bindings in shader and runtime resources are out of sync. Verify uniforms/textures layout.'
         };
     }
     if (message.includes('Destination texture needs to have CopyDst')) {
         return {
+            code: 'TEXTURE_USAGE_INVALID',
+            severity: 'error',
+            recoverable: true,
             title: 'Invalid texture usage flags',
             hint: 'Texture used as upload destination must include CopyDst (and often RenderAttachment).'
         };
     }
+    if (message.includes('Texture request failed')) {
+        return {
+            code: 'TEXTURE_REQUEST_FAILED',
+            severity: 'error',
+            recoverable: true,
+            title: 'Texture request failed',
+            hint: 'Verify texture URL, CORS policy and response status before retrying.'
+        };
+    }
+    if (message.includes('createImageBitmap is not available in this runtime')) {
+        return {
+            code: 'TEXTURE_DECODE_UNAVAILABLE',
+            severity: 'fatal',
+            recoverable: false,
+            title: 'Texture decode unavailable',
+            hint: 'Runtime lacks createImageBitmap support. Use a browser/runtime with image bitmap decoding.'
+        };
+    }
+    if (message.toLowerCase().includes('texture request was aborted')) {
+        return {
+            code: 'TEXTURE_REQUEST_ABORTED',
+            severity: 'error',
+            recoverable: true,
+            title: 'Texture request aborted',
+            hint: 'Texture load was cancelled. Retry the request when source inputs stabilize.'
+        };
+    }
     return {
+        code: 'MOTIONGPU_RUNTIME_ERROR',
+        severity: 'error',
+        recoverable: true,
         title: 'MotionGPU render error',
         hint: 'Review technical details below. If issue persists, isolate shader/uniform/texture changes.'
     };
@@ -167,6 +221,7 @@ export function toMotionGPUErrorReport(error, phase) {
     const defaultMessage = rawLines[0] ?? rawMessage;
     const defaultDetails = rawLines.slice(1);
     const source = buildSourceFromDiagnostics(error);
+    const context = shaderDiagnostics?.runtimeContext ?? null;
     const message = shaderDiagnostics && shaderDiagnostics.diagnostics[0]
         ? formatDiagnosticMessage(shaderDiagnostics.diagnostics[0])
         : defaultMessage;
@@ -178,6 +233,9 @@ export function toMotionGPUErrorReport(error, phase) {
         : [];
     const classification = classifyErrorMessage(rawMessage);
     return {
+        code: classification.code,
+        severity: classification.severity,
+        recoverable: classification.recoverable,
         title: classification.title,
         message,
         hint: classification.hint,
@@ -185,6 +243,7 @@ export function toMotionGPUErrorReport(error, phase) {
         stack,
         rawMessage,
         phase,
-        source
+        source,
+        context
     };
 }

package/dist/{frame-context.d.ts → core/frame-registry.d.ts}

@@ -1,5 +1,5 @@
-import { type Readable } from 'svelte/store';
-import type { FrameInvalidationToken, FrameState, RenderMode } from './core/types';
+import { type Subscribable } from './current-value.js';
+import type { FrameInvalidationToken, FrameState, RenderMode } from './types.js';
 /**
  * Per-frame callback executed by the frame scheduler.
  */
@@ -97,7 +97,7 @@ export interface UseFrameResult {
     /**
      * Readable flag representing effective running state.
      */
-    started: Readable<boolean>;
+    started: Subscribable<boolean>;
 }
 /**
  * Snapshot of the resolved stage/task execution order.
@@ -270,18 +270,4 @@ export declare function createFrameRegistry(options?: {
     profilingWindow?: number;
     diagnosticsEnabled?: boolean;
 }): FrameRegistry;
-/**
- * Provides a frame registry through Svelte context.
- *
- * @param registry - Registry to provide.
- */
-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;
 export {};

package/dist/{frame-context.js → core/frame-registry.js}

@@ -1,9 +1,4 @@
-import { getContext, onDestroy, setContext } from 'svelte';
-import { writable } from 'svelte/store';
-/**
- * Svelte context key for the active frame registry.
- */
-const FRAME_CONTEXT_KEY = Symbol('motiongpu.frame-context');
+import { createCurrentWritable } from './current-value.js';
 /**
  * Default stage key used when task stage is not explicitly specified.
  */
@@ -492,7 +487,7 @@ export function createFrameRegistry(options) {
                 ? toStageKey(taskOptions.stage)
                 : (inferredStage?.stage ?? MAIN_STAGE_KEY);
             const stage = ensureStage(stageKey);
-            const startedWritable = writable(taskOptions.autoStart ?? true);
+            const startedWritable = createCurrentWritable(taskOptions.autoStart ?? true);
             const internalTask = {
                 task: { key, stage: stage.key },
                 callback,
@@ -699,33 +694,3 @@ export function createFrameRegistry(options) {
         }
     };
 }
-/**
- * Provides a frame registry through Svelte context.
- *
- * @param registry - Registry to provide.
- */
-export function provideFrameRegistry(registry) {
-    setContext(FRAME_CONTEXT_KEY, registry);
-}
-/**
- * Registers a callback in the active frame registry and auto-unsubscribes on destroy.
- *
- * @returns Frame task handle for start/stop control.
- * @throws {Error} When used outside `<FragCanvas>`.
- */
-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/core/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Framework-agnostic MotionGPU core entrypoint.
+ *
+ * This surface is intended for building framework adapters (Svelte/React/Vue).
+ */
+export { defineMaterial, resolveMaterial } from './material.js';
+export { toMotionGPUErrorReport } from './error-report.js';
+export { createCurrentWritable } from './current-value.js';
+export { createFrameRegistry } from './frame-registry.js';
+export { createMotionGPURuntimeLoop } from './runtime-loop.js';
+export { loadTexturesFromUrls } from './texture-loader.js';
+export { BlitPass, CopyPass, ShaderPass } from '../passes/index.js';
+export type { CurrentReadable, CurrentWritable, Subscribable } from './current-value.js';
+export type { MotionGPUErrorCode, MotionGPUErrorContext, MotionGPUErrorPhase, MotionGPUErrorReport, MotionGPUErrorSeverity, MotionGPUErrorSource, MotionGPUErrorSourceLine } from './error-report.js';
+export type { FrameCallback, FrameKey, FrameProfilingSnapshot, FrameRegistry, FrameRunTimings, FrameScheduleSnapshot, FrameStage, FrameStageCallback, FrameTask, FrameTaskInvalidation, FrameTaskInvalidationToken, FrameTimingStats, UseFrameOptions, UseFrameResult } from './frame-registry.js';
+export type { FragMaterial, FragMaterialInput, MaterialDefineValue, MaterialDefines, MaterialIncludes, ResolvedMaterial, TypedMaterialDefineValue } from './material.js';
+export type { MotionGPURuntimeLoop, MotionGPURuntimeLoopOptions } from './runtime-loop.js';
+export type { LoadedTexture, TextureDecodeOptions, TextureLoadOptions } from './texture-loader.js';
+export type { FrameInvalidationToken, FrameState, OutputColorSpace, RenderPass, RenderPassContext, RenderPassFlags, RenderPassInputSlot, RenderPassOutputSlot, RenderMode, RenderTarget, RenderTargetDefinition, RenderTargetDefinitionMap, TextureData, TextureDefinition, TextureDefinitionMap, TextureMap, TextureSource, TextureUpdateMode, TextureValue, TypedUniform, UniformLayout, UniformLayoutEntry, UniformMap, UniformMat4Value, UniformType, UniformValue } from './types.js';

package/dist/core/index.js

@@ -0,0 +1,12 @@
+/**
+ * Framework-agnostic MotionGPU core entrypoint.
+ *
+ * This surface is intended for building framework adapters (Svelte/React/Vue).
+ */
+export { defineMaterial, resolveMaterial } from './material.js';
+export { toMotionGPUErrorReport } from './error-report.js';
+export { createCurrentWritable } from './current-value.js';
+export { createFrameRegistry } from './frame-registry.js';
+export { createMotionGPURuntimeLoop } from './runtime-loop.js';
+export { loadTexturesFromUrls } from './texture-loader.js';
+export { BlitPass, CopyPass, ShaderPass } from '../passes/index.js';

package/dist/core/material-preprocess.d.ts

@@ -1,4 +1,4 @@
-import type { MaterialDefineValue, MaterialDefines, MaterialIncludes } from './material';
+import type { MaterialDefineValue, MaterialDefines, MaterialIncludes } from './material.js';
 /**
  * Source location metadata for one generated fragment line.
  */

package/dist/core/material-preprocess.js

@@ -1,4 +1,4 @@
-import { assertUniformName } from './uniforms';
+import { assertUniformName } from './uniforms.js';
 const INCLUDE_DIRECTIVE_PATTERN = /^\s*#include\s+<([A-Za-z_][A-Za-z0-9_]*)>\s*$/;
 function normalizeTypedDefine(name, define) {
     const value = define.value;

package/dist/core/material.d.ts

@@ -1,7 +1,7 @@
-import type { MaterialSourceMetadata } from './error-diagnostics';
-import { resolveUniformLayout } from './uniforms';
-import { type MaterialLineMap } from './material-preprocess';
-import type { TextureDefinitionMap, UniformMap } from './types';
+import type { MaterialSourceMetadata } from './error-diagnostics.js';
+import { resolveUniformLayout } from './uniforms.js';
+import { type MaterialLineMap } from './material-preprocess.js';
+import type { TextureDefinitionMap, UniformMap } from './types.js';
 /**
  * Typed compile-time define declaration.
  */