af-motion 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,43 @@
+/**
+ * AF Motion 3D Material Intelligence Contracts
+ */
+import type { MaterialSpec } from "../schemas/types.js";
+export type Material3DPresetName = "chrome" | "gold" | "frosted-glass" | "clear-glass" | "matte-plastic" | "glossy-plastic" | "velvet" | "neon-glow";
+export interface Standard3DMaterialSpec extends MaterialSpec {
+    readonly type: "standard" | "physical";
+    readonly emissive?: string;
+    readonly emissiveIntensity?: number;
+    readonly clearcoat?: number;
+    readonly clearcoatRoughness?: number;
+}
+export interface Glass3DMaterialSpec extends MaterialSpec {
+    readonly type: "physical";
+    readonly transmission: number;
+    readonly ior: number;
+    readonly thickness?: number;
+    readonly dispersion?: number;
+    readonly attenuationColor?: string;
+    readonly attenuationDistance?: number;
+}
+export interface Fabric3DMaterialSpec extends MaterialSpec {
+    readonly type: "physical";
+    readonly sheen?: number;
+    readonly sheenColor?: string;
+    readonly sheenRoughness?: number;
+}
+export interface Emissive3DMaterialSpec extends MaterialSpec {
+    readonly type: "basic" | "standard";
+    readonly emissive: string;
+    readonly emissiveIntensity: number;
+}
+export interface IntelligentMaterial3DConfig extends MaterialSpec {
+    readonly preset?: Material3DPresetName;
+    readonly emissive?: string;
+    readonly emissiveIntensity?: number;
+    readonly clearcoat?: number;
+    readonly clearcoatRoughness?: number;
+    readonly sheen?: number;
+    readonly sheenColor?: string;
+    readonly thickness?: number;
+    readonly dispersion?: number;
+}

package/dist/3d/materials/validation.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion 3D Material Validation & Safe Correction
+ */
+import type { IntelligentMaterial3DConfig } from "./types.js";
+export declare function validateMaterial3D(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+export declare function correctMaterial3D(raw: unknown): IntelligentMaterial3DConfig;

package/dist/3d/morphing/animator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AF Motion — 3D Morph Animation Orchestrator
+ *
+ * Drives frame-scheduled 3D geometry transformations with RAF integration,
+ * dynamic retargeting, reversible playback, and physics bounds synchronization.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+import type { Morph3DAnimationOptions, MorphController3D, MorphGeometry3D, MorphTarget3D, MorphSequenceItem, MorphSequenceOptions } from "./types.js";
+type AnyMesh = Mesh3DData | GeometryBufferData;
+/**
+ * Animates a 3D geometry from base shape to destination target(s).
+ */
+export declare function morph3D(base: AnyMesh | MorphGeometry3D, targetOrTargets: AnyMesh | MorphTarget3D | Array<AnyMesh | MorphTarget3D>, options?: Morph3DAnimationOptions): MorphController3D;
+/**
+ * Creates and executes a multi-step sequential morph animation across multiple targets.
+ */
+export declare function createMorphSequence(base: AnyMesh, sequence: MorphSequenceItem[], options?: MorphSequenceOptions): MorphController3D;
+export {};

package/dist/3d/morphing/correspondence.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AF Motion — 3D Vertex Correspondence & Resampling
+ *
+ * Establishes geometric correspondence between models of differing topology,
+ * handles spatial normalization, and enables deterministic resampling.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+import type { CorrespondenceConfig, VertexCorrespondenceMap } from "./types.js";
+type AnyMesh = Mesh3DData | GeometryBufferData;
+/**
+ * Centers a flat positions buffer around origin [0, 0, 0].
+ */
+export declare function alignGeometryCenter(positions: Float32Array): Float32Array;
+/**
+ * Normalizes positions to fit within a unit or target-scaled bounding sphere/cube.
+ */
+export declare function normalizeGeometryBounds(positions: Float32Array, targetScale?: number): {
+    normalized: Float32Array;
+    scale: number;
+    center: [number, number, number];
+};
+/**
+ * Maps vertex correspondence from base geometry to target geometry using configurable strategies.
+ */
+export declare function mapVertexCorrespondence(base: AnyMesh, target: AnyMesh, config?: CorrespondenceConfig): VertexCorrespondenceMap;
+/**
+ * Resamples an incompatible 3D mesh to exactly match a target vertex count,
+ * generating continuous surface samples using face area weighting.
+ */
+export declare function resampleGeometry(source: AnyMesh, targetVertexCount: number): Mesh3DData;
+export {};

package/dist/3d/morphing/geometry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * AF Motion — 3D Morph Geometry Lifecycle & Target Management
+ *
+ * Manages morphable 3D geometry objects, target registrations, scratch buffer pools,
+ * and seamless correspondence normalization.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+import type { MorphGeometry3D, MorphTarget3D } from "./types.js";
+type AnyMesh = Mesh3DData | GeometryBufferData;
+/**
+ * Creates a managed MorphGeometry3D container with pre-allocated scratch buffers.
+ */
+export declare function createMorphGeometry(base: AnyMesh, targets?: Array<AnyMesh | MorphTarget3D>): MorphGeometry3D;
+/**
+ * Registers an additional morph target into a MorphGeometry3D container.
+ * Automatically aligns and resamples geometry if vertex counts do not match.
+ */
+export declare function addMorphTarget(morphGeometry: MorphGeometry3D, targetInput: AnyMesh | MorphTarget3D, fallbackId?: string): MorphTarget3D;
+/**
+ * Removes a morph target by its identifier.
+ */
+export declare function removeMorphTarget(morphGeometry: MorphGeometry3D, targetId: string): boolean;
+/**
+ * Finds a registered morph target by its identifier.
+ */
+export declare function getMorphTarget(morphGeometry: MorphGeometry3D, targetId: string): MorphTarget3D | undefined;
+export {};

package/dist/3d/morphing/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AF Motion — 3D Morphing & Cross-System Integration Module
+ *
+ * Dedicated framework-independent 3D morphing engine providing deterministic
+ * geometry transitions, blend shapes, topology correspondence, procedural presets,
+ * and animation lifecycle orchestration.
+ */
+export * from "./types.js";
+export * from "./validation.js";
+export * from "./geometry.js";
+export * from "./topology.js";
+export * from "./interpolation.js";
+export * from "./correspondence.js";
+export * from "./morph.js";
+export * from "./animator.js";
+export * from "./presets.js";

package/dist/3d/morphing/interpolation.d.ts

@@ -0,0 +1,45 @@
+/**
+ * AF Motion — 3D Morph Interpolation Engine
+ *
+ * High-performance, allocation-free mathematical interpolation for 3D vertex positions,
+ * surface normals, UV maps, vertex colors, and multi-target blend weights.
+ */
+import type { MorphInterpolationMode } from "./types.js";
+/**
+ * Standard linear interpolation.
+ */
+export declare function lerp(a: number, b: number, t: number): number;
+/**
+ * Smoothstep Hermite curve interpolation.
+ */
+export declare function smoothstep(t: number): number;
+/**
+ * Cubic ease-in-out curve.
+ */
+export declare function cubicEaseInOut(t: number): number;
+/**
+ * Resolves normalized interpolation factor according to selected interpolation mode.
+ */
+export declare function resolveInterpolationFactor(progress: number, mode?: MorphInterpolationMode): number;
+/**
+ * Interpolates two Float32Array buffers in-place into an output buffer.
+ */
+export declare function interpolateBuffer(base: Float32Array, target: Float32Array, progress: number, out: Float32Array, options?: {
+    isNormal?: boolean;
+    clampProgress?: boolean;
+}): void;
+/**
+ * Blends multiple target buffers against a base buffer using arbitrary weights.
+ *
+ * Supports additive relative targets:
+ *   P = P_base + sum(w_i * delta_i)
+ * as well as absolute targets:
+ *   P = P_base + sum(w_i * (P_i - P_base))
+ */
+export declare function blendMultipleBuffers(base: Float32Array, targets: Array<{
+    buffer: Float32Array;
+    weight: number;
+    relative?: boolean;
+}>, out: Float32Array, options?: {
+    isNormal?: boolean;
+}): void;

package/dist/3d/morphing/morph.d.ts

@@ -0,0 +1,18 @@
+/**
+ * AF Motion — 3D Morph Evaluation Engine
+ *
+ * Deterministic computation and evaluation of blend shape weights,
+ * generating in-place mutated or cloned 3D meshes with updated bounding boxes.
+ */
+import type { BoundingBox3D } from "../schemas/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+import type { MorphGeometry3D, MorphEvaluationOptions } from "./types.js";
+/**
+ * Computes bounding box dimensions from a flat positions buffer.
+ */
+export declare function computeMorphBoundingBox(positions: Float32Array): BoundingBox3D;
+/**
+ * Evaluates the morph state at a given progress [0..1] or arbitrary target weights record.
+ * Mutates morphGeometry.currentMesh in-place with zero memory allocation.
+ */
+export declare function evaluateMorph(morphGeometry: MorphGeometry3D, progressOrWeights: number | Record<string, number>, options?: MorphEvaluationOptions): Mesh3DData;

package/dist/3d/morphing/presets.d.ts

@@ -0,0 +1,31 @@
+/**
+ * AF Motion — 3D Morph Presets
+ *
+ * Pre-configured procedural geometric morph pairings (Sphere <-> Box, Torus <-> Sphere, etc.)
+ * with matched topology, normalized bounding dimensions, and smooth vertex transitions.
+ */
+import type { MorphGeometry3D } from "./types.js";
+/**
+ * Creates a normalized Sphere to Box morph geometry.
+ */
+export declare function createSphereToBoxMorph(subdivisions?: number): MorphGeometry3D;
+/**
+ * Creates a normalized Box to Sphere morph geometry.
+ */
+export declare function createCubeToSphereMorph(subdivisions?: number): MorphGeometry3D;
+/**
+ * Creates a Torus to Sphere morph geometry.
+ */
+export declare function createTorusToSphereMorph(radialSegments?: number, tubularSegments?: number): MorphGeometry3D;
+/**
+ * Creates a Cylinder to Cone morph geometry.
+ */
+export declare function createCylinderToConeMorph(radialSegments?: number): MorphGeometry3D;
+/**
+ * Creates a Plane to Wave morph geometry.
+ */
+export declare function createPlaneToWaveMorph(widthSegments?: number, heightSegments?: number, amplitude?: number): MorphGeometry3D;
+/**
+ * Lists all available built-in 3D morph presets.
+ */
+export declare function listMorphPresets(): string[];

package/dist/3d/morphing/react.d.ts

@@ -0,0 +1,29 @@
+/**
+ * AF Motion — React 3D Morph Hook
+ *
+ * Declarative React hook for driving 3D morph animations, managing RAF frame lifecycle,
+ * and binding dynamic morph states to React Three Fiber or custom 3D canvases.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+import type { Morph3DAnimationOptions, MorphController3D, MorphGeometry3D, MorphTarget3D } from "./types.js";
+type AnyMesh = Mesh3DData | GeometryBufferData;
+export interface Use3DMorphResult {
+    mesh: Mesh3DData | null;
+    progress: number;
+    isPlaying: boolean;
+    isPaused: boolean;
+    controller: MorphController3D | null;
+    seek: (progress: number) => void;
+    pause: () => void;
+    resume: () => void;
+    reverse: () => void;
+    play: () => void;
+    retarget: (newTarget: AnyMesh, transitionDuration?: number) => void;
+    setTargetWeight: (targetId: string, weight: number) => void;
+}
+/**
+ * React hook to animate a 3D geometry between morph targets with lifecycle management.
+ */
+export declare function use3DMorph(base: AnyMesh | MorphGeometry3D, targetOrTargets: AnyMesh | MorphTarget3D | Array<AnyMesh | MorphTarget3D>, options?: Morph3DAnimationOptions): Use3DMorphResult;
+export {};

package/dist/3d/morphing/topology.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AF Motion — 3D Topology Analysis & Consistency
+ *
+ * Inspects geometric manifold topology, verifies vertex and index connectivity,
+ * and harmonizes winding orders for cross-model morph stability.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+type AnyMesh = Mesh3DData | GeometryBufferData;
+export interface TopologyStats {
+    vertexCount: number;
+    triangleCount: number;
+    indexed: boolean;
+    indexCount: number;
+    isClosedManifold: boolean;
+    sharedEdgeCount: number;
+    boundaryEdgeCount: number;
+}
+/**
+ * Computes topological statistics of a 3D geometry buffer.
+ */
+export declare function computeTopologyStats(mesh: AnyMesh): TopologyStats;
+/**
+ * Compares topological structure between two geometries.
+ */
+export declare function compareTopology(meshA: AnyMesh, meshB: AnyMesh): {
+    identical: boolean;
+    vertexCountMatch: boolean;
+    triangleCountMatch: boolean;
+    indicesMatch: boolean;
+    statsA: TopologyStats;
+    statsB: TopologyStats;
+};
+export {};

package/dist/3d/morphing/types.d.ts

@@ -0,0 +1,138 @@
+/**
+ * AF Motion — 3D Morphing Engine Types
+ *
+ * Strongly-typed definitions for 3D geometric morphing, blend shapes,
+ * vertex correspondence, multi-target interpolation, and cross-system orchestration.
+ */
+import type { EasingOption } from "../../easing/easings.js";
+import type { BoundingBox3D } from "../schemas/types.js";
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+export type MorphableAttributeType = "positions" | "normals" | "uvs" | "colors" | "custom";
+export interface MorphTarget3D {
+    id: string;
+    name?: string;
+    positions: Float32Array;
+    normals?: Float32Array;
+    uvs?: Float32Array;
+    colors?: Float32Array;
+    customAttributes?: Record<string, Float32Array>;
+    /** Weight in range [0, 1] or arbitrary relative factor. Default: 0. */
+    weight?: number;
+    /** Whether the target offsets are relative to base or absolute world coordinates. Default: false (absolute). */
+    relative?: boolean;
+}
+export interface MorphGeometry3D {
+    id: string;
+    name?: string;
+    base: Mesh3DData;
+    targets: MorphTarget3D[];
+    indices?: Uint16Array | Uint32Array;
+    vertexCount: number;
+    triangleCount: number;
+    /** Reusable current evaluated geometry buffer to prevent GC allocations. */
+    currentMesh: Mesh3DData;
+    /** Pre-allocated scratch buffers for zero-allocation blend evaluation. */
+    scratchPositions: Float32Array;
+    scratchNormals?: Float32Array;
+    scratchUvs?: Float32Array;
+    scratchColors?: Float32Array;
+}
+export interface MorphCompatibilityReport {
+    isCompatible: boolean;
+    canResample: boolean;
+    vertexCountMatch: boolean;
+    baseVertexCount: number;
+    targetVertexCount: number;
+    topologyMatch: boolean;
+    hasIndices: boolean;
+    hasNormals: boolean;
+    hasUVs: boolean;
+    hasColors: boolean;
+    missingAttributes: string[];
+    warnings: string[];
+    errors: string[];
+}
+export type CorrespondenceStrategy = "index" | "nearest-neighbor" | "barycentric" | "polar" | "resample";
+export interface CorrespondenceConfig {
+    strategy?: CorrespondenceStrategy;
+    tolerance?: number;
+    normalizeBounds?: boolean;
+    alignCenter?: boolean;
+}
+export interface VertexCorrespondenceMap {
+    /** Array of length baseVertexCount mapping to target vertex indices or fractional weights */
+    sourceToTargetIndices: Int32Array;
+    weights?: Float32Array;
+    strategyUsed: CorrespondenceStrategy;
+    confidence: number;
+}
+export type MorphInterpolationMode = "linear" | "smoothstep" | "cubic" | "spring";
+export interface MorphState3D {
+    progress: number;
+    mesh: Mesh3DData;
+    targetWeights: Record<string, number>;
+    isPlaying: boolean;
+    isPaused: boolean;
+    boundingBox: BoundingBox3D;
+    timestamp: number;
+}
+export interface MorphEvaluationOptions {
+    normalizeNormals?: boolean;
+    clampProgress?: boolean;
+    interpolationMode?: MorphInterpolationMode;
+    attributeWeights?: Partial<Record<MorphableAttributeType, number>>;
+}
+export interface Morph3DAnimationOptions {
+    duration?: number;
+    delay?: number;
+    easing?: EasingOption;
+    interpolationMode?: MorphInterpolationMode;
+    normalizeBounds?: boolean;
+    alignCenter?: boolean;
+    correspondenceStrategy?: CorrespondenceStrategy;
+    repeat?: number;
+    yoyo?: boolean;
+    playbackRate?: number;
+    respectReducedMotion?: boolean;
+    /** Callback fired before first tick */
+    onStart?: () => void;
+    /** Callback on each frame update */
+    onUpdate?: (progress: number, state: MorphState3D) => void;
+    /** Callback on animation completion */
+    onComplete?: () => void;
+    /** Callback if animation is cancelled */
+    onCancel?: () => void;
+    /** Optional physics callback for refitting colliders / bounds */
+    onGeometryChanged?: (mesh: Mesh3DData, bounds: BoundingBox3D) => void;
+}
+export type MorphAnimationOptions3D = Morph3DAnimationOptions;
+export interface MorphController3D {
+    seek(progress: number): void;
+    pause(): void;
+    resume(): void;
+    reverse(): void;
+    play(): void;
+    setPlaybackRate(rate: number): void;
+    getPlaybackRate(): number;
+    setTargetWeight(targetId: string, weight: number): void;
+    setTargetWeights(weights: Record<string, number>): void;
+    retarget(newTarget: Mesh3DData | GeometryBufferData, transitionDuration?: number): void;
+    cancel(): void;
+    destroy(): void;
+    getState(): MorphState3D;
+    interpolate(progress: number): Mesh3DData;
+}
+export interface MorphSequenceItem {
+    target: Mesh3DData | GeometryBufferData | string;
+    duration?: number;
+    delay?: number;
+    easing?: EasingOption;
+}
+export interface MorphSequenceOptions {
+    loop?: boolean;
+    yoyo?: boolean;
+    playbackRate?: number;
+    onSequenceComplete?: () => void;
+    onStepComplete?: (stepIndex: number) => void;
+}

package/dist/3d/morphing/validation.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AF Motion — 3D Morph Compatibility & Validation
+ *
+ * Diagnostics and compatibility analysis ensuring numerical stability,
+ * topology consistency, and graceful fallback paths during 3D morphing.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData } from "../optimization/types.js";
+import type { MorphCompatibilityReport } from "./types.js";
+type AnyMesh = Mesh3DData | GeometryBufferData;
+/**
+ * Analyzes compatibility between a base 3D geometry and a destination target.
+ */
+export declare function analyzeMorphCompatibility(base: AnyMesh, target: AnyMesh): MorphCompatibilityReport;
+/**
+ * Validates multiple morph targets against a base geometry.
+ */
+export declare function validateMorphTargets(base: AnyMesh, targets: AnyMesh[]): MorphCompatibilityReport;
+export {};

package/dist/3d/optimization/analysis.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AF Motion — 3D Model Analysis & Inspection Engine
+ *
+ * Comprehensive inspection of 3D model geometry, bounds, hierarchy,
+ * textures, materials, degenerate triangles, normal fidelity, and VRAM memory.
+ */
+import type { ModelAnalysisReport } from "./types.js";
+/**
+ * Inspects and analyzes a 3D model, mesh, or scene graph, producing an in-depth audit report.
+ */
+export declare function analyzeModel3D(model: unknown, options?: {
+    checkNormals?: boolean;
+    checkDegenerates?: boolean;
+}): ModelAnalysisReport;

package/dist/3d/optimization/colliders.d.ts

@@ -0,0 +1,16 @@
+/**
+ * AF Motion — 3D Automatic Collider Generation & Physics Fitting
+ *
+ * Recommends and generates optimal 3D physics colliders (Box, Sphere, Capsule, Convex)
+ * based on geometric principal extents, aspect ratios, and computational budgets.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData, Model3DData, ModelAnalysisReport, ColliderRecommendation, RecommendedColliderType } from "./types.js";
+/**
+ * Automatically fits and recommends an optimal 3D physics collider for a mesh or model.
+ */
+export declare function generateModelCollider(input: Mesh3DData | GeometryBufferData | Model3DData | ModelAnalysisReport, options?: {
+    preferredType?: "auto" | RecommendedColliderType;
+    type?: "auto" | RecommendedColliderType;
+    id?: string;
+}): ColliderRecommendation;

package/dist/3d/optimization/geometry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AF Motion — 3D Geometry Optimization Engine
+ *
+ * Configurable, non-destructive mesh optimization featuring spatial vertex deduplication,
+ * index buffer synthesis, degenerate triangle removal, smooth normal recalculation,
+ * tangent generation, geometry merging, and mesh splitting.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData, GeometryOptimizationConfig, OptimizedGeometryResult } from "./types.js";
+/**
+ * Optimizes 3D mesh geometry, eliminating duplicate vertices, generating index buffers,
+ * purging degenerate faces, and correcting normals and tangents.
+ */
+export declare function optimizeGeometry3D(input: Mesh3DData | GeometryBufferData, config?: GeometryOptimizationConfig): OptimizedGeometryResult;
+/**
+ * Merges multiple 3D sub-meshes into a single unified mesh buffer for draw call reduction.
+ */
+export declare function mergeGeometries3D(meshes: Mesh3DData[], materialId?: string): Mesh3DData;
+/**
+ * Splits a large mesh exceeding vertex thresholds into smaller, cache-friendly sub-meshes.
+ */
+export declare function splitMesh3D(mesh: Mesh3DData, maxVertices?: number): Mesh3DData[];

package/dist/3d/optimization/hierarchy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AF Motion — 3D Model Hierarchy Optimization
+ *
+ * Collapses redundant scene nodes, eliminates empty groups, and bakes static transforms
+ * while strictly preserving animation-sensitive skeletons and physics target nodes.
+ */
+import type { ModelNode3D, Model3DData, HierarchyOptimizationConfig, HierarchyOptimizationReport } from "./types.js";
+/**
+ * Optimizes an object hierarchy tree, removing redundant nodes and collapsing empty groups.
+ */
+export declare function optimizeModelHierarchy(input: ModelNode3D | Model3DData, config?: HierarchyOptimizationConfig): {
+    root: ModelNode3D;
+    report: HierarchyOptimizationReport;
+};

package/dist/3d/optimization/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * AF Motion — 3D Model Intelligence & Optimization Module
+ *
+ * Dedicated framework-independent 3D model analysis, geometry optimization,
+ * LOD generation, material/texture intelligence, hierarchy collapsing,
+ * skeletal inspection, and automatic physics collider generation.
+ */
+export * from "./types.js";
+export * from "./analysis.js";
+export * from "./geometry.js";
+export * from "./lod.js";
+export * from "./materials.js";
+export * from "./hierarchy.js";
+export * from "./skeleton.js";
+export * from "./colliders.js";
+export * from "./recommendations.js";
+import type { ModelAnalysisReport } from "./types.js";
+/**
+ * Validates a 3D model for runtime rendering integrity, checking for non-finite vertices,
+ * empty meshes, or severe degenerate anomalies.
+ */
+export declare function validateModel3D(model: unknown): {
+    valid: boolean;
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    issues: string[];
+    report: ModelAnalysisReport;
+};
+/**
+ * Cleanly releases any cached data or intermediate buffers created during analysis.
+ */
+export declare function disposeModelAnalysis(_report?: ModelAnalysisReport): void;

package/dist/3d/optimization/lod.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AF Motion — 3D Level of Detail (LOD) Generator
+ *
+ * Automatic multi-tier LOD generation using geometry decimation, spatial vertex clustering,
+ * distance transition thresholds, and screen-space error metrics.
+ */
+import type { GeometryBufferData } from "../geometry/types.js";
+import type { Mesh3DData, LODConfig, LODLevelConfig, ModelLODResult } from "./types.js";
+export declare const DEFAULT_LOD_LEVELS: LODLevelConfig[];
+/**
+ * Generates an array of simplified LOD levels from a base 3D mesh.
+ */
+export declare function generateModelLODs(input: Mesh3DData | GeometryBufferData, config?: LODConfig): ModelLODResult;

package/dist/3d/optimization/materials.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AF Motion — 3D Material & Texture Intelligence
+ *
+ * Detects duplicate materials, analyzes texture memory footprints,
+ * flags uncompressed/non-power-of-two assets, and recommends resolution downscaling.
+ */
+import type { MaterialData3D, TextureData3D, Model3DData, MaterialOptimizationConfig, MaterialOptimizationReport } from "./types.js";
+/**
+ * Analyzes materials and textures, discovering duplicate materials and VRAM savings opportunities.
+ * Can be called with (materials, textures, config) or (model, config).
+ */
+export declare function analyzeMaterials3D(materialsOrModel?: MaterialData3D[] | Model3DData, texturesOrConfig?: TextureData3D[] | MaterialOptimizationConfig, configArg?: MaterialOptimizationConfig): MaterialOptimizationReport;

package/dist/3d/optimization/recommendations.d.ts

@@ -0,0 +1,13 @@
+/**
+ * AF Motion — 3D Optimization Recommendation Intelligence
+ *
+ * Deterministic rule-based performance analysis matching model metrics against
+ * device capability budgets (Mobile, Standard, High-End) with explainable actions.
+ */
+import type { ModelAnalysisReport, Model3DData, DeviceProfileTier, OptimizationRecommendations } from "./types.js";
+/**
+ * Evaluates a model analysis report and generates structured, deterministic optimization recommendations.
+ */
+export declare function recommendModelOptimizations(reportOrModel: ModelAnalysisReport | Model3DData, tierOrOptions?: DeviceProfileTier | {
+    targetDeviceTier?: DeviceProfileTier;
+}): OptimizationRecommendations;

package/dist/3d/optimization/skeleton.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AF Motion — 3D Skeletal & Animation Intelligence
+ *
+ * Inspects bone hierarchies, checks acyclic graph validity, validates skin weight
+ * normalization, prunes low-magnitude influences, and extracts animation metadata.
+ */
+import type { SkeletonData3D, SkeletonOptimizationConfig, SkeletonAnalysisReport } from "./types.js";
+export interface PrunedSkinResult {
+    prunedWeights: Float32Array;
+    prunedIndices: Uint16Array | Uint32Array;
+    maxInfluencesFound: number;
+}
+/**
+ * Inspects, validates, and reports on a 3D skeletal hierarchy and vertex skinning weights.
+ */
+export declare function analyzeSkeleton3D(skeleton: SkeletonData3D, config?: SkeletonOptimizationConfig): SkeletonAnalysisReport;
+/**
+ * Prunes vertex bone skinning influences exceeding a target limit and renormalizes remaining weights to 1.0.
+ */
+export declare function pruneSkinInfluences(weights: Float32Array, indices: Uint16Array | Uint32Array, maxInfluences?: number, inputStride?: number): PrunedSkinResult;