af-motion 0.0.0-stage → 1.0.0

package/dist/graphics/environment/lightning.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AF Motion Environmental Simulation Engine — Lightning Subsystem
+ *
+ * Implements stochastic recursive branching lightning bolts, screen-space illumination
+ * flash decay, storm coordination, and distance-based thunder callback events.
+ */
+import type { EnvironmentalEffect, EnvironmentalEffectType, EnvironmentSimulation, LightningConfig, LightningStrike } from "./types.js";
+export declare class LightningEffectImpl implements EnvironmentalEffect {
+    readonly id: string;
+    readonly type: EnvironmentalEffectType;
+    enabled: boolean;
+    intensity: number;
+    frequency: number;
+    maxFlashes: number;
+    flashDurationMs: number;
+    branchCount: number;
+    stormCoordination: boolean;
+    onThunder?: (delayMs: number, strike: LightningStrike) => void;
+    flashColor: readonly [number, number, number];
+    private activeStrikes;
+    private nextStrikeTimer;
+    private currentFlashAlpha;
+    constructor(config?: LightningConfig);
+    private scheduleNextStrike;
+    triggerStrike(startX?: number, startY?: number, endX?: number, endY?: number): LightningStrike;
+    private generateBoltPath;
+    update(dt: number, _time: number, env: EnvironmentSimulation): void;
+    render(ctx: CanvasRenderingContext2D | WebGL2RenderingContext, targetW: number, targetH: number): void;
+    private drawBranches;
+    get activeStrikeCount(): number;
+    dispose(): void;
+}
+export declare function createLightningEffect(config?: LightningConfig): LightningEffectImpl;

package/dist/graphics/environment/rain.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AF Motion Environmental Simulation Engine — Rain Subsystem
+ *
+ * Implements high-performance rain simulation with wind drift, droplet size variation,
+ * ground impact detection, and dynamic splash particles using Prompt 118 particle infrastructure.
+ */
+import type { EnvironmentalEffect, EnvironmentalEffectType, EnvironmentSimulation, RainConfig } from "./types.js";
+export declare class RainEffectImpl implements EnvironmentalEffect {
+    readonly id: string;
+    readonly type: EnvironmentalEffectType;
+    enabled: boolean;
+    intensity: number;
+    dropletSize: number;
+    dropletLength: number;
+    fallSpeed: number;
+    windInfluence: number;
+    splashesEnabled: boolean;
+    splashCount: number;
+    groundY: number;
+    color: readonly [number, number, number, number];
+    private rainPool;
+    private splashPool;
+    private maxDroplets;
+    private spawnAcc;
+    constructor(config?: RainConfig);
+    update(dt: number, time: number, env: EnvironmentSimulation): void;
+    private spawnSplash;
+    render(ctx: CanvasRenderingContext2D | WebGL2RenderingContext, targetW: number, targetH: number): void;
+    get activeDroplets(): number;
+    get activeSplashes(): number;
+    dispose(): void;
+}
+export declare function createRainEffect(config?: RainConfig): RainEffectImpl;

package/dist/graphics/environment/snow.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AF Motion Environmental Simulation Engine — Snow Subsystem
+ *
+ * Implements realistic snowflake simulation with wind flutter, turbulence drift,
+ * size distribution, and ground accumulation visualization.
+ */
+import type { EnvironmentalEffect, EnvironmentalEffectType, EnvironmentSimulation, SnowConfig } from "./types.js";
+export declare class SnowEffectImpl implements EnvironmentalEffect {
+    readonly id: string;
+    readonly type: EnvironmentalEffectType;
+    enabled: boolean;
+    intensity: number;
+    flakeSize: number;
+    fallSpeed: number;
+    driftAmount: number;
+    turbulence: number;
+    groundY: number;
+    accumulationEnabled: boolean;
+    color: readonly [number, number, number, number];
+    private pool;
+    private maxFlakes;
+    private spawnAcc;
+    private accumulationBins;
+    constructor(config?: SnowConfig);
+    update(dt: number, time: number, env: EnvironmentSimulation): void;
+    render(ctx: CanvasRenderingContext2D | WebGL2RenderingContext, targetW: number, targetH: number): void;
+    get activeFlakes(): number;
+    dispose(): void;
+}
+export declare function createSnowEffect(config?: SnowConfig): SnowEffectImpl;

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

@@ -0,0 +1,184 @@
+/**
+ * AF Motion Environmental Simulation Engine — Type Definitions
+ *
+ * Framework-independent architecture for realistic atmospheric simulations
+ * including rain, snow, fog, clouds, wind, fire, smoke, and lightning.
+ * Coordinates Prompt 117 GPU compute, Prompt 118 particles, and Prompt 119 fluids.
+ */
+import type { ComputeBackendType } from "../gpu-simulation/types.js";
+import type { GraphicsQualityLevel } from "../composition/types.js";
+import type { FlowField } from "../fluid/types.js";
+import type { ParticleVector3Tuple } from "../particles/types.js";
+export type EnvironmentalVector2Tuple = readonly [number, number];
+export type EnvironmentalVector3Tuple = ParticleVector3Tuple;
+export type WeatherState = "clear" | "cloudy" | "rain" | "heavy-rain" | "snow" | "blizzard" | "fog" | "storm" | "firestorm" | "custom";
+export type EnvironmentalEffectType = "rain" | "snow" | "fog" | "cloud" | "wind" | "fire" | "smoke" | "lightning";
+export interface WindConfig {
+    readonly direction?: EnvironmentalVector2Tuple;
+    readonly speed?: number;
+    readonly gustIntensity?: number;
+    readonly gustFrequency?: number;
+    readonly turbulence?: number;
+    readonly spatialScale?: number;
+}
+export interface WindSystem {
+    direction: EnvironmentalVector2Tuple;
+    speed: number;
+    gustIntensity: number;
+    gustFrequency: number;
+    turbulence: number;
+    spatialScale: number;
+    sampleWind(x: number, y: number, z: number, time: number): EnvironmentalVector3Tuple;
+    toFlowField(): FlowField;
+    update(dt: number, time: number): void;
+}
+export interface RainConfig {
+    readonly intensity?: number;
+    readonly dropletSize?: number;
+    readonly dropletLength?: number;
+    readonly fallSpeed?: number;
+    readonly windInfluence?: number;
+    readonly splashesEnabled?: boolean;
+    readonly splashCount?: number;
+    readonly groundY?: number;
+    readonly color?: readonly [number, number, number, number];
+    readonly maxDroplets?: number;
+}
+export interface SnowConfig {
+    readonly intensity?: number;
+    readonly flakeSize?: number;
+    readonly fallSpeed?: number;
+    readonly driftAmount?: number;
+    readonly turbulence?: number;
+    readonly groundY?: number;
+    readonly accumulationEnabled?: boolean;
+    readonly color?: readonly [number, number, number, number];
+    readonly maxFlakes?: number;
+}
+export interface EnvironmentalFogConfig {
+    readonly density?: number;
+    readonly groundHeight?: number;
+    readonly heightFalloff?: number;
+    readonly animated?: boolean;
+    readonly speed?: number;
+    readonly layers?: number;
+    readonly color?: readonly [number, number, number];
+    readonly opacity?: number;
+    readonly approximationMode?: "layered-screen" | "height-gradient";
+}
+export type FogEffectConfig = EnvironmentalFogConfig;
+export interface CloudConfig {
+    readonly coverage?: number;
+    readonly density?: number;
+    readonly layers?: number;
+    readonly speed?: number;
+    readonly altitude?: number;
+    readonly windDriven?: boolean;
+    readonly opacity?: number;
+    readonly color?: readonly [number, number, number];
+}
+export interface FireConfig {
+    readonly position?: EnvironmentalVector3Tuple;
+    readonly intensity?: number;
+    readonly radius?: number;
+    readonly flameHeight?: number;
+    readonly turbulence?: number;
+    readonly smokeEnabled?: boolean;
+    readonly smokeDensity?: number;
+    readonly smokeColor?: readonly [number, number, number];
+    readonly fluidCoupled?: boolean;
+}
+export interface LightningStrike {
+    readonly id: string;
+    readonly startX: number;
+    readonly startY: number;
+    readonly endX: number;
+    readonly endY: number;
+    readonly branches: ReadonlyArray<ReadonlyArray<EnvironmentalVector2Tuple>>;
+    readonly intensity: number;
+    readonly progress: number;
+    readonly durationMs: number;
+}
+export interface LightningConfig {
+    readonly frequency?: number;
+    readonly maxFlashes?: number;
+    readonly flashDurationMs?: number;
+    readonly branchCount?: number;
+    readonly stormCoordination?: boolean;
+    readonly onThunder?: (delayMs: number, strike: LightningStrike) => void;
+    readonly flashColor?: readonly [number, number, number];
+}
+export interface EnvironmentalParameters {
+    temperature?: number;
+    humidity?: number;
+    visibility?: number;
+    atmosphericDensity?: number;
+    ambientLight?: number;
+    skyColor?: readonly [number, number, number];
+}
+export interface EnvironmentalEffect {
+    readonly id: string;
+    readonly type: EnvironmentalEffectType;
+    enabled: boolean;
+    intensity: number;
+    update(dt: number, time: number, env: EnvironmentSimulation): void;
+    render(ctx: CanvasRenderingContext2D | WebGL2RenderingContext, targetW: number, targetH: number): void;
+    dispose(): void;
+}
+export interface EnvironmentMetrics {
+    readonly activeEffects: number;
+    readonly particleCount: number;
+    readonly fps: number;
+    readonly updateTimeMs: number;
+    readonly renderTimeMs: number;
+    readonly memoryBytes: number;
+    readonly backend: ComputeBackendType | "canvas2d";
+}
+export type EnvironmentState = "idle" | "running" | "paused" | "disposed";
+export interface EnvironmentConfig {
+    readonly id?: string;
+    readonly weather?: WeatherState;
+    readonly globalIntensity?: number;
+    readonly parameters?: EnvironmentalParameters;
+    readonly wind?: WindConfig;
+    readonly effects?: readonly EnvironmentalEffect[];
+    readonly quality?: GraphicsQualityLevel;
+    readonly backend?: "auto" | ComputeBackendType;
+    readonly canvas?: HTMLCanvasElement | null;
+    readonly autoStart?: boolean;
+}
+export interface WeatherTransition {
+    readonly from: WeatherState;
+    readonly to: WeatherState;
+    readonly duration: number;
+    progress: number;
+}
+export interface WeatherSystem {
+    currentWeather: WeatherState;
+    targetWeather: WeatherState | null;
+    transitionProgress: number;
+    setWeather(weather: WeatherState, durationSec?: number): void;
+    update(dt: number, env: EnvironmentSimulation): void;
+}
+export interface EnvironmentSimulation {
+    readonly id: string;
+    readonly state: EnvironmentState;
+    readonly metrics: EnvironmentMetrics;
+    readonly wind: WindSystem;
+    readonly weather: WeatherSystem;
+    parameters: Required<EnvironmentalParameters>;
+    globalIntensity: number;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    dispose(): void;
+    update(deltaTime?: number): void;
+    render(canvas?: HTMLCanvasElement): void;
+    addEffect(effect: EnvironmentalEffect): EnvironmentalEffect;
+    removeEffect(id: string): boolean;
+    getEffect(id: string): EnvironmentalEffect | undefined;
+    getEffects(): readonly EnvironmentalEffect[];
+    updateParameters(params: Partial<EnvironmentalParameters>): void;
+    setWeather(weather: WeatherState, transitionSec?: number): void;
+}

package/dist/graphics/environment/weather.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AF Motion Environmental Simulation Engine — Weather Management
+ *
+ * Implements weather state transitions (clear, cloudy, rain, snow, storm, etc.)
+ * with smooth parameter interpolation and coordinated atmospheric effects.
+ */
+import type { EnvironmentSimulation, WeatherState, WeatherSystem } from "./types.js";
+export declare class WeatherSystemImpl implements WeatherSystem {
+    currentWeather: WeatherState;
+    targetWeather: WeatherState | null;
+    transitionProgress: number;
+    private activeTransition;
+    constructor(initialWeather?: WeatherState);
+    setWeather(weather: WeatherState, durationSec?: number): void;
+    update(dt: number, env: EnvironmentSimulation): void;
+    private applyPreset;
+    private interpolatePresets;
+}
+export declare function createWeatherSystem(initialWeather?: WeatherState): WeatherSystem;

package/dist/graphics/environment/wind.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AF Motion Environmental Simulation Engine — Wind Subsystem
+ *
+ * Provides configurable global wind, periodic gusting, spatial turbulence,
+ * and seamless integration with Prompt 119 flow-fields and particle physics.
+ */
+import type { FlowField } from "../fluid/types.js";
+import type { EnvironmentalVector2Tuple, EnvironmentalVector3Tuple, WindConfig, WindSystem } from "./types.js";
+export declare class WindSystemImpl implements WindSystem {
+    direction: EnvironmentalVector2Tuple;
+    speed: number;
+    gustIntensity: number;
+    gustFrequency: number;
+    turbulence: number;
+    spatialScale: number;
+    private currentGust;
+    private flowFieldCache;
+    constructor(config?: WindConfig);
+    update(dt: number, time: number): void;
+    sampleWind(x: number, y: number, z: number, time: number): EnvironmentalVector3Tuple;
+    toFlowField(): FlowField;
+}
+export declare function createWindSystem(config?: WindConfig): WindSystem;

package/dist/graphics/fluid/flow-field.d.ts

@@ -0,0 +1,74 @@
+/**
+ * AF Motion Fluid & Flow Simulation Engine — Flow Fields
+ *
+ * Implements directional, radial, vortex, curl-noise, custom, and composite
+ * force fields with divergence-free mathematical guarantees and field blending.
+ */
+import type { CompositeFlowFieldConfig, CurlNoiseFlowFieldConfig, CustomFlowFieldConfig, DirectionalFlowFieldConfig, FlowField, FlowFieldConfig, FlowFieldType, RadialFlowFieldConfig, Vector2Tuple, VortexFlowFieldConfig } from "./types.js";
+declare abstract class BaseFlowField implements FlowField {
+    readonly id: string;
+    abstract readonly type: FlowFieldType;
+    enabled: boolean;
+    weight: number;
+    constructor(id?: string, weight?: number);
+    abstract evaluate(x: number, y: number, time: number): Vector2Tuple;
+}
+export declare class DirectionalFlowField extends BaseFlowField {
+    readonly type: "directional";
+    private readonly dirX;
+    private readonly dirY;
+    constructor(config: DirectionalFlowFieldConfig);
+    evaluate(_x: number, _y: number, _time: number): Vector2Tuple;
+}
+export declare class RadialFlowField extends BaseFlowField {
+    readonly type: "radial";
+    private readonly cx;
+    private readonly cy;
+    private readonly strength;
+    private readonly radius;
+    private readonly falloff;
+    constructor(config: RadialFlowFieldConfig);
+    evaluate(x: number, y: number, _time: number): Vector2Tuple;
+}
+export declare class VortexFlowField extends BaseFlowField {
+    readonly type: "vortex";
+    private readonly cx;
+    private readonly cy;
+    private readonly strength;
+    private readonly radius;
+    private readonly inwardPull;
+    constructor(config: VortexFlowFieldConfig);
+    evaluate(x: number, y: number, _time: number): Vector2Tuple;
+}
+/**
+ * Divergence-free Curl-Noise Flow Field
+ * F = (dPsi/dy, -dPsi/dx) where Psi is a scalar potential function.
+ * Since div(curl(Psi)) = 0, this creates perfectly incompressible fluid motion.
+ */
+export declare class CurlNoiseFlowField extends BaseFlowField {
+    readonly type: "curl-noise";
+    private readonly frequency;
+    private readonly strength;
+    private readonly octaves;
+    private readonly timeScale;
+    constructor(config?: CurlNoiseFlowFieldConfig);
+    private potential;
+    evaluate(x: number, y: number, time: number): Vector2Tuple;
+}
+export declare class CustomFlowField extends BaseFlowField {
+    readonly type: "custom";
+    private readonly customEval;
+    constructor(config: CustomFlowFieldConfig);
+    evaluate(x: number, y: number, time: number): Vector2Tuple;
+}
+export declare class CompositeFlowField extends BaseFlowField {
+    readonly type: "composite";
+    private readonly fields;
+    constructor(config: CompositeFlowFieldConfig);
+    evaluate(x: number, y: number, time: number): Vector2Tuple;
+    addField(field: FlowField | FlowFieldConfig): FlowField;
+    removeField(id: string): boolean;
+    getFields(): readonly FlowField[];
+}
+export declare function createFlowField(config: FlowFieldConfig): FlowField;
+export {};

package/dist/graphics/fluid/grid.d.ts

@@ -0,0 +1,43 @@
+/**
+ * AF Motion Fluid & Flow Simulation Engine — Eulerian Grid
+ *
+ * Provides a 2D staggered/collocated Eulerian grid with double-buffered
+ * velocity and density fields, pressure, divergence, and obstacle masks.
+ */
+import type { FluidGrid, Vector2Tuple } from "./types.js";
+export declare class FluidGridImpl implements FluidGrid {
+    readonly width: number;
+    readonly height: number;
+    readonly size: number;
+    private _u;
+    private _v;
+    private _u0;
+    private _v0;
+    private _density;
+    private _density0;
+    private readonly _pressure;
+    private readonly _divergence;
+    private readonly _obstacles;
+    constructor(width: number, height: number);
+    get u(): Float32Array;
+    get v(): Float32Array;
+    get u0(): Float32Array;
+    get v0(): Float32Array;
+    get density(): Float32Array;
+    get density0(): Float32Array;
+    get pressure(): Float32Array;
+    get divergence(): Float32Array;
+    get obstacles(): Uint8Array;
+    swapVelocity(): void;
+    swapDensity(): void;
+    clear(): void;
+    /**
+     * Sample bilinear velocity at normalized [0, 1] coordinates.
+     */
+    sampleVelocity(normX: number, normY: number): Vector2Tuple;
+    /**
+     * Sample bilinear scalar density at normalized [0, 1] coordinates.
+     */
+    sampleDensity(normX: number, normY: number): number;
+}
+export declare function createFluidGrid(width: number, height: number): FluidGrid;

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

@@ -0,0 +1,13 @@
+/**
+ * AF Motion Fluid & Flow Simulation Engine
+ *
+ * Framework-independent Eulerian fluid dynamics, Navier-Stokes solver,
+ * divergence-free flow fields, obstacle collision, and particle-fluid coupling.
+ */
+export * from "./types.js";
+export * from "./grid.js";
+export * from "./solver.js";
+export * from "./flow-field.js";
+export * from "./interactions.js";
+export * from "./rendering.js";
+export * from "./simulation.js";

package/dist/graphics/fluid/interactions.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AF Motion Fluid & Flow Simulation Engine — Interaction & Obstacles
+ *
+ * Provides solid obstacle geometry (circles, boxes), obstacle rasterization,
+ * pointer impulse generation, and bidirectional particle-fluid coupling.
+ */
+import type { FluidForce, FluidGrid, FluidObstacle, FluidObstacleShape, Vector2Tuple } from "./types.js";
+export declare class FluidObstacleImpl implements FluidObstacle {
+    readonly id: string;
+    readonly shape: FluidObstacleShape;
+    enabled: boolean;
+    constructor(shape: FluidObstacleShape, id?: string);
+    contains(normX: number, normY: number): boolean;
+}
+export declare function createFluidObstacle(shape: FluidObstacleShape, id?: string): FluidObstacle;
+/**
+ * Re-rasterize all active obstacles onto the grid's obstacle buffer.
+ */
+export declare function rasterizeObstacles(grid: FluidGrid, obstacles: readonly FluidObstacle[]): void;
+/**
+ * Creates an impulse force from pointer or touch movement.
+ */
+export declare function createPointerForce(prevPos: Vector2Tuple, currPos: Vector2Tuple, radius?: number, strength?: number, density?: number): FluidForce;
+/**
+ * Interface representing particles for coupling with the fluid field.
+ */
+export interface CouplableParticle {
+    x: number;
+    y: number;
+    vx: number;
+    vy: number;
+    mass?: number;
+}
+/**
+ * Coupler between particle systems and the Eulerian fluid grid.
+ * - Applies fluid velocity drag to particles.
+ * - Injects particle momentum back into the fluid grid.
+ */
+export declare function coupleParticlesWithFluid(grid: FluidGrid, particles: CouplableParticle[], drag?: number, feedback?: number, dt?: number): void;

package/dist/graphics/fluid/rendering.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AF Motion Fluid & Flow Simulation Engine — Visualization & Rendering
+ *
+ * Implements GPU-accelerated WebGL2 texture visualization alongside high-performance
+ * Canvas2D rasterization for density, velocity, pressure, and vector fields.
+ */
+import type { FluidGrid, FluidObstacle, FluidRenderOptions } from "./types.js";
+export interface FluidRenderer {
+    render(grid: FluidGrid, obstacles?: readonly FluidObstacle[]): void;
+    dispose(): void;
+}
+export declare class Canvas2DFluidRenderer implements FluidRenderer {
+    private readonly canvas;
+    private readonly ctx;
+    private options;
+    private imgData;
+    constructor(canvas: HTMLCanvasElement, options?: FluidRenderOptions);
+    setOptions(options: FluidRenderOptions): void;
+    render(grid: FluidGrid, obstacles?: readonly FluidObstacle[]): void;
+    private renderRasterField;
+    private renderVectorGlyphs;
+    private renderObstacles;
+    dispose(): void;
+}
+export declare class WebGL2FluidRenderer implements FluidRenderer {
+    private readonly gl;
+    private fallback;
+    constructor(canvas: HTMLCanvasElement, options?: FluidRenderOptions);
+    render(grid: FluidGrid, obstacles?: readonly FluidObstacle[]): void;
+    dispose(): void;
+}
+export declare function createFluidRenderer(canvas: HTMLCanvasElement | null, options?: FluidRenderOptions): FluidRenderer | null;

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

@@ -0,0 +1,50 @@
+/**
+ * AF Motion Fluid & Flow Simulation Engine — Simulation Controller
+ *
+ * Coordinates Eulerian fluid grid, Navier-Stokes numerical solver, flow fields,
+ * obstacle collision, rendering pipeline, and hardware capability adaptation.
+ */
+import type { ComputeBackendType } from "../gpu-simulation/types.js";
+import type { FlowField, FlowFieldConfig, FluidForce, FluidGrid, FluidObstacle, FluidObstacleShape, FluidSimulation, FluidSimulationConfig, FluidSimulationMetrics, FluidSimulationState, Vector2Tuple } from "./types.js";
+export declare class FluidSimulationImpl implements FluidSimulation {
+    readonly id: string;
+    readonly grid: FluidGrid;
+    readonly backend: ComputeBackendType | "canvas2d";
+    private _state;
+    private readonly solver;
+    private readonly compositeFlowField;
+    private readonly obstacles;
+    private readonly queuedForces;
+    private renderer;
+    private animFrameId;
+    private lastTime;
+    private totalSimTime;
+    private readonly fixedTimestep;
+    private _metrics;
+    constructor(config?: FluidSimulationConfig);
+    get state(): FluidSimulationState;
+    get metrics(): FluidSimulationMetrics;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    dispose(): void;
+    update(deltaTime?: number): void;
+    render(canvas?: HTMLCanvasElement, context?: unknown): void;
+    addForce(force: FluidForce): void;
+    addObstacle(shape: FluidObstacleShape, id?: string): FluidObstacle;
+    removeObstacle(id: string): boolean;
+    addFlowField(field: FlowField | FlowFieldConfig): FlowField;
+    removeFlowField(id: string): boolean;
+    sampleVelocity(normX: number, normY: number): Vector2Tuple;
+    sampleDensity(normX: number, normY: number): number;
+    getObstacles(): readonly FluidObstacle[];
+    getFlowFields(): readonly FlowField[];
+}
+export declare function createFluidSimulation(config?: FluidSimulationConfig): FluidSimulation;
+export declare function addFluidForce(sim: FluidSimulation, force: FluidForce): void;
+export declare function addFluidObstacle(sim: FluidSimulation, shape: FluidObstacleShape, id?: string): FluidObstacle;
+export declare function updateFluidSimulation(sim: FluidSimulation, deltaTime?: number): void;
+export declare function sampleFluidVelocity(sim: FluidSimulation, normX: number, normY: number): Vector2Tuple;
+export declare function resetFluidSimulation(sim: FluidSimulation): void;
+export declare function disposeFluidSimulation(sim: FluidSimulation): void;

package/dist/graphics/fluid/solver.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AF Motion Fluid & Flow Simulation Engine — Navier-Stokes Solver
+ *
+ * Implements Stam's unconditionally stable fluid dynamics algorithm with
+ * semi-Lagrangian advection, Jacobi pressure projection, viscosity diffusion,
+ * obstacle masking, and configurable boundary conditions.
+ */
+import type { FluidForce, FluidGrid, FluidSolver, FluidSolverConfig } from "./types.js";
+export declare class FluidSolverImpl implements FluidSolver {
+    readonly config: Required<FluidSolverConfig>;
+    constructor(config?: FluidSolverConfig);
+    step(grid: FluidGrid, dt: number, forces: readonly FluidForce[], time: number): void;
+    private applyForces;
+    private diffuse;
+    private advect;
+    private project;
+    private setBoundaries;
+}
+export declare function createFluidSolver(config?: FluidSolverConfig): FluidSolver;