af-motion 0.0.0-stage → 1.0.0

package/dist/graphics/schema.d.ts

@@ -0,0 +1,177 @@
+export declare const GRAPHICS_SCHEMA_VERSION = "1.0.0";
+export declare const RENDERER_OPTIONS_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly backend: {
+            readonly type: "string";
+            readonly enum: readonly ["canvas2d", "webgl", "webgl2", "webgpu", "null", "auto"];
+            readonly default: "auto";
+            readonly description: "Rendering backend to use, or auto to choose best available.";
+        };
+        readonly alpha: {
+            readonly type: "boolean";
+            readonly default: true;
+            readonly description: "Whether the canvas context supports transparency.";
+        };
+        readonly antialias: {
+            readonly type: "boolean";
+            readonly default: true;
+            readonly description: "Whether to enable hardware antialiasing where supported.";
+        };
+        readonly powerPreference: {
+            readonly type: "string";
+            readonly enum: readonly ["default", "high-performance", "low-power"];
+            readonly default: "default";
+            readonly description: "GPU power preference for dual-GPU systems.";
+        };
+        readonly preserveDrawingBuffer: {
+            readonly type: "boolean";
+            readonly default: false;
+            readonly description: "Whether buffers are preserved after rendering.";
+        };
+        readonly dpr: {
+            readonly type: "number";
+            readonly minimum: 0.5;
+            readonly maximum: 4;
+            readonly description: "Device pixel ratio multiplier.";
+        };
+        readonly fallbackBackend: {
+            readonly type: "string";
+            readonly enum: readonly ["canvas2d", "null"];
+            readonly default: "canvas2d";
+            readonly description: "Fallback backend if preferred backend fails.";
+        };
+    };
+    readonly additionalProperties: false;
+};
+export declare const GRAPHICS_ENGINE_OPTIONS_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly renderer: {
+            readonly type: "object";
+            readonly description: "Custom renderer instance or renderer configuration options.";
+        };
+        readonly dpr: {
+            readonly type: readonly ["number", "string"];
+            readonly description: "Device pixel ratio ('auto' or numeric multiplier).";
+        };
+        readonly autoStart: {
+            readonly type: "boolean";
+            readonly default: true;
+            readonly description: "Automatically begin animation loop on canvas attach.";
+        };
+        readonly pauseOnHidden: {
+            readonly type: "boolean";
+            readonly default: true;
+            readonly description: "Automatically suspend rendering loop when browser tab is hidden.";
+        };
+        readonly respectReducedMotion: {
+            readonly type: "boolean";
+            readonly default: true;
+            readonly description: "Honor prefers-reduced-motion OS preferences.";
+        };
+        readonly fpsLimit: {
+            readonly type: "number";
+            readonly minimum: 1;
+            readonly maximum: 240;
+            readonly description: "Optional maximum frame rate limiter.";
+        };
+    };
+    readonly additionalProperties: false;
+};
+export declare const GRAPHICS_CAPABILITIES_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly supportedBackends: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "List of detected rendering backends available on this device.";
+        };
+        readonly activeBackend: {
+            readonly type: "string";
+            readonly description: "Currently active rendering backend.";
+        };
+        readonly canvas: {
+            readonly type: "boolean";
+        };
+        readonly webgl: {
+            readonly type: "boolean";
+        };
+        readonly webgl2: {
+            readonly type: "boolean";
+        };
+        readonly webgpu: {
+            readonly type: "boolean";
+        };
+        readonly maxTextureSize: {
+            readonly type: "number";
+        };
+        readonly dpr: {
+            readonly type: "number";
+        };
+        readonly reducedMotion: {
+            readonly type: "boolean";
+        };
+        readonly colorSpace: {
+            readonly type: "string";
+        };
+        readonly antialias: {
+            readonly type: "boolean";
+        };
+        readonly floatTextures: {
+            readonly type: "boolean";
+        };
+        readonly instancedArrays: {
+            readonly type: "boolean";
+        };
+    };
+    readonly required: readonly ["supportedBackends", "activeBackend", "canvas", "webgl", "maxTextureSize", "dpr"];
+};
+export interface ValidationReport {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+}
+export declare function validateRendererOptions(input: unknown): ValidationReport;
+export declare function validateGraphicsEngineOptions(input: unknown): ValidationReport;
+export declare function validateGraphicsEffect(input: unknown): ValidationReport;
+export declare function validateGraphicsEffectConfig(input: unknown): ValidationReport;
+export declare const GRAPHICS_RENDERING_CAPABILITY: {
+    id: string;
+    name: string;
+    category: "graphics";
+    description: string;
+    tags: string[];
+    version: string;
+    parameters: {
+        name: string;
+        kind: "option";
+        type: string;
+        required: boolean;
+        description: string;
+    }[];
+    supportedTargets: string[];
+    signature: {
+        importStatement: string;
+        invocation: string;
+        exampleCode: string;
+    };
+    controls: string[];
+    callbacks: string[];
+    reducedMotion: "static-fallback";
+    compatibility: {
+        browser: boolean;
+        ssr: boolean;
+        requiresCanvas: boolean;
+    };
+    react: {
+        available: boolean;
+        componentName: string;
+        hookName: string;
+        importPath: string;
+    };
+};
+export declare function registerGraphicsCapability(registry: {
+    registerCapability: (cap: any, opts?: any) => void;
+}): void;

package/dist/graphics/simulation/adapters.d.ts

@@ -0,0 +1,36 @@
+/**
+ * AF Motion Simulation Subsystem Adapters
+ *
+ * Bridges individual simulation engines (Particles, Fluid, Environment,
+ * Interactive Forces, GPU Compute) into the unified SimulationParticipant protocol.
+ */
+import type { ParticleSystem } from "../particles/types.js";
+import type { FluidSimulation } from "../fluid/types.js";
+import type { EnvironmentSimulation } from "../environment/types.js";
+import type { InteractiveParticleSystem } from "../particle-fields/system.js";
+import type { SimulationEngine } from "../gpu-simulation/types.js";
+import type { SimulationParticipant } from "./types.js";
+export interface ParticipantAdapterOptions {
+    priority?: number;
+    autoRender?: boolean;
+}
+/**
+ * Adapt a ParticleSystem instance into a unified SimulationParticipant.
+ */
+export declare function createParticleParticipant(id: string, system: ParticleSystem, options?: ParticipantAdapterOptions): SimulationParticipant;
+/**
+ * Adapt a FluidSimulation instance into a unified SimulationParticipant.
+ */
+export declare function createFluidParticipant(id: string, fluid: FluidSimulation, options?: ParticipantAdapterOptions): SimulationParticipant;
+/**
+ * Adapt an EnvironmentSimulation instance into a unified SimulationParticipant.
+ */
+export declare function createEnvironmentParticipant(id: string, env: EnvironmentSimulation, options?: ParticipantAdapterOptions): SimulationParticipant;
+/**
+ * Adapt an InteractiveParticleSystem instance into a unified SimulationParticipant.
+ */
+export declare function createInteractiveParticleParticipant(id: string, system: InteractiveParticleSystem, options?: ParticipantAdapterOptions): SimulationParticipant;
+/**
+ * Adapt a GPU SimulationEngine instance into a unified SimulationParticipant.
+ */
+export declare function createGPUSimulationParticipant(id: string, engine: SimulationEngine, options?: ParticipantAdapterOptions): SimulationParticipant;

package/dist/graphics/simulation/coordinator.d.ts

@@ -0,0 +1,64 @@
+/**
+ * AF Motion Unified Simulation Lifecycle Coordinator
+ *
+ * Framework-independent master orchestration layer coordinating GPU compute,
+ * particles, fluid dynamics, environmental effects, and interactive force fields
+ * with shared timestepping, visibility-aware pausing, and deterministic execution.
+ */
+import type { SimulationCoordinator, SimulationCoordinatorConfig, SimulationCoordinatorMetrics, SimulationCoordinatorState, SimulationParticipant, SimulationQuality } from "./types.js";
+export declare class UnifiedSimulationCoordinator implements SimulationCoordinator {
+    private participants;
+    private sortedParticipants;
+    private state;
+    private canvas;
+    private qualityController;
+    private resourceManager;
+    private mode;
+    private fixedDelta;
+    private maxDelta;
+    private substeps;
+    private timeScale;
+    private totalSimulationTime;
+    private frameCount;
+    private lastFrameTimestamp;
+    private timeAccumulator;
+    private lastFpsUpdateTime;
+    private framesThisSecond;
+    private currentFps;
+    private lastFrameDurationMs;
+    private lastStepDurationMs;
+    private lastRenderDurationMs;
+    private isReducedMotion;
+    private unsubscribeScheduler;
+    private unbindContextLoss;
+    private config;
+    constructor(config?: SimulationCoordinatorConfig);
+    private checkReducedMotion;
+    private setupContextLoss;
+    register(participant: SimulationParticipant): () => void;
+    unregister(id: string): void;
+    getParticipant(id: string): SimulationParticipant | undefined;
+    listParticipants(): readonly SimulationParticipant[];
+    private rebuildSortedList;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    private onAnimationFrame;
+    step(explicitDt?: number): void;
+    private executeStep;
+    render(): void;
+    setQuality(quality: SimulationQuality): void;
+    getQuality(): SimulationQuality;
+    getState(): SimulationCoordinatorState;
+    getMetrics(): SimulationCoordinatorMetrics;
+    setCanvas(canvas: HTMLCanvasElement | null): void;
+    getCanvas(): HTMLCanvasElement | null;
+    handleContextLost(): void;
+    handleContextRestored(): void;
+    dispose(): void;
+}
+/**
+ * Factory creating a UnifiedSimulationCoordinator.
+ */
+export declare function createSimulationCoordinator(config?: SimulationCoordinatorConfig): SimulationCoordinator;

package/dist/graphics/simulation/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Simulation Optimization & Unified Lifecycle
+ *
+ * Framework-independent master orchestration layer coordinating GPU compute,
+ * particles, fluid dynamics, environmental effects, and interactive force fields.
+ */
+export * from "./types.js";
+export * from "./resource-manager.js";
+export * from "./optimizer.js";
+export * from "./coordinator.js";
+export * from "./adapters.js";

package/dist/graphics/simulation/optimizer.d.ts

@@ -0,0 +1,101 @@
+/**
+ * AF Motion Simulation Performance Optimizer & Benchmarking
+ *
+ * Buffer pooling, adaptive quality management, and benchmarks
+ * across particle, fluid, spatial field, and multi-system workloads.
+ */
+import type { SimulationQuality } from "./types.js";
+/**
+ * High-performance TypedArray recycler to eliminate garbage collection
+ * overhead during continuous simulation calculations.
+ */
+export declare class TypedArrayPool {
+    private floatPool;
+    private uintPool;
+    private maxPooledPerSize;
+    /**
+     * Acquire a Float32Array of at least the requested length.
+     */
+    acquireFloat32(length: number): Float32Array;
+    /**
+     * Return a Float32Array back to the pool for reuse.
+     */
+    releaseFloat32(arr: Float32Array): void;
+    /**
+     * Acquire a Uint32Array of at least the requested length.
+     */
+    acquireUint32(length: number): Uint32Array;
+    /**
+     * Return a Uint32Array back to the pool for reuse.
+     */
+    releaseUint32(arr: Uint32Array): void;
+    /**
+     * Clear all pooled buffers to free memory.
+     */
+    clear(): void;
+}
+/**
+ * Global shared buffer pool instance.
+ */
+export declare const sharedBufferPool: TypedArrayPool;
+/**
+ * Adaptive quality controller that monitors frame times and adjusts quality levels.
+ */
+export declare class AdaptiveQualityController {
+    private currentQuality;
+    private frameTimes;
+    private maxSamples;
+    private lastAdjustmentTime;
+    private cooldownMs;
+    constructor(initialQuality?: SimulationQuality);
+    get quality(): SimulationQuality;
+    recordFrame(frameDurationMs: number): SimulationQuality;
+    setQuality(quality: SimulationQuality): void;
+}
+export interface ParticleBenchmarkResult {
+    particleCount: number;
+    steps: number;
+    durationMs: number;
+    avgStepMs: number;
+    particlesPerSec: number;
+}
+export interface FluidBenchmarkResult {
+    gridResolution: number;
+    cellCount: number;
+    steps: number;
+    durationMs: number;
+    avgStepMs: number;
+    cellsPerSec: number;
+}
+export interface SpatialBenchmarkResult {
+    particleCount: number;
+    forceFieldCount: number;
+    steps: number;
+    durationMs: number;
+    avgStepMs: number;
+    queriesPerSec: number;
+}
+export interface MultiSimBenchmarkResult {
+    particleCount: number;
+    fluidResolution: number;
+    steps: number;
+    durationMs: number;
+    avgStepMs: number;
+    fps: number;
+}
+/**
+ * Benchmark particle buffer layout simulation at various particle counts.
+ */
+export declare function benchmarkParticleSimulation(particleCount: number, steps?: number): ParticleBenchmarkResult;
+/**
+ * Benchmark Eulerian fluid grid simulation at given grid resolution.
+ */
+export declare function benchmarkFluidSimulation(gridResolution: number, steps?: number): FluidBenchmarkResult;
+/**
+ * Benchmark spatial hash grid queries for particles under localized force fields.
+ */
+export declare function benchmarkSpatialQueries(particleCount: number, forceFieldCount: number, steps?: number): SpatialBenchmarkResult;
+/**
+ * Benchmark multiple simultaneous simulations (particles + fluid dynamics).
+ */
+export declare function benchmarkMultiSimulation(particleCount: number, fluidResolution: number, steps?: number): MultiSimBenchmarkResult;

package/dist/graphics/simulation/resource-manager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * AF Motion Simulation GPU Resource Management & Recovery
+ *
+ * Hardened resource ownership, WebGL context-loss/restoration handling,
+ * and leak-free resource pooling for simulation subsystems.
+ */
+export interface ContextLossHandlers {
+    onLost: (event: Event) => void;
+    onRestored: (event: Event) => void;
+}
+/**
+ * Attaches WebGL/WebGPU context-loss and context-restored listeners to a canvas.
+ * Returns an unbind function that safely removes the listeners.
+ */
+export declare function setupCanvasContextLossRecovery(canvas: HTMLCanvasElement | null, onLost: (event: Event) => void, onRestored: (event: Event) => void): () => void;
+/**
+ * Safe cleanup of a WebGL rendering context.
+ */
+export declare function safeDisposeWebGLContext(gl: WebGLRenderingContext | WebGL2RenderingContext | null | undefined): void;
+/**
+ * Manages GPU and CPU allocated resources for simulation lifecycles,
+ * preventing leaks across mount/unmount cycles.
+ */
+export declare class SimulationResourceManager {
+    private cleanups;
+    private isDisposed;
+    /**
+     * Register a cleanup action to be invoked when the resource manager is disposed.
+     */
+    track(cleanup: () => void): () => void;
+    /**
+     * Track canvas event listeners and auto-remove them on dispose.
+     */
+    trackEventListener(target: EventTarget | null | undefined, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): () => void;
+    /**
+     * Dispose all tracked resources cleanly.
+     */
+    dispose(): void;
+    get disposed(): boolean;
+}

package/dist/graphics/simulation/types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * AF Motion Simulation Optimization & Lifecycle Types
+ *
+ * Framework-independent type definitions for unified simulation coordination,
+ * shared timestep management, resource pooling, and multi-system composition.
+ */
+export type SimulationSubsystemType = "gpu-compute" | "particle" | "fluid" | "environment" | "particle-field" | "physics-3d" | "custom";
+export type SimulationCoordinatorState = "idle" | "running" | "paused" | "stopped" | "disposed";
+export type CoordinatorState = SimulationCoordinatorState;
+export type SimulationQuality = "low" | "medium" | "high" | "ultra";
+export type SimulationCoordinatorTimestepMode = "fixed" | "variable" | "substep";
+export type CoordinatorTimestepMode = SimulationCoordinatorTimestepMode;
+export interface SimulationTimestepConfig {
+    /** Timestep progression mode. Default is 'variable'. */
+    readonly mode?: SimulationCoordinatorTimestepMode;
+    /** Fixed timestep in seconds when mode is 'fixed' or 'substep'. Default: 1/60 (0.01667s). */
+    readonly fixedDelta?: number;
+    /** Maximum frame delta in seconds to prevent simulation divergence ('spiral of death'). Default: 0.1s. */
+    readonly maxDelta?: number;
+    /** Number of internal integration substeps per frame. Default: 1. */
+    readonly substeps?: number;
+    /** Global time scale multiplier. Default: 1.0. */
+    readonly timeScale?: number;
+}
+export interface SimulationParticipant {
+    /** Unique identifier for the simulation participant. */
+    readonly id: string;
+    /** Classification of the subsystem. */
+    readonly type: SimulationSubsystemType;
+    /** Execution and rendering priority (lower values evaluate first). Default: 0. */
+    readonly priority?: number;
+    /** Underlying simulation instance reference. */
+    readonly instance?: unknown;
+    /** Step the simulation forward by delta time dt (in seconds). */
+    step(dt: number, totalTime: number): void;
+    /** Optional render pass to the shared canvas. */
+    render?(canvas: HTMLCanvasElement, ctx?: CanvasRenderingContext2D | WebGL2RenderingContext | null): void;
+    /** Pause participant internal timers if any. */
+    pause?(): void;
+    /** Resume participant internal timers if any. */
+    resume?(): void;
+    /** Reset participant simulation state to initial values. */
+    reset?(): void;
+    /** Apply runtime quality changes (particle count, grid resolution, etc.). */
+    setQuality?(quality: SimulationQuality): void;
+    /** Free participant resources and memory. */
+    dispose(): void;
+    /** Handle WebGL / WebGPU context loss. */
+    onContextLost?(): void;
+    /** Handle WebGL / WebGPU context restoration. */
+    onContextRestored?(): void;
+}
+export interface SimulationCoordinatorMetrics {
+    readonly state: SimulationCoordinatorState;
+    readonly participantCount: number;
+    readonly fps: number;
+    readonly frameTimeMs: number;
+    readonly stepTimeMs: number;
+    readonly renderTimeMs: number;
+    readonly totalSimulationTime: number;
+    readonly frameCount: number;
+    readonly quality: SimulationQuality;
+    readonly isReducedMotion: boolean;
+}
+export interface SimulationCoordinatorConfig {
+    /** Shared canvas element for simulation rendering. */
+    readonly canvas?: HTMLCanvasElement | null;
+    /** Automatically start the simulation coordinator loop upon initialization. Default: true. */
+    readonly autoStart?: boolean;
+    /** Timestep configuration parameters. */
+    readonly timestep?: SimulationTimestepConfig;
+    /** Initial quality level. Default: 'high'. */
+    readonly quality?: SimulationQuality;
+    /** Whether to respect prefers-reduced-motion media query. Default: true. */
+    readonly respectReducedMotion?: boolean;
+    /** Whether to pause when the document/tab is hidden. Default: true. */
+    readonly visibilityAware?: boolean;
+    /** Clear the canvas context before each render pass. Default: true. */
+    readonly clearBeforeRender?: boolean;
+    /** Background clear color when clearBeforeRender is active. Default: null (transparent). */
+    readonly clearColor?: string | null;
+    /** Notification hook fired on each simulation step. */
+    readonly onStep?: (dt: number, totalTime: number) => void;
+    /** Notification hook fired on lifecycle state changes. */
+    readonly onStateChange?: (state: SimulationCoordinatorState) => void;
+}
+export interface SimulationCoordinator {
+    /** Register a simulation subsystem participant. Returns an unregister callback. */
+    register(participant: SimulationParticipant): () => void;
+    /** Unregister a simulation participant by its unique id. */
+    unregister(id: string): void;
+    /** Retrieve a registered participant by id. */
+    getParticipant(id: string): SimulationParticipant | undefined;
+    /** Retrieve all active participants sorted by priority. */
+    listParticipants(): readonly SimulationParticipant[];
+    /** Start the coordinator animation loop. */
+    start(): void;
+    /** Pause the coordinator animation loop. */
+    pause(): void;
+    /** Resume the coordinator animation loop. */
+    resume(): void;
+    /** Reset all registered participants and simulation time to zero. */
+    reset(): void;
+    /** Deterministically step the entire simulation system forward by dt (or fixedDelta). */
+    step(dt?: number): void;
+    /** Trigger an explicit render pass across all participants. */
+    render(): void;
+    /** Cleanly dispose the coordinator and all participants. */
+    dispose(): void;
+    /** Change the global quality level across all participants. */
+    setQuality(quality: SimulationQuality): void;
+    /** Get current quality level. */
+    getQuality(): SimulationQuality;
+    /** Get current coordinator lifecycle state. */
+    getState(): SimulationCoordinatorState;
+    /** Get real-time simulation metrics. */
+    getMetrics(): SimulationCoordinatorMetrics;
+    /** Update the shared canvas target. */
+    setCanvas(canvas: HTMLCanvasElement | null): void;
+    /** Get the current canvas target. */
+    getCanvas(): HTMLCanvasElement | null;
+    /** Explicitly trigger context lost event across participants. */
+    handleContextLost(): void;
+    /** Explicitly trigger context restored event across participants. */
+    handleContextRestored(): void;
+}

package/dist/graphics/textures/cache.d.ts

@@ -0,0 +1,29 @@
+/**
+ * AF Motion Procedural Texture Cache
+ *
+ * Bounded LRU cache with seed-based keys, automatic resource disposal,
+ * and memory-footprint tracking.
+ */
+import type { GeneratedTexture, TextureCacheStats } from "./types.js";
+export interface TextureCacheOptions {
+    /** Maximum number of textures in cache (default: 64) */
+    readonly maxSize?: number;
+    /** Maximum estimated memory in bytes (default: 64 MB = 67,108,864 bytes) */
+    readonly maxMemoryBytes?: number;
+}
+export declare class TextureCache {
+    private readonly cache;
+    private readonly maxSize;
+    private readonly maxMemoryBytes;
+    private currentMemoryBytes;
+    private hits;
+    private misses;
+    constructor(options?: TextureCacheOptions);
+    get(key: string): GeneratedTexture | undefined;
+    set(key: string, texture: GeneratedTexture): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    clear(): void;
+    getStats(): TextureCacheStats;
+}
+export declare const defaultTextureCache: TextureCache;

package/dist/graphics/textures/canvas-utils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * AF Motion Texture Canvas Utilities
+ *
+ * Canvas allocation, pixel manipulation, color parsing, and SSR fallbacks.
+ */
+export interface ColorRGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/**
+ * Parse hex or rgba color string into normalized 0-255 RGBA components.
+ */
+export declare function parseColor(colorStr?: string): ColorRGBA;
+/**
+ * Safe canvas creator. In SSR or environments without DOM, returns null.
+ */
+export declare function createSafeCanvas(width: number, height: number): HTMLCanvasElement | null;
+/**
+ * Safely get 2D context without throwing in JSDOM/SSR environments.
+ */
+export declare function getSafe2DContext(canvas: HTMLCanvasElement | null): CanvasRenderingContext2D | null;
+/**
+ * Safely convert canvas to Data URL, returning empty string if unsupported.
+ */
+export declare function safeToDataURL(canvas: HTMLCanvasElement | null, type?: string): string;
+/**
+ * Format an SVG string into a valid Data URL (safe for SSR and CSS background-image).
+ */
+export declare function encodeSvgDataUrl(svgContent: string): string;

package/dist/graphics/textures/engine.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AF Motion Procedural Texture Engine
+ *
+ * Core execution engine managing deterministic generation, quality presets,
+ * resolution clamping, cache lookups, and resource lifecycles.
+ */
+import type { ResourceManager } from "../types.js";
+import { TextureCache } from "./cache.js";
+import type { GeneratedTexture, ProceduralTextureConfig, ProceduralTextureOptions, TextureGeneratorMetadata, TextureGeneratorName } from "./types.js";
+export interface GenerateTextureExecutionOptions {
+    /** Custom texture cache or false to disable caching (default: defaultTextureCache) */
+    readonly cache?: TextureCache | boolean;
+    /** Optional Prompt 71 ResourceManager to register texture lifecycle with */
+    readonly resourceManager?: ResourceManager;
+    /** Optional owner ID for the resource manager */
+    readonly ownerId?: string;
+}
+/**
+ * Build a deterministic cache key for a texture configuration.
+ */
+export declare function buildTextureCacheKey(generator: TextureGeneratorName, seed: number, width: number, height: number, options?: ProceduralTextureOptions): string;
+/**
+ * Generate a procedural texture deterministically using configurable generators,
+ * seeds, quality presets, and bounded memory caching.
+ */
+export declare function generateProceduralTexture(config: ProceduralTextureConfig, execOptions?: GenerateTextureExecutionOptions): GeneratedTexture;
+/**
+ * Get metadata for a texture generator.
+ */
+export declare function getTextureGeneratorMetadata(name: TextureGeneratorName): TextureGeneratorMetadata | undefined;
+/**
+ * List all available texture generators with their metadata.
+ */
+export declare function listTextureGenerators(): readonly TextureGeneratorMetadata[];