af-motion 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,150 @@
+/**
+ * AF Motion Materials, Surfaces, Lighting & Glass Contracts
+ *
+ * Framework-independent definitions for configurable surfaces,
+ * lighting systems, material lifecycles, and progressive glass effects.
+ */
+export type MaterialType = "matte" | "metallic" | "glass" | "plastic" | "emissive" | "translucent" | "custom";
+export interface MaterialUniforms {
+    readonly [uniformName: string]: number | readonly number[] | string | boolean;
+}
+export interface MaterialProperty {
+    readonly name: string;
+    readonly type: "float" | "vec2" | "vec3" | "vec4" | "color" | "boolean" | "texture";
+    readonly value: unknown;
+    readonly min?: number;
+    readonly max?: number;
+}
+export interface SurfaceBorderOptions {
+    readonly width?: number | string;
+    readonly style?: string;
+    readonly color?: string;
+    readonly radius?: number | string;
+    readonly glow?: string;
+}
+export interface SurfaceHighlightOptions {
+    readonly color?: string;
+    readonly intensity?: number;
+    readonly angle?: number;
+    readonly spread?: number;
+}
+export interface SurfaceDefinition {
+    readonly roughness?: number;
+    readonly smoothness?: number;
+    readonly opacity?: number;
+    readonly transmission?: number;
+    readonly baseColor?: string;
+    readonly border?: SurfaceBorderOptions;
+    readonly elevation?: number;
+    readonly depth?: number;
+    readonly highlight?: SurfaceHighlightOptions;
+    readonly reflectivity?: number;
+    readonly refractiveIndex?: number;
+    readonly textureRef?: string;
+    readonly textureScale?: number | readonly [number, number];
+    readonly textureOffset?: readonly [number, number];
+    readonly textureRepeat?: "repeat" | "no-repeat" | "repeat-x" | "repeat-y";
+    readonly textureOpacity?: number;
+    readonly blendMode?: "normal" | "multiply" | "screen" | "overlay" | "soft-light";
+}
+export interface SurfaceStyleResult {
+    readonly background: string;
+    readonly backgroundImage?: string;
+    readonly backgroundSize?: string;
+    readonly backgroundRepeat?: string;
+    readonly backgroundPosition?: string;
+    readonly backgroundBlendMode?: string;
+    readonly backdropFilter?: string;
+    readonly WebkitBackdropFilter?: string;
+    readonly border: string;
+    readonly borderRadius: string;
+    readonly boxShadow: string;
+    readonly opacity: number;
+    readonly color?: string;
+    readonly outline?: string;
+    readonly transform?: string;
+    readonly uniforms?: MaterialUniforms;
+}
+export interface AmbientLight {
+    readonly color?: string;
+    readonly intensity?: number;
+}
+export interface DirectionalLight {
+    readonly direction?: readonly [number, number, number];
+    readonly color?: string;
+    readonly intensity?: number;
+}
+export interface PointLight {
+    readonly position?: readonly [number, number, number];
+    readonly color?: string;
+    readonly intensity?: number;
+    readonly attenuation?: number;
+}
+export interface HighlightConfig {
+    readonly color?: string;
+    readonly blur?: number | string;
+    readonly angle?: number;
+}
+export interface ShadowConfig {
+    readonly offset?: readonly [number, number];
+    readonly blur?: number;
+    readonly spread?: number;
+    readonly color?: string;
+    readonly opacity?: number;
+    readonly inset?: boolean;
+}
+export interface EnvironmentLighting {
+    readonly preset?: "studio" | "dramatic" | "ambient-soft" | "neon" | "sunset";
+    readonly intensity?: number;
+    readonly tint?: string;
+}
+export interface LightingConfig {
+    readonly ambient?: AmbientLight;
+    readonly directional?: DirectionalLight;
+    readonly point?: PointLight;
+    readonly highlight?: HighlightConfig;
+    readonly shadows?: readonly ShadowConfig[];
+    readonly environment?: EnvironmentLighting;
+}
+export interface ResolvedLighting {
+    readonly ambientColor: string;
+    readonly ambientIntensity: number;
+    readonly primaryLightColor: string;
+    readonly primaryLightDirection: readonly [number, number, number];
+    readonly shadowsCss: string;
+    readonly highlightCss: string;
+    readonly uniforms: MaterialUniforms;
+}
+export interface MaterialDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly type: MaterialType;
+    readonly version?: string;
+    readonly surface: SurfaceDefinition;
+    readonly lighting?: LightingConfig;
+    readonly uniforms?: MaterialUniforms;
+    readonly customShaders?: {
+        readonly vertexShader?: string;
+        readonly fragmentShader?: string;
+    };
+}
+export type GlassPresetName = "frosted-glass" | "clear-glass" | "tinted-glass" | "liquid-glass" | "acrylic" | "translucent-panel";
+export interface GlassMaterialOptions {
+    readonly preset?: GlassPresetName;
+    readonly blur?: number;
+    readonly opacity?: number;
+    readonly tint?: string;
+    readonly elevation?: number;
+    readonly edgeHighlight?: boolean;
+    readonly borderWidth?: number | string;
+    readonly borderColor?: string;
+    readonly borderRadius?: number | string;
+    readonly refractiveIndex?: number;
+    readonly highContrast?: boolean;
+    readonly reducedMotion?: boolean;
+}
+export interface GlassStyleResult extends SurfaceStyleResult {
+    readonly preset: GlassPresetName;
+    readonly blur: number;
+    readonly isFallback: boolean;
+}

package/dist/graphics/particle-fields/composition.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AF Motion Interactive Particle Fields & Forces — Field Composition
+ *
+ * Implements priority-based and additive force composition, maximum acceleration
+ * clamping, spatial acceleration integration, and Prompt 118 behavior adaptation.
+ */
+import type { CustomBehavior, ParticleDataPool } from "../particles/types.js";
+import type { ForceField, ForceFieldConfig, ForceFieldManagerConfig, ForceVector3Tuple, ParticleFieldMetrics } from "./types.js";
+export declare class ForceFieldManager {
+    private readonly fields;
+    private readonly spatialGrid;
+    private readonly spatialEnabled;
+    private readonly maxAcceleration;
+    private totalForcesEvaluated;
+    private lastEvaluationTimeMs;
+    constructor(config?: ForceFieldManagerConfig);
+    addField(field: ForceField | ForceFieldConfig): ForceField;
+    removeField(id: string): boolean;
+    getField(id: string): ForceField | undefined;
+    getFields(): readonly ForceField[];
+    clear(): void;
+    private sortFields;
+    rebuildSpatial(): void;
+    evaluateCombinedForce(px: number, py: number, pz: number, vx: number, vy: number, vz: number, mass?: number, time?: number): ForceVector3Tuple;
+    applyToPool(pool: ParticleDataPool, dt: number, time?: number): void;
+    /**
+     * Adapts this ForceFieldManager into a Prompt 118 ParticleBehavior.
+     */
+    toParticleBehavior(): CustomBehavior;
+    getMetrics(particleCount?: number): ParticleFieldMetrics;
+}
+export declare function createForceFieldManager(config?: ForceFieldManagerConfig): ForceFieldManager;

package/dist/graphics/particle-fields/forces.d.ts

@@ -0,0 +1,103 @@
+/**
+ * AF Motion Interactive Particle Fields & Forces — Force Field Implementations
+ *
+ * Implements attraction, repulsion, vortex, directional, gravitational,
+ * turbulence, drag, custom, and fluid/wind-coupled force fields with configurable falloffs.
+ */
+import type { AttractionForceConfig, CustomForceConfig, DirectionalForceConfig, DragForceConfig, FlowCoupledForceConfig, ForceField, ForceFieldConfig, ForceVector3Tuple, GravitationalForceConfig, ParticleFalloffType, ParticleForceType, RepulsionForceConfig, TurbulenceForceConfig, VortexForceConfig } from "./types.js";
+export declare function computeFalloff(distance: number, radius: number, falloff: ParticleFalloffType): number;
+declare abstract class BaseForceField implements ForceField {
+    readonly id: string;
+    abstract readonly type: ParticleForceType;
+    enabled: boolean;
+    weight: number;
+    priority: number;
+    position: ForceVector3Tuple;
+    radius: number;
+    falloff: ParticleFalloffType;
+    maxForce: number;
+    constructor(config: {
+        id?: string;
+        enabled?: boolean;
+        weight?: number;
+        priority?: number;
+        position?: ForceVector3Tuple;
+        radius?: number;
+        falloff?: ParticleFalloffType;
+        maxForce?: number;
+    });
+    abstract evaluate(px: number, py: number, pz: number, vx: number, vy: number, vz: number, mass: number, time: number): ForceVector3Tuple;
+}
+export declare class AttractionForceField extends BaseForceField {
+    readonly type: "attraction";
+    strength: number;
+    minDistance: number;
+    constructor(config: AttractionForceConfig);
+    evaluate(px: number, py: number, pz: number): ForceVector3Tuple;
+}
+export declare class RepulsionForceField extends BaseForceField {
+    readonly type: "repulsion";
+    strength: number;
+    minDistance: number;
+    constructor(config: RepulsionForceConfig);
+    evaluate(px: number, py: number, pz: number): ForceVector3Tuple;
+}
+export declare class VortexForceField extends BaseForceField {
+    readonly type: "vortex";
+    strength: number;
+    axis: ForceVector3Tuple;
+    inwardPull: number;
+    constructor(config: VortexForceConfig);
+    evaluate(px: number, py: number, pz: number): ForceVector3Tuple;
+}
+export declare class DirectionalForceField extends BaseForceField {
+    readonly type: "directional";
+    direction: ForceVector3Tuple;
+    strength: number;
+    constructor(config: DirectionalForceConfig);
+    evaluate(px: number, py: number, pz: number): ForceVector3Tuple;
+}
+export declare class GravitationalForceField extends BaseForceField {
+    readonly type: "gravitational";
+    mass: number;
+    G: number;
+    softening: number;
+    constructor(config: GravitationalForceConfig);
+    evaluate(px: number, py: number, pz: number, _vx: number, _vy: number, _vz: number, particleMass?: number): ForceVector3Tuple;
+}
+export declare class TurbulenceForceField extends BaseForceField {
+    readonly type: "turbulence";
+    frequency: number;
+    strength: number;
+    octaves: number;
+    timeScale: number;
+    constructor(config: TurbulenceForceConfig);
+    evaluate(px: number, py: number, pz: number, _vx: number, _vy: number, _vz: number, _mass: number, time?: number): ForceVector3Tuple;
+}
+export declare class DragForceField extends BaseForceField {
+    readonly type: "drag";
+    damping: number;
+    quadratic: boolean;
+    constructor(config: DragForceConfig);
+    evaluate(px: number, py: number, pz: number, vx: number, vy: number, vz: number): ForceVector3Tuple;
+}
+export declare class CustomForceField extends BaseForceField {
+    readonly type: "custom";
+    private readonly customFn;
+    constructor(config: CustomForceConfig);
+    evaluate(px: number, py: number, pz: number, vx: number, vy: number, vz: number, mass: number, time: number): ForceVector3Tuple;
+}
+export declare class FlowCoupledForceField extends BaseForceField {
+    readonly type: "flow-coupled";
+    flowField?: FlowCoupledForceConfig["flowField"];
+    windSystem?: FlowCoupledForceConfig["windSystem"];
+    dragCoefficient: number;
+    constructor(config: FlowCoupledForceConfig);
+    evaluate(px: number, py: number, pz: number, vx: number, vy: number, vz: number, _mass: number, time: number): ForceVector3Tuple;
+}
+export declare function createForceField(config: ForceFieldConfig): ForceField;
+export declare function createAttractionField(config: AttractionForceConfig): ForceField;
+export declare function createRepulsionField(config: RepulsionForceConfig): ForceField;
+export declare function createVortexField(config: VortexForceConfig): ForceField;
+export declare function createTurbulenceField(config: TurbulenceForceConfig): ForceField;
+export {};

package/dist/graphics/particle-fields/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AF Motion Interactive Particle Fields & Forces
+ *
+ * Framework-independent spatial force fields, pointer interaction,
+ * gesture impulses, fluid coupling, and high-performance particle dynamics.
+ */
+export * from "./types.js";
+export * from "./forces.js";
+export * from "./spatial-index.js";
+export * from "./composition.js";
+export * from "./interaction.js";
+export * from "./system.js";

package/dist/graphics/particle-fields/interaction.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AF Motion Interactive Particle Fields & Forces — Pointer & Gesture Integration
+ *
+ * Translates pointer motion, multi-touch events, and Prompt 105-110 gestures
+ * into dynamic spatial attraction, repulsion, shockwave bursts, and rotational forces.
+ */
+import type { GestureType } from "../../core/interactions/types.js";
+import type { GestureForceAction, InteractivePointer, PointerInteractionConfig } from "./types.js";
+import type { ForceFieldManager } from "./composition.js";
+export declare class ParticleInteractionController {
+    private readonly manager;
+    private readonly config;
+    private readonly pointers;
+    private readonly pointerFields;
+    private readonly gestureMappings;
+    constructor(manager: ForceFieldManager, config?: PointerInteractionConfig, gestureMappings?: readonly GestureForceAction[]);
+    updatePointer(id: number | string, x: number, y: number, active?: boolean, primaryButton?: boolean, z?: number): void;
+    removePointer(id: number | string): void;
+    private syncPointerField;
+    /**
+     * Dispatches a gesture action into appropriate instantaneous or sustained force bursts.
+     */
+    handleGesture(gesture: GestureType, originX: number, originY: number, details?: {
+        scale?: number;
+        rotation?: number;
+        velocityX?: number;
+        velocityY?: number;
+    }): void;
+    private getDefaultActionForGesture;
+    getPointers(): readonly InteractivePointer[];
+    clear(): void;
+}

package/dist/graphics/particle-fields/spatial-index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AF Motion Interactive Particle Fields & Forces — Spatial Broad-Phase Index
+ *
+ * Implements a uniform spatial hash grid for fast broad-phase force field culling,
+ * minimizing evaluation cost when many localized force fields are active.
+ */
+import type { ForceField } from "./types.js";
+export declare class SpatialFieldGrid {
+    readonly cellSize: number;
+    private readonly cells;
+    private readonly globalFields;
+    constructor(cellSize?: number);
+    private hash;
+    clear(): void;
+    insert(field: ForceField): void;
+    rebuild(fields: readonly ForceField[]): void;
+    query(px: number, py: number, pz: number): readonly ForceField[];
+    get cellCount(): number;
+    get globalCount(): number;
+}

package/dist/graphics/particle-fields/system.d.ts

@@ -0,0 +1,52 @@
+/**
+ * AF Motion Interactive Particle Fields & Forces — Master System Controller
+ *
+ * Coordinates particle pools, composite force fields, pointer interaction,
+ * gesture response, fluid/wind coupling, and hardware-accelerated rendering.
+ */
+import type { ParticleDataPool } from "../particles/types.js";
+import { ForceFieldManager } from "./composition.js";
+import { createAttractionField, createForceField, createRepulsionField, createTurbulenceField, createVortexField } from "./forces.js";
+import { ParticleInteractionController } from "./interaction.js";
+import type { ForceField, ForceFieldConfig, InteractiveParticleSystemConfig, ParticleFieldMetrics } from "./types.js";
+import type { GestureType } from "../../core/interactions/types.js";
+export declare class InteractiveParticleSystem {
+    readonly id: string;
+    readonly pool: ParticleDataPool;
+    readonly fieldManager: ForceFieldManager;
+    readonly interaction: ParticleInteractionController;
+    private _state;
+    private canvas;
+    private animFrameId;
+    private lastTime;
+    private totalTime;
+    constructor(config?: InteractiveParticleSystemConfig);
+    get state(): "idle" | "running" | "paused" | "disposed";
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+    dispose(): void;
+    update(deltaTime?: number): void;
+    render(canvas?: HTMLCanvasElement): void;
+    addForce(force: ForceField | ForceFieldConfig): ForceField;
+    removeForce(id: string): boolean;
+    getForce(id: string): ForceField | undefined;
+    getForces(): readonly ForceField[];
+    updatePointer(id: number | string, x: number, y: number, active?: boolean, primaryButton?: boolean, z?: number): void;
+    removePointer(id: number | string): void;
+    handleGesture(gesture: GestureType, x: number, y: number, details?: {
+        scale?: number;
+        rotation?: number;
+        velocityX?: number;
+        velocityY?: number;
+    }): void;
+    getMetrics(): ParticleFieldMetrics;
+}
+export declare function createInteractiveParticleSystem(config?: InteractiveParticleSystemConfig): InteractiveParticleSystem;
+export declare function createParticleField(config?: ForceFieldConfig): ForceField;
+export declare function addParticleForce(sys: InteractiveParticleSystem, force: ForceField | ForceFieldConfig): ForceField;
+export declare function removeParticleForce(sys: InteractiveParticleSystem, id: string): boolean;
+export declare function updateParticleField(sys: InteractiveParticleSystem, deltaTime?: number): void;
+export declare function disposeParticleField(sys: InteractiveParticleSystem): void;
+export { createAttractionField, createForceField, createRepulsionField, createTurbulenceField, createVortexField, };

package/dist/graphics/particle-fields/types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * AF Motion Interactive Particle Fields & Forces — Type Definitions
+ *
+ * Framework-independent architecture for interactive spatial force fields,
+ * pointer attraction/repulsion, gesture-driven impulses, fluid coupling,
+ * and high-performance spatial-partitioned field composition.
+ */
+import type { ParticleVector3Tuple } from "../particles/types.js";
+import type { FlowField } from "../fluid/types.js";
+import type { WindSystem } from "../environment/types.js";
+import type { GestureType } from "../../core/interactions/types.js";
+export type ForceVector3Tuple = ParticleVector3Tuple;
+export type ParticleForceType = "attraction" | "repulsion" | "vortex" | "directional" | "gravitational" | "turbulence" | "drag" | "custom" | "flow-coupled";
+export type ParticleFalloffType = "none" | "linear" | "inverse-distance" | "inverse-square" | "smoothstep" | "exponential";
+export interface BaseForceFieldConfig {
+    readonly id?: string;
+    readonly type: ParticleForceType;
+    readonly enabled?: boolean;
+    readonly weight?: number;
+    readonly priority?: number;
+    readonly position?: ForceVector3Tuple;
+    readonly radius?: number;
+    readonly falloff?: ParticleFalloffType;
+    readonly maxForce?: number;
+}
+export interface AttractionForceConfig extends BaseForceFieldConfig {
+    readonly type: "attraction";
+    readonly strength: number;
+    readonly minDistance?: number;
+}
+export interface RepulsionForceConfig extends BaseForceFieldConfig {
+    readonly type: "repulsion";
+    readonly strength: number;
+    readonly minDistance?: number;
+}
+export interface VortexForceConfig extends BaseForceFieldConfig {
+    readonly type: "vortex";
+    readonly strength: number;
+    readonly axis?: ForceVector3Tuple;
+    readonly inwardPull?: number;
+}
+export interface DirectionalForceConfig extends BaseForceFieldConfig {
+    readonly type: "directional";
+    readonly direction: ForceVector3Tuple;
+    readonly strength: number;
+}
+export interface GravitationalForceConfig extends BaseForceFieldConfig {
+    readonly type: "gravitational";
+    readonly mass: number;
+    readonly G?: number;
+    readonly softening?: number;
+}
+export interface TurbulenceForceConfig extends BaseForceFieldConfig {
+    readonly type: "turbulence";
+    readonly frequency?: number;
+    readonly strength?: number;
+    readonly octaves?: number;
+    readonly timeScale?: number;
+}
+export interface DragForceConfig extends BaseForceFieldConfig {
+    readonly type: "drag";
+    readonly damping: number;
+    readonly quadratic?: boolean;
+}
+export interface CustomForceConfig extends BaseForceFieldConfig {
+    readonly type: "custom";
+    readonly evaluate: (px: number, py: number, pz: number, vx: number, vy: number, vz: number, mass: number, time: number) => ForceVector3Tuple;
+}
+export interface FlowCoupledForceConfig extends BaseForceFieldConfig {
+    readonly type: "flow-coupled";
+    readonly flowField?: FlowField;
+    readonly windSystem?: WindSystem;
+    readonly dragCoefficient?: number;
+}
+export type ForceFieldConfig = AttractionForceConfig | RepulsionForceConfig | VortexForceConfig | DirectionalForceConfig | GravitationalForceConfig | TurbulenceForceConfig | DragForceConfig | CustomForceConfig | FlowCoupledForceConfig;
+export interface ForceField {
+    readonly id: string;
+    readonly type: ParticleForceType;
+    enabled: boolean;
+    weight: number;
+    priority: number;
+    position: ForceVector3Tuple;
+    radius: number;
+    falloff: ParticleFalloffType;
+    maxForce: number;
+    evaluate(px: number, py: number, pz: number, vx: number, vy: number, vz: number, mass: number, time: number): ForceVector3Tuple;
+    update?(dt: number, time: number): void;
+}
+export interface InteractivePointer {
+    readonly id: number | string;
+    x: number;
+    y: number;
+    z?: number;
+    vx: number;
+    vy: number;
+    vz?: number;
+    active: boolean;
+    primaryButton: boolean;
+    pressure?: number;
+}
+export interface PointerInteractionConfig {
+    readonly mode?: "attract" | "repel" | "vortex" | "velocity-drag" | "burst";
+    readonly radius?: number;
+    readonly strength?: number;
+    readonly burstCount?: number;
+    readonly burstSpeed?: number;
+    readonly smoothVelocity?: boolean;
+}
+export interface GestureForceAction {
+    readonly gesture: GestureType;
+    readonly action: "burst" | "radial-shockwave" | "displace" | "momentum-inject" | "expand" | "compress" | "vortex" | "singularity";
+    readonly strength?: number;
+    readonly radius?: number;
+}
+export interface ForceFieldManagerConfig {
+    readonly maxAcceleration?: number;
+    readonly defaultFalloff?: ParticleFalloffType;
+    readonly spatialPartitioning?: boolean;
+    readonly spatialCellSize?: number;
+}
+export interface ParticleFieldMetrics {
+    readonly activeFields: number;
+    readonly particleCount: number;
+    readonly forcesEvaluated: number;
+    readonly evaluationTimeMs: number;
+    readonly memoryBytes: number;
+    readonly spatialIndexEnabled: boolean;
+}
+export interface InteractiveParticleSystemConfig {
+    readonly id?: string;
+    readonly maxParticles?: number;
+    readonly forces?: readonly ForceFieldConfig[];
+    readonly pointerInteraction?: PointerInteractionConfig;
+    readonly gestureMappings?: readonly GestureForceAction[];
+    readonly composition?: ForceFieldManagerConfig;
+    readonly canvas?: HTMLCanvasElement | null;
+    readonly autoStart?: boolean;
+}

package/dist/graphics/particles/behaviors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion Advanced Particle Engine — Behaviors
+ *
+ * Implements composable physical behaviors including gravity, attraction,
+ * repulsion, drag, friction, turbulence noise, velocity limits, and boundary constraints.
+ */
+import type { ParticleBehavior, ParticleDataPool } from "./types.js";
+/**
+ * Applies all active behaviors to the particle pool in-place.
+ */
+export declare function applyParticleBehaviors(pool: ParticleDataPool, behaviors: readonly ParticleBehavior[], dt: number): void;

package/dist/graphics/particles/controller.d.ts

@@ -0,0 +1,82 @@
+/**
+ * AF Motion Advanced Particle Engine — System Controller
+ *
+ * Implements the master ParticleSystem controller managing multi-emitter simulation,
+ * composable physics behaviors, GPU/CPU rendering, adaptive quality scaling,
+ * and performance metrics tracking.
+ */
+import type { ComputeBackendType } from "../gpu-simulation/types.js";
+import type { ParticleBehavior, ParticleEmitter, ParticleEmitterConfig, ParticleSystem, ParticleSystemConfig, ParticleSystemMetrics, ParticleSystemState } from "./types.js";
+export declare class ParticleSystemImpl implements ParticleSystem {
+    readonly id: string;
+    readonly maxParticles: number;
+    private pool;
+    private emitters;
+    private behaviors;
+    private renderOptions;
+    private device;
+    private qualityMonitor;
+    private prng;
+    private canvas;
+    private gl2Renderer;
+    private sysState;
+    private activeBackend;
+    private fixedTimestep;
+    private substeps;
+    private timeAccumulator;
+    private lastTime;
+    private stepTimeMs;
+    private renderTimeMs;
+    private fps;
+    private frameCount;
+    private lastFpsTime;
+    constructor(config?: ParticleSystemConfig);
+    get state(): ParticleSystemState;
+    get particleCount(): number;
+    get backend(): ComputeBackendType | "canvas2d";
+    get metrics(): ParticleSystemMetrics;
+    start(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    reset(): void;
+    clear(): void;
+    burst(count: number, emitterIndexOrId?: number | string): number;
+    update(explicitDelta?: number): void;
+    render(canvas?: HTMLCanvasElement, context?: unknown): void;
+    addEmitter(emitter: ParticleEmitter | ParticleEmitterConfig): ParticleEmitter;
+    removeEmitter(emitterId: string): boolean;
+    addBehavior(behavior: ParticleBehavior): void;
+    removeBehavior(behaviorId: string): boolean;
+    getEmitters(): readonly ParticleEmitter[];
+    getBehaviors(): readonly ParticleBehavior[];
+    dispose(): void;
+}
+/**
+ * Creates and initializes a complete ParticleSystem instance.
+ */
+export declare function createParticleSystem(config?: ParticleSystemConfig): ParticleSystem;
+/**
+ * Appends a physical behavior to a ParticleSystem.
+ */
+export declare function addParticleBehavior(system: ParticleSystem, behavior: ParticleBehavior): void;
+/**
+ * Removes a behavior by ID from a ParticleSystem.
+ */
+export declare function removeParticleBehavior(system: ParticleSystem, behaviorId: string): boolean;
+/**
+ * Triggers an immediate burst of particles.
+ */
+export declare function emitParticles(system: ParticleSystem, count: number, emitterIndex?: number): void;
+/**
+ * Manually advances a ParticleSystem simulation by a delta time.
+ */
+export declare function updateParticleSystem(system: ParticleSystem, deltaTime?: number): void;
+/**
+ * Resets a ParticleSystem back to its initial zero-particle state.
+ */
+export declare function resetParticleSystem(system: ParticleSystem): void;
+/**
+ * Disposes of all resources allocated by a ParticleSystem.
+ */
+export declare function disposeParticleSystem(system: ParticleSystem): void;