af-motion 0.0.0-stage → 1.0.0

package/dist/core/device-capabilities/hardware.d.ts

@@ -0,0 +1,27 @@
+/**
+ * AF Motion — CPU, Memory, Display & Hardware Intelligence
+ *
+ * Safe probing of CPU cores, device memory, JS heap metrics, display characteristics,
+ * battery and network conditions with explicit status tracking and zero fabrication.
+ */
+import type { CpuCapabilityInfo, MemoryCapabilityInfo, DisplayCapabilityInfo, NetworkCapabilityInfo, BatteryCapabilityInfo, MockEnvironment } from "./types.js";
+/**
+ * Detects CPU capabilities: concurrency, WebAssembly, SharedArrayBuffer, and Worker support.
+ */
+export declare function detectCpuCapabilities(mockEnv?: MockEnvironment): CpuCapabilityInfo;
+/**
+ * Detects device memory and JavaScript heap metrics where exposed.
+ */
+export declare function detectMemoryCapabilities(mockEnv?: MockEnvironment): MemoryCapabilityInfo;
+/**
+ * Detects display metrics, pixel ratio, viewport boundaries, and accessibility preferences.
+ */
+export declare function detectDisplayCapabilities(mockEnv?: MockEnvironment): DisplayCapabilityInfo;
+/**
+ * Detects network connectivity and bandwidth indicators where available.
+ */
+export declare function detectNetworkCapabilities(mockEnv?: MockEnvironment): NetworkCapabilityInfo;
+/**
+ * Detects battery level and charging state if Battery Status API is available.
+ */
+export declare function detectBatteryCapabilities(mockEnv?: MockEnvironment): BatteryCapabilityInfo;

package/dist/core/device-capabilities/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AF Motion — Adaptive Performance Intelligence: Device Capability Detection
+ *
+ * Unified capability detection, runtime profiling, hardware estimation,
+ * multi-dimensional scoring, and event-driven live monitoring.
+ */
+export * from "./types.js";
+export * from "./runtime.js";
+export * from "./hardware.js";
+export * from "./graphics.js";
+export * from "./classification.js";
+export * from "./scoring.js";
+export * from "./detection.js";
+export * from "./monitor.js";

package/dist/core/device-capabilities/monitor.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AF Motion — Live Capability Monitoring
+ *
+ * Event-driven, zero-polling live listener infrastructure observing WebGL context loss,
+ * DPR changes, viewport resizing, visibility, reduced motion, and network events.
+ */
+import type { CapabilityChangeListener, CapabilitySubscription } from "./types.js";
+/**
+ * Subscribes to live capability changes and returns a subscription with an unsubscribe callback.
+ */
+export declare function subscribeToCapabilityChanges(listener: CapabilityChangeListener): CapabilitySubscription;
+/**
+ * Removes all active event listeners and clears subscriber registries.
+ */
+export declare function disposeCapabilityMonitor(): void;
+/**
+ * Checks whether active capability monitoring is currently running.
+ */
+export declare function isCapabilityMonitoringActive(): boolean;

package/dist/core/device-capabilities/react.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AF Motion — React Device Capability Hooks
+ *
+ * React 18 & 19 compatible hooks for accessing device profiles, graphics ceilings,
+ * and live capability changes with SSR safety and Strict Mode cleanup.
+ */
+import type { DeviceCapabilityProfile, DeviceDetectionOptions, CapabilityChangeListener } from "./types.js";
+import type { DetailedGraphicsReport } from "./graphics.js";
+/**
+ * React hook to retrieve the current device capability profile.
+ * SSR-safe: returns default initial profile on server, re-evaluates on client mount.
+ */
+export declare function useDeviceCapabilities(options?: DeviceDetectionOptions): DeviceCapabilityProfile;
+/**
+ * React hook specifically for WebGL/WebGPU graphics capabilities.
+ */
+export declare function useDetailedGraphicsCapabilities(options?: {
+    testCanvas?: HTMLCanvasElement | null;
+}): DetailedGraphicsReport;
+export { useDetailedGraphicsCapabilities as useGraphicsCapabilities };
+/**
+ * React hook to subscribe to live capability updates (e.g. orientation, reduced motion, network).
+ */
+export declare function useDeviceCapabilityChanges(onChange: CapabilityChangeListener): void;

package/dist/core/device-capabilities/runtime.d.ts

@@ -0,0 +1,11 @@
+/**
+ * AF Motion — Runtime Environment Detection
+ *
+ * Distinguishes Browser, Web Worker, Dedicated Worker, Node.js, and SSR contexts
+ * without executing browser globals during module evaluation.
+ */
+import type { RuntimeEnvironmentInfo, MockEnvironment } from "./types.js";
+/**
+ * Detects the runtime execution environment defensively.
+ */
+export declare function detectRuntimeEnvironment(mockEnv?: MockEnvironment): RuntimeEnvironmentInfo;

package/dist/core/device-capabilities/scoring.d.ts

@@ -0,0 +1,18 @@
+/**
+ * AF Motion — Multi-Dimensional Capability Scoring
+ *
+ * Computes deterministic, explainable 0–100 scores across CPU, Memory, GPU,
+ * Graphics Features, Worker, and Rendering dimensions with confidence levels and signals.
+ */
+import type { CapabilityScores, CpuCapabilityInfo, MemoryCapabilityInfo, WebGLCapabilitiesInfo, WebGPUCapabilitiesInfo, DisplayCapabilityInfo, RuntimeEnvironmentInfo } from "./types.js";
+/**
+ * Calculates multi-dimensional capability scores based on detected device characteristics.
+ */
+export declare function calculateCapabilityScores(profile: {
+    runtime: RuntimeEnvironmentInfo;
+    cpu: CpuCapabilityInfo;
+    memory: MemoryCapabilityInfo;
+    webgl: WebGLCapabilitiesInfo;
+    webgpu: WebGPUCapabilitiesInfo;
+    display: DisplayCapabilityInfo;
+}): CapabilityScores;

package/dist/core/device-capabilities/types.d.ts

@@ -0,0 +1,171 @@
+/**
+ * AF Motion — Device Capability Detection Types
+ *
+ * Strongly-typed contracts for hardware, browser, rendering, memory, and runtime profiling.
+ * Every field explicitly distinguishes between detected, estimated, unsupported,
+ * unavailable, and unknown status without hardware fabrication.
+ */
+import type { RendererBackend } from "../../graphics/types.js";
+export type DetectionStatus = "detected" | "estimated" | "unsupported" | "unavailable" | "unknown";
+export interface ValueWithStatus<T> {
+    readonly value: T;
+    readonly status: DetectionStatus;
+    readonly details?: string;
+}
+export type DeviceCategory = "low-end-mobile" | "standard-mobile" | "high-end-mobile" | "low-end-desktop" | "standard-desktop" | "high-end-desktop" | "tablet" | "unknown";
+export type RuntimeEnvironment = "browser" | "worker" | "dedicated-worker" | "offscreen-canvas" | "node" | "ssr" | "unknown";
+export interface CpuCapabilityInfo {
+    readonly concurrency: ValueWithStatus<number>;
+    readonly wasmSupported: ValueWithStatus<boolean>;
+    readonly sharedArrayBuffer: ValueWithStatus<boolean>;
+    readonly simdSupported: ValueWithStatus<boolean>;
+    readonly workerAvailable: ValueWithStatus<boolean>;
+}
+export interface MemoryCapabilityInfo {
+    readonly deviceMemoryGB: ValueWithStatus<number | null>;
+    readonly jsHeapLimitMB: ValueWithStatus<number | null>;
+    readonly totalJSHeapMB: ValueWithStatus<number | null>;
+    readonly usedJSHeapMB: ValueWithStatus<number | null>;
+}
+export interface RuntimeEnvironmentInfo {
+    readonly environment: ValueWithStatus<RuntimeEnvironment>;
+    readonly isBrowser: boolean;
+    readonly isWorker: boolean;
+    readonly isNode: boolean;
+    readonly isSSR: boolean;
+    readonly offscreenCanvasSupported: ValueWithStatus<boolean>;
+    readonly userAgent: ValueWithStatus<string>;
+    readonly platform: ValueWithStatus<string>;
+    readonly browserName: ValueWithStatus<string>;
+}
+export interface WebGLCapabilitiesInfo {
+    readonly webgl1: ValueWithStatus<boolean>;
+    readonly webgl2: ValueWithStatus<boolean>;
+    readonly maxTextureSize: ValueWithStatus<number>;
+    readonly maxCubeMapSize: ValueWithStatus<number>;
+    readonly maxRenderBufferSize: ValueWithStatus<number>;
+    readonly maxVertexAttributes: ValueWithStatus<number>;
+    readonly maxTextureUnits: ValueWithStatus<number>;
+    readonly maxUniformVectors: ValueWithStatus<number>;
+    readonly maxViewportDimensions: ValueWithStatus<readonly [number, number]>;
+    readonly shaderPrecision: ValueWithStatus<{
+        readonly highp: boolean;
+        readonly mediump: boolean;
+        readonly lowp: boolean;
+    }>;
+    readonly floatTextures: ValueWithStatus<boolean>;
+    readonly halfFloatTextures: ValueWithStatus<boolean>;
+    readonly instancing: ValueWithStatus<boolean>;
+    readonly timerQuery: ValueWithStatus<boolean>;
+    readonly maxAnisotropy: ValueWithStatus<number>;
+    readonly supportedExtensions: ValueWithStatus<readonly string[]>;
+    readonly unmaskedVendor: ValueWithStatus<string>;
+    readonly unmaskedRenderer: ValueWithStatus<string>;
+}
+export interface WebGPUCapabilitiesInfo {
+    readonly apiAvailable: ValueWithStatus<boolean>;
+    readonly adapterAvailable: ValueWithStatus<boolean>;
+    readonly deviceAvailable: ValueWithStatus<boolean>;
+    readonly computeShaderSupport: ValueWithStatus<boolean>;
+    readonly maxTextureDimension2D: ValueWithStatus<number>;
+    readonly maxBufferSize: ValueWithStatus<number>;
+    readonly features: ValueWithStatus<readonly string[]>;
+    readonly limits: ValueWithStatus<Readonly<Record<string, number>>>;
+    readonly architecture: ValueWithStatus<string>;
+}
+export interface DisplayCapabilityInfo {
+    readonly dpr: ValueWithStatus<number>;
+    readonly viewportWidth: ValueWithStatus<number>;
+    readonly viewportHeight: ValueWithStatus<number>;
+    readonly screenWidth: ValueWithStatus<number>;
+    readonly screenHeight: ValueWithStatus<number>;
+    readonly colorDepth: ValueWithStatus<number>;
+    readonly colorSpace: ValueWithStatus<"srgb" | "display-p3">;
+    readonly reducedMotion: ValueWithStatus<boolean>;
+    readonly reducedTransparency: ValueWithStatus<boolean>;
+    readonly highContrast: ValueWithStatus<boolean>;
+    readonly colorScheme: ValueWithStatus<"light" | "dark" | "unknown">;
+}
+export interface NetworkCapabilityInfo {
+    readonly online: ValueWithStatus<boolean>;
+    readonly effectiveType: ValueWithStatus<string>;
+    readonly downlinkMbps: ValueWithStatus<number | null>;
+    readonly rttMs: ValueWithStatus<number | null>;
+    readonly saveData: ValueWithStatus<boolean>;
+}
+export interface BatteryCapabilityInfo {
+    readonly charging: ValueWithStatus<boolean | null>;
+    readonly level: ValueWithStatus<number | null>;
+    readonly chargingTime: ValueWithStatus<number | null>;
+    readonly dischargingTime: ValueWithStatus<number | null>;
+}
+export interface DimensionScore {
+    readonly score: number;
+    readonly confidence: "high" | "medium" | "low";
+    readonly supportingSignals: readonly string[];
+    readonly missingInformation: readonly string[];
+    readonly rationale: string;
+}
+export interface CapabilityScores {
+    readonly cpu: DimensionScore;
+    readonly memory: DimensionScore;
+    readonly gpu: DimensionScore;
+    readonly graphicsFeatures: DimensionScore;
+    readonly worker: DimensionScore;
+    readonly rendering: DimensionScore;
+    readonly overallScore: number;
+}
+export interface DeviceCapabilityProfile {
+    readonly version: string;
+    readonly category: DeviceCategory;
+    readonly categoryRationale: string;
+    readonly scores: CapabilityScores;
+    readonly runtime: RuntimeEnvironmentInfo;
+    readonly cpu: CpuCapabilityInfo;
+    readonly memory: MemoryCapabilityInfo;
+    readonly webgl: WebGLCapabilitiesInfo;
+    readonly webgpu: WebGPUCapabilitiesInfo;
+    readonly supportedGraphicsBackends: readonly RendererBackend[];
+    readonly activeGraphicsBackend: RendererBackend;
+    readonly display: DisplayCapabilityInfo;
+    readonly network: NetworkCapabilityInfo;
+    readonly battery: BatteryCapabilityInfo;
+    readonly detectedAt: number;
+}
+export interface MockEnvironment {
+    isBrowser?: boolean;
+    isWorker?: boolean;
+    isNode?: boolean;
+    isSSR?: boolean;
+    userAgent?: string;
+    platform?: string;
+    hardwareConcurrency?: number;
+    deviceMemory?: number;
+    webgl1?: boolean;
+    webgl2?: boolean;
+    webgpu?: boolean;
+    maxTextureSize?: number;
+    dpr?: number;
+    reducedMotion?: boolean;
+    online?: boolean;
+    effectiveType?: string;
+    saveData?: boolean;
+    batteryCharging?: boolean;
+    batteryLevel?: number;
+    jsHeapSizeLimit?: number;
+    totalJSHeapSize?: number;
+    usedJSHeapSize?: number;
+    sharedArrayBuffer?: boolean;
+}
+export interface DeviceDetectionOptions {
+    readonly forceRefresh?: boolean;
+    readonly mockEnvironment?: MockEnvironment;
+    readonly testCanvas?: HTMLCanvasElement | null;
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    readonly asyncProbes?: boolean;
+}
+export type CapabilityChangeListener = (profile: DeviceCapabilityProfile, changedKeys: readonly string[]) => void;
+export interface CapabilitySubscription {
+    unsubscribe(): void;
+}

package/dist/core/effect-composer.d.ts

@@ -0,0 +1,41 @@
+import { type AdaptiveMotionConditions } from "./adaptive-motion.js";
+import type { MotionDNA, MotionDNAOverrides } from "./motion-dna.js";
+export type EffectCompositionInstance = {
+    destroy(): void;
+    pause?(): void;
+    resume?(): void;
+} | {
+    cancel(): void;
+    pause?(): void;
+    resume?(): void;
+};
+export interface EffectCompositionEntry {
+    /** Starts an effect and returns its native cleanup controls. */
+    start: () => EffectCompositionInstance;
+    /** Effects without this field receive no Motion DNA options. */
+    motionDNA?: never;
+}
+export interface MotionDNACompositionEntry {
+    /** Starts an effect with resolved animation options from the named Motion DNA. */
+    start: (options: MotionDNA) => EffectCompositionInstance;
+    motionDNA: {
+        name: string;
+        overrides?: MotionDNAOverrides;
+    };
+    adaptive?: boolean | AdaptiveMotionConditions;
+}
+export type ComposableEffect = EffectCompositionEntry | MotionDNACompositionEntry | (() => EffectCompositionInstance) | EffectCompositionInstance;
+export interface EffectCompositionControls {
+    /** Cleans up every effect in reverse start order. Safe to call repeatedly. */
+    destroy(): void;
+    /** Alias for destroy(). */
+    cancel(): void;
+    /** Pauses effects that expose a pause control; other effects continue unchanged. */
+    pause(): void;
+    /** Resumes effects that expose a resume control. */
+    resume(): void;
+    /** Composed effect instances in start order. */
+    readonly effects: readonly EffectCompositionInstance[];
+}
+/** Starts an ordered set of compatible effects and owns their shared cleanup. */
+export declare function composeEffects(entries: readonly ComposableEffect[]): EffectCompositionControls;

package/dist/core/generation-pipeline.d.ts

@@ -0,0 +1,135 @@
+/**
+ * AF Motion AI Generation Pipeline & React Integration Core
+ *
+ * Framework-independent pipeline that unifies design intelligence, natural-language
+ * motion interpretation, composition, schema validation, and automatic correction
+ * into an automated, deterministic generation workflow.
+ *
+ * Pipeline Flow:
+ * Natural Language → Design Interpretation → Motion Interpretation → Composition → Validation → Correction → Generation Result
+ */
+import type { AIMotionRegistry } from "./ai-motion-registry.js";
+import { type CompositionTree, type CompositionValidationResult, type MotionComposition } from "./composition.js";
+import { type CompositionCorrectionResult } from "./configuration-corrector.js";
+import { type DesignContext, type DesignInterpretationResult } from "./design-intelligence.js";
+import { type MotionInterpretationResult, type MotionSpecification } from "./natural-motion.js";
+export declare const PIPELINE_VERSION = "1.0.0";
+export type GenerationStage = "idle" | "interpreting_design" | "interpreting_motion" | "resolving_capabilities" | "building_composition" | "validating" | "correcting" | "generating_react" | "complete" | "failed" | "cancelled";
+export type GenerationSceneType = "hero" | "card-grid" | "cards-grid" | "interactive-button" | "scroll-section" | "background-effect" | "landing-page" | "feature-showcase" | "modal-dialog" | "custom";
+export interface GenerationRequest {
+    /** Natural-language description of website, page, or animation request. */
+    readonly prompt: string;
+    /** Optional pre-configured or partial design context. */
+    readonly designContext?: Partial<DesignContext>;
+    /** Optional motion prompt if separate from design prompt. */
+    readonly motionPrompt?: string;
+    /** Target framework. Defaults to "react". */
+    readonly targetFramework?: "react" | "vanilla";
+    /** Optional explicit scene type hint. */
+    readonly sceneType?: GenerationSceneType;
+    /** Optional target element or container selector. */
+    readonly targetSelector?: string;
+    /** Optional background capability preference. */
+    readonly backgroundCapability?: string;
+    /** Optional Motion DNA identifier. */
+    readonly motionDNA?: string;
+    /** Optional Design System identifier. */
+    readonly designSystem?: string;
+    /** Optional Palette ID. */
+    readonly paletteId?: string;
+    /** Custom metadata. */
+    readonly metadata?: Record<string, unknown>;
+}
+export interface GenerationOptions {
+    /** Custom AIMotionRegistry instance. Defaults to global registry. */
+    readonly registry?: AIMotionRegistry;
+    /** Strict mode: never auto-apply corrections that could alter intent. */
+    readonly strictMode?: boolean;
+    /** Whether to allow removal of unsupported properties during correction. */
+    readonly allowUnsupportedRemoval?: boolean;
+    /** Whether to auto-correct validation issues when safe. Defaults to true. */
+    readonly autoCorrect?: boolean;
+    /** Abort signal for cancellation. */
+    readonly signal?: AbortSignal;
+    /** Progress callback invoked at each stage. */
+    readonly onProgress?: (stage: GenerationStage, progress: number, message: string) => void;
+    /** Minimum confidence threshold [0-1] for interpretation. Defaults to 0.4. */
+    readonly minConfidence?: number;
+    /** Fallback background capability if none specified or inferred. */
+    readonly fallbackBackground?: string;
+}
+export interface GenerationContext {
+    readonly request: GenerationRequest;
+    readonly options: GenerationOptions;
+    readonly timestamp: number;
+    readonly designContext?: DesignContext;
+    readonly motionSpec?: MotionSpecification;
+    readonly resolvedCapabilityIds: readonly string[];
+}
+export interface ReactHierarchyNode {
+    readonly id: string;
+    readonly name: string;
+    readonly type: string;
+    readonly capabilityId?: string;
+    readonly selector?: string;
+    readonly parentId?: string;
+    readonly children: readonly string[];
+}
+export interface ReactIntegrationOutput {
+    /** Suggested React JSX / TSX code snippet or template. */
+    readonly componentCode: string;
+    /** Modules and named imports required from "af-motion" and "af-motion/react". */
+    readonly requiredImports: ReadonlyArray<{
+        readonly module: "af-motion" | "af-motion/react";
+        readonly namedImports: readonly string[];
+    }>;
+    /** AF Motion API references utilized (e.g. ['useComposition', 'useInView']). */
+    readonly apiReferences: readonly string[];
+    /** Component tree hierarchy for React rendering. */
+    readonly componentHierarchy: readonly ReactHierarchyNode[];
+    /** Plain English integration steps and guidelines for developers. */
+    readonly integrationInstructions: readonly string[];
+}
+export interface GenerationDiagnostics {
+    readonly durationMs: number;
+    readonly completedStages: readonly GenerationStage[];
+    readonly warnings: readonly string[];
+    readonly designConfidence: number;
+    readonly motionConfidence: number;
+    readonly issuesCount: number;
+    readonly correctionsCount: number;
+    readonly stageTimings: Readonly<Record<string, number>>;
+}
+export interface GenerationError {
+    readonly stage: GenerationStage;
+    readonly message: string;
+    readonly code: string;
+    readonly details?: unknown;
+}
+export interface GenerationResult {
+    readonly success: boolean;
+    readonly cancelled: boolean;
+    readonly stage: GenerationStage;
+    readonly sceneType?: GenerationSceneType;
+    readonly request: GenerationRequest;
+    readonly context: GenerationContext;
+    readonly designInterpretation?: DesignInterpretationResult;
+    readonly motionInterpretation?: MotionInterpretationResult;
+    readonly composition?: MotionComposition;
+    readonly compositionTree?: CompositionTree;
+    readonly validation?: CompositionValidationResult;
+    readonly correction?: CompositionCorrectionResult;
+    readonly reactOutput?: ReactIntegrationOutput;
+    readonly diagnostics: GenerationDiagnostics;
+    readonly error?: GenerationError;
+}
+export declare function setGenerationPipelineRegistryResolver(resolver: () => AIMotionRegistry | undefined): void;
+export declare function getEffectiveGenerationRegistry(options?: GenerationOptions): AIMotionRegistry | undefined;
+/**
+ * Synchronous core generation function.
+ */
+export declare function generateMotionSync(request: GenerationRequest, options?: GenerationOptions): GenerationResult;
+/**
+ * Asynchronous generation API supporting cancellation and progress updates across ticks.
+ */
+export declare function generateMotion(request: GenerationRequest, options?: GenerationOptions): Promise<GenerationResult>;

package/dist/core/inertia.d.ts

@@ -0,0 +1,30 @@
+export interface InertiaOptions {
+    /** Starting position. Defaults to 0. */
+    from?: number;
+    /** Initial velocity in position units per second. Defaults to 1000. */
+    initialVelocity?: number;
+    /** Exponential velocity decay per second. Must be finite and > 0. Defaults to 8. */
+    friction?: number;
+    /** Minimum speed in position units per second at which motion settles. Defaults to 10. */
+    minVelocity?: number;
+    /** Optional lower position bound. */
+    min?: number;
+    /** Optional upper position bound. */
+    max?: number;
+    /** Called on each shared animation frame with position and velocity. */
+    onUpdate: (state: InertiaUpdate) => void;
+    /** Called once when velocity settles, a bound is reached, or reduced motion completes. */
+    onComplete?: () => void;
+    /** Defaults to true. */
+    respectReducedMotion?: boolean;
+}
+export interface InertiaUpdate {
+    position: number;
+    velocity: number;
+}
+export interface InertiaControls {
+    /** Stops the inertia motion and suppresses subsequent update and completion callbacks. */
+    cancel(): void;
+}
+/** Animates position using exponentially decaying velocity on the shared frame scheduler. */
+export declare function animateInertia(options: InertiaOptions): InertiaControls;

package/dist/core/interactions/cursor-controller.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion Cursor Controller
+ *
+ * Configurable, high-performance cursor intelligence system supporting custom cursor visuals,
+ * smoothing, lag/delayed tracking, velocity, acceleration, direction, hover detection,
+ * proximity sensing, visibility controls, and touch graceful fallback.
+ */
+import type { CursorController, CursorControllerOptions } from "./types.js";
+export declare function createCursorController(element?: HTMLElement | null, options?: CursorControllerOptions): CursorController;

package/dist/core/interactions/custom-gestures.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AF Motion Custom Gesture Definition Registry
+ *
+ * Declarative registration and validation of custom user-defined gestures and built-in templates.
+ */
+import type { CustomGestureDefinition } from "./types.js";
+export declare const BUILT_IN_GESTURE_DEFINITIONS: readonly CustomGestureDefinition[];
+/**
+ * Registers a custom gesture definition.
+ * Returns an unregister function.
+ */
+export declare function registerGesture(definition: CustomGestureDefinition): () => void;
+/**
+ * Unregisters a gesture by its unique identifier.
+ */
+export declare function unregisterGesture(id: string): boolean;
+/**
+ * Returns all currently registered gesture definitions.
+ */
+export declare function getRegisteredGestures(): readonly CustomGestureDefinition[];
+/**
+ * Retrieves a registered gesture definition by id.
+ */
+export declare function getGestureDefinition(id: string): CustomGestureDefinition | undefined;
+/**
+ * Clears custom gestures, restoring defaults.
+ */
+export declare function resetGestureRegistry(): void;

package/dist/core/interactions/device-capabilities.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AF Motion Device Capability Detection
+ *
+ * Detects pointer support, touch capability, maximum touch points,
+ * hover capabilities, and primary input hardware.
+ */
+import type { DeviceCapabilities } from "./types.js";
+/**
+ * Inspects browser environment and media queries to determine input capabilities.
+ * Safe for server-side rendering (SSR).
+ */
+export declare function getDeviceCapabilities(): DeviceCapabilities;

package/dist/core/interactions/drag-controller.d.ts

@@ -0,0 +1,60 @@
+/**
+ * AF Motion Advanced Drag Engine
+ *
+ * Framework-independent controller supporting element dragging, axis locking,
+ * elastic boundaries, snap-to-grid, snap points, momentum continuation,
+ * keyboard accessibility, nested draggable isolation, and composable transforms.
+ */
+import type { AdvancedDragControls, AdvancedDragOptions, AdvancedDragState, DragPosition } from "./types.js";
+export declare class AdvancedDragEngine implements AdvancedDragControls {
+    readonly target: HTMLElement;
+    private readonly options;
+    private readonly tracker;
+    private position;
+    private startPosition;
+    private startPointerPoint;
+    private offset;
+    private delta;
+    private velocity;
+    private isDraggingState;
+    private isSnappingState;
+    private activePointerId;
+    private activePointerType;
+    private lockedAxis;
+    private delayTimer;
+    private pendingPointerEvent;
+    private inertiaControlsX;
+    private inertiaControlsY;
+    private springControlsX;
+    private springControlsY;
+    private boundListeners;
+    private isDestroyed;
+    constructor(target: HTMLElement, options?: AdvancedDragOptions);
+    getState(): AdvancedDragState;
+    getPosition(): DragPosition;
+    setPosition(pos: Partial<DragPosition>): void;
+    isDragging(): boolean;
+    cancel(): void;
+    reset(): void;
+    destroy(): void;
+    private attach;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private handleKeyDown;
+    private beginDrag;
+    private updateDrag;
+    private computeConstrainedPosition;
+    private endDrag;
+    private springBackToBounds;
+    private getResolvedBounds;
+    private render;
+    private removeTransform;
+    private clearTimers;
+    private stopMomentum;
+}
+/**
+ * Creates and attaches an Advanced Drag Controller to an element.
+ */
+export declare function createDragController(target: HTMLElement, options?: AdvancedDragOptions): AdvancedDragControls;

package/dist/core/interactions/errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AF Motion Universal Interaction & Gestures — Structured Errors
+ */
+export declare class InteractionError extends Error {
+    readonly code: string;
+    constructor(message: string, code?: string);
+}
+export declare class GestureConfigurationError extends InteractionError {
+    constructor(message: string);
+}
+export declare class InteractionLifecycleError extends InteractionError {
+    constructor(message: string);
+}