@motion-core/motion-gpu 0.1.0

package/dist/use-motiongpu-user-context.js

@@ -0,0 +1,74 @@
+import { useMotionGPU } from './motiongpu-context';
+/**
+ * Checks whether a value is a non-array object suitable for shallow merge.
+ */
+function isObjectEntry(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Read-only user context hook:
+ * - no args: returns full user context store
+ * - namespace: returns namespaced store view
+ *
+ * @param namespace - Optional namespace key.
+ */
+export function useMotionGPUUserContext(namespace) {
+    const userStore = useMotionGPU().user;
+    if (namespace === undefined) {
+        const allStore = {
+            get current() {
+                return userStore.current;
+            },
+            subscribe(run) {
+                return userStore.subscribe((context) => run(context));
+            }
+        };
+        return allStore;
+    }
+    const scopedStore = {
+        get current() {
+            return userStore.current[namespace];
+        },
+        subscribe(run) {
+            return userStore.subscribe((context) => run(context[namespace]));
+        }
+    };
+    return scopedStore;
+}
+/**
+ * Sets a namespaced user context value with explicit write semantics.
+ *
+ * Returns the effective value stored under the namespace.
+ */
+export function setMotionGPUUserContext(namespace, value, options) {
+    const userStore = useMotionGPU().user;
+    const mode = options?.existing ?? 'skip';
+    let resolvedValue;
+    userStore.update((context) => {
+        const hasExisting = namespace in context;
+        if (hasExisting && mode === 'skip') {
+            resolvedValue = context[namespace];
+            return context;
+        }
+        const nextValue = typeof value === 'function' ? value() : value;
+        if (hasExisting && mode === 'merge') {
+            const currentValue = context[namespace];
+            if (isObjectEntry(currentValue) && isObjectEntry(nextValue)) {
+                resolvedValue = {
+                    ...currentValue,
+                    ...nextValue
+                };
+                return {
+                    ...context,
+                    [namespace]: resolvedValue
+                };
+            }
+        }
+        resolvedValue = nextValue;
+        return {
+            ...context,
+            [namespace]: nextValue
+        };
+    });
+    return resolvedValue;
+}

package/dist/use-texture.d.ts

@@ -0,0 +1,35 @@
+import type { CurrentReadable } from './current-writable';
+import { type LoadedTexture, type TextureLoadOptions } from './core/texture-loader';
+/**
+ * Reactive state returned by {@link useTexture}.
+ */
+export interface UseTextureResult {
+    /**
+     * Loaded textures or `null` when unavailable/failed.
+     */
+    textures: CurrentReadable<LoadedTexture[] | null>;
+    /**
+     * `true` while an active load request is running.
+     */
+    loading: CurrentReadable<boolean>;
+    /**
+     * Last loading error.
+     */
+    error: CurrentReadable<Error | null>;
+    /**
+     * Reloads all textures using current URL input.
+     */
+    reload: () => Promise<void>;
+}
+/**
+ * Supported URL input variants for `useTexture`.
+ */
+export type TextureUrlInput = string[] | (() => string[]);
+/**
+ * Loads textures from URLs and exposes reactive loading/error state.
+ *
+ * @param urlInput - URLs array or lazy URL provider.
+ * @param options - Loader options passed to URL fetch/decode pipeline.
+ * @returns Reactive texture loading state with reload support.
+ */
+export declare function useTexture(urlInput: TextureUrlInput, options?: TextureLoadOptions): UseTextureResult;

package/dist/use-texture.js

@@ -0,0 +1,147 @@
+import { onDestroy } from 'svelte';
+import { currentWritable } from './current-writable';
+import { isAbortError, loadTexturesFromUrls } from './core/texture-loader';
+/**
+ * Normalizes unknown thrown values to an `Error` instance.
+ */
+function toError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error('Unknown texture loading error');
+}
+/**
+ * Releases GPU-side resources for a list of loaded textures.
+ */
+function disposeTextures(list) {
+    for (const texture of list ?? []) {
+        texture.dispose();
+    }
+}
+function mergeAbortSignals(primary, secondary) {
+    if (!secondary) {
+        return {
+            signal: primary,
+            dispose: () => { }
+        };
+    }
+    if (typeof AbortSignal.any === 'function') {
+        return {
+            signal: AbortSignal.any([primary, secondary]),
+            dispose: () => { }
+        };
+    }
+    const fallback = new AbortController();
+    let disposed = false;
+    const cleanup = () => {
+        if (disposed) {
+            return;
+        }
+        disposed = true;
+        primary.removeEventListener('abort', abort);
+        secondary.removeEventListener('abort', abort);
+    };
+    const abort = () => fallback.abort();
+    primary.addEventListener('abort', abort, { once: true });
+    secondary.addEventListener('abort', abort, { once: true });
+    return {
+        signal: fallback.signal,
+        dispose: cleanup
+    };
+}
+/**
+ * Loads textures from URLs and exposes reactive loading/error state.
+ *
+ * @param urlInput - URLs array or lazy URL provider.
+ * @param options - Loader options passed to URL fetch/decode pipeline.
+ * @returns Reactive texture loading state with reload support.
+ */
+export function useTexture(urlInput, options = {}) {
+    const textures = currentWritable(null);
+    const loading = currentWritable(true);
+    const error = currentWritable(null);
+    let disposed = false;
+    let requestVersion = 0;
+    let activeController = null;
+    let runningLoad = null;
+    let reloadQueued = false;
+    const getUrls = typeof urlInput === 'function' ? urlInput : () => urlInput;
+    const executeLoad = async () => {
+        if (disposed) {
+            return;
+        }
+        const version = ++requestVersion;
+        const controller = new AbortController();
+        activeController = controller;
+        loading.set(true);
+        error.set(null);
+        const previous = textures.current;
+        const mergedSignal = mergeAbortSignals(controller.signal, options.signal);
+        try {
+            const loaded = await loadTexturesFromUrls(getUrls(), {
+                ...options,
+                signal: mergedSignal.signal
+            });
+            if (disposed || version !== requestVersion) {
+                disposeTextures(loaded);
+                return;
+            }
+            textures.set(loaded);
+            disposeTextures(previous);
+        }
+        catch (nextError) {
+            if (disposed || version !== requestVersion) {
+                return;
+            }
+            if (isAbortError(nextError)) {
+                return;
+            }
+            disposeTextures(previous);
+            textures.set(null);
+            error.set(toError(nextError));
+        }
+        finally {
+            if (!disposed && version === requestVersion) {
+                loading.set(false);
+            }
+            if (activeController === controller) {
+                activeController = null;
+            }
+            mergedSignal.dispose();
+        }
+    };
+    const runLoadLoop = async () => {
+        do {
+            reloadQueued = false;
+            await executeLoad();
+        } while (reloadQueued && !disposed);
+    };
+    const load = () => {
+        activeController?.abort();
+        if (runningLoad) {
+            reloadQueued = true;
+            return runningLoad;
+        }
+        const pending = runLoadLoop();
+        const trackedPending = pending.finally(() => {
+            if (runningLoad === trackedPending) {
+                runningLoad = null;
+            }
+        });
+        runningLoad = trackedPending;
+        return trackedPending;
+    };
+    void load();
+    onDestroy(() => {
+        disposed = true;
+        requestVersion += 1;
+        activeController?.abort();
+        disposeTextures(textures.current);
+    });
+    return {
+        textures,
+        loading,
+        error,
+        reload: load
+    };
+}

package/package.json

@@ -0,0 +1,94 @@
+{
+	"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.",
+	"keywords": [
+		"svelte",
+		"svelte5",
+		"webgpu",
+		"wgsl",
+		"shader",
+		"graphics",
+		"gpu",
+		"postprocessing"
+	],
+	"homepage": "https://github.com/Motion-Core/motion-gpu/tree/master/packages/motion-gpu#readme",
+	"bugs": {
+		"url": "https://github.com/Motion-Core/motion-gpu/issues"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Motion-Core/motion-gpu.git",
+		"directory": "packages/motion-gpu"
+	},
+	"license": "MIT",
+	"publishConfig": {
+		"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"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "svelte-package -i src/lib -o dist",
+		"prepack": "bun run build",
+		"check": "svelte-check --tsconfig ./tsconfig.json && publint",
+		"test": "vitest run",
+		"test:coverage": "vitest run --coverage",
+		"test:watch": "vitest",
+		"test:e2e": "playwright test",
+		"test:e2e:headed": "playwright test --headed",
+		"e2e:serve": "vite --config e2e/vite.config.ts",
+		"perf:core": "bun run ./scripts/perf/core-benchmark.ts",
+		"perf:core:check": "bun run ./scripts/perf/core-benchmark.ts --strict",
+		"perf:core:baseline": "bun run ./scripts/perf/core-benchmark.ts --update-baseline",
+		"perf:runtime": "bun run ./scripts/perf/runtime-benchmark.ts",
+		"perf:runtime:check": "bun run ./scripts/perf/runtime-benchmark.ts --strict",
+		"perf:runtime:baseline": "bun run ./scripts/perf/runtime-benchmark.ts --update-baseline",
+		"lint": "prettier --check . && eslint .",
+		"format": "prettier --write ."
+	},
+	"peerDependencies": {
+		"svelte": "^5.0.0"
+	},
+	"devDependencies": {
+		"@eslint/compat": "^2.0.2",
+		"@eslint/js": "^10.0.1",
+		"@playwright/test": "^1.58.2",
+		"@sveltejs/package": "^2.5.0",
+		"@sveltejs/vite-plugin-svelte": "^6.2.4",
+		"@testing-library/svelte": "^5.2.8",
+		"@vitest/coverage-v8": "^4.0.18",
+		"@types/node": "^25.3.3",
+		"@webgpu/types": "^0.1.66",
+		"eslint": "^10.0.2",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-svelte": "^3.14.0",
+		"globals": "^17.3.0",
+		"happy-dom": "^20.0.10",
+		"prettier": "^3.8.1",
+		"prettier-plugin-svelte": "^3.4.1",
+		"prettier-plugin-tailwindcss": "^0.7.2",
+		"publint": "^0.3.15",
+		"svelte": "^5.51.0",
+		"svelte-check": "^4.3.6",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.54.0",
+		"vite": "^7.3.1",
+		"vitest": "^4.0.18"
+	}
+}