af-motion 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,252 @@
+/**
+ * AF Motion — 3D Model Intelligence & Optimization Types
+ *
+ * Strongly-typed contracts for model inspection, geometry optimization,
+ * LOD generation, material/texture analysis, hierarchy collapsing,
+ * skeletal analysis, and automatic collider generation.
+ */
+import type { Vector3, AABB3D, Transform3D, Collider3D } from "../physics/types.js";
+import type { AnimationClipMetadata } from "../assets/types.js";
+export interface Mesh3DData {
+    id?: string;
+    name?: string;
+    positions: Float32Array;
+    normals?: Float32Array;
+    uvs?: Float32Array;
+    indices?: Uint16Array | Uint32Array;
+    tangents?: Float32Array;
+    colors?: Float32Array;
+    materialId?: string;
+}
+export interface MaterialData3D {
+    id: string;
+    name?: string;
+    color?: [number, number, number, number];
+    roughness?: number;
+    metalness?: number;
+    albedoTextureId?: string;
+    normalTextureId?: string;
+    roughnessTextureId?: string;
+    emissiveTextureId?: string;
+    alphaMode?: "OPAQUE" | "MASK" | "BLEND";
+}
+export interface TextureData3D {
+    id: string;
+    name?: string;
+    width: number;
+    height: number;
+    format?: "RGBA" | "RGB" | "GREYSCALE" | "COMPRESSED";
+    byteLength?: number;
+}
+export interface ModelNode3D {
+    id: string;
+    name?: string;
+    transform: Transform3D;
+    meshIds?: string[];
+    children?: ModelNode3D[];
+    isAnimated?: boolean;
+    isPhysicsTarget?: boolean;
+}
+export interface SkeletonBone3D {
+    id: string;
+    name: string;
+    parentIndex: number;
+    localTransform: Transform3D;
+    inverseBindMatrix?: Float32Array;
+}
+export interface SkeletonData3D {
+    bones: SkeletonBone3D[];
+    skinWeights?: Float32Array;
+    skinIndices?: Uint16Array | Uint32Array;
+    maxInfluencesPerVertex?: number;
+    animationClips?: AnimationClipMetadata[];
+}
+export interface Model3DData {
+    id: string;
+    name?: string;
+    rootNode: ModelNode3D;
+    meshes: Mesh3DData[];
+    materials?: MaterialData3D[];
+    textures?: TextureData3D[];
+    skeleton?: SkeletonData3D;
+}
+export interface TextureAnalysisMetrics {
+    totalTextureCount: number;
+    totalPixelCount: number;
+    estimatedVRAMBytesUncompressed: number;
+    estimatedVRAMBytesCompressed: number;
+    maxDimension: number;
+    nonPowerOfTwoCount: number;
+}
+export interface ModelAnalysisReport {
+    vertexCount: number;
+    triangleCount: number;
+    meshCount: number;
+    materialCount: number;
+    textureCount: number;
+    drawCallEstimate: number;
+    hierarchyDepth: number;
+    nodeCount: number;
+    bounds: {
+        aabb: AABB3D;
+        center: Vector3;
+        dimensions: Vector3;
+        boundingSphereRadius: number;
+    };
+    diagnostics: {
+        degenerateTriangles: number;
+        nonFiniteVertexCount: number;
+        duplicateVertexCount: number;
+        normalConsistency: number;
+        hasUVs: boolean;
+        hasTangents: boolean;
+        hasSkinning: boolean;
+        unindexedMeshCount: number;
+        unusedMaterials: string[];
+        emptyNodesCount: number;
+    };
+    textureMetrics: TextureAnalysisMetrics;
+    memoryEstimate: {
+        geometryBytes: number;
+        textureBytes: number;
+        totalVRAMBytes: number;
+    };
+    inspectedAt: number;
+}
+export interface GeometryOptimizationConfig {
+    /** Merge coincident vertices within distance tolerance. Default: true. */
+    deduplicateVertices?: boolean;
+    /** Spatial distance tolerance for vertex deduplication. Default: 1e-4. */
+    deduplicationTolerance?: number;
+    /** Remove zero-area or collinear triangles. Default: true. */
+    removeDegenerateTriangles?: boolean;
+    /** Recalculate smooth vertex normals from face area weighting. Default: false. */
+    recalculateNormals?: boolean;
+    /** Generate tangent vectors (and bitangent signs) from UVs. Default: false. */
+    generateTangents?: boolean;
+    /** Convert unindexed vertex streams into indexed triangle buffers. Default: true. */
+    generateIndices?: boolean;
+    /** Merge sub-meshes sharing identical materials. Default: false. */
+    mergeGeometries?: boolean;
+    /** Split large meshes exceeding vertex limits for 16-bit indices. Default: false. */
+    splitLargeMeshes?: boolean;
+    /** Maximum vertices threshold when splitting meshes. Default: 65535. */
+    maxVerticesPerMesh?: number;
+}
+export interface OptimizedGeometryResult {
+    mesh: Mesh3DData;
+    originalVertexCount: number;
+    optimizedVertexCount: number;
+    originalTriangleCount: number;
+    optimizedTriangleCount: number;
+    reductionPercentage: number;
+    indicesGenerated: boolean;
+    tangentsGenerated: boolean;
+    degeneratesRemoved: number;
+}
+export interface LODLevelConfig {
+    level: number;
+    targetTriangleRatio: number;
+    distanceThreshold: number;
+    maxError?: number;
+}
+export interface LODConfig {
+    levels?: LODLevelConfig[];
+    /** Preserve outer boundary edge vertices. Default: true. */
+    preserveBoundaries?: boolean;
+    /** Screen space error threshold in pixels. Default: 2.0. */
+    screenSpaceError?: number;
+}
+export interface LODLevelData {
+    level: number;
+    mesh: Mesh3DData;
+    vertexCount: number;
+    triangleCount: number;
+    reductionRatio: number;
+    distanceThreshold: number;
+}
+export interface ModelLODResult {
+    lods: LODLevelData[];
+    baseTriangleCount: number;
+    totalLevels: number;
+}
+export interface MaterialOptimizationConfig {
+    deduplicateMaterials?: boolean;
+    recommendTextureDownscaling?: boolean;
+    maxTextureDimension?: number;
+}
+export interface MaterialOptimizationReport {
+    originalMaterialCount: number;
+    deduplicatedMaterialCount: number;
+    duplicatePairs: Array<{
+        duplicateId: string;
+        canonicalId: string;
+    }>;
+    textureRecommendations: Array<{
+        textureId: string;
+        currentResolution: [number, number];
+        recommendedResolution: [number, number];
+        savedVRAMBytes: number;
+        reason: string;
+    }>;
+    totalVRAMSavingsBytes: number;
+}
+export interface HierarchyOptimizationConfig {
+    removeEmptyGroups?: boolean;
+    collapseRedundantNodes?: boolean;
+    bakeStaticTransforms?: boolean;
+    preserveAnimatedNodes?: boolean;
+    preservePhysicsNodes?: boolean;
+}
+export interface HierarchyOptimizationReport {
+    originalNodeCount: number;
+    optimizedNodeCount: number;
+    nodesRemoved: number;
+    transformsBaked: number;
+    maxDepthBefore: number;
+    maxDepthAfter: number;
+}
+export interface SkeletonOptimizationConfig {
+    maxInfluences?: number;
+    minWeightThreshold?: number;
+}
+export interface SkeletonAnalysisReport {
+    boneCount: number;
+    hierarchyDepth: number;
+    hasCycles: boolean;
+    maxInfluencesPerVertex: number;
+    unnormalizedWeightsCount: number;
+    prunedInfluencesCount: number;
+    animationClips: AnimationClipMetadata[];
+}
+export type RecommendedColliderType = "box" | "sphere" | "capsule" | "convex" | "compound";
+export interface ColliderRecommendation {
+    type: RecommendedColliderType;
+    collider: Collider3D;
+    center?: Vector3;
+    halfExtents?: Vector3;
+    radius?: number;
+    height?: number;
+    vertices?: Float32Array;
+    confidence: number;
+    accuracyEstimate: number;
+    computationalCost: "minimal" | "low" | "medium" | "high";
+    reason: string;
+}
+export type DeviceProfileTier = "mobile" | "standard" | "high-end";
+export interface OptimizationRecommendationItem {
+    category: "geometry" | "lod" | "materials" | "textures" | "hierarchy" | "physics";
+    severity: "info" | "warning" | "critical";
+    message: string;
+    expectedImpact: string;
+    action: string;
+}
+export interface OptimizationRecommendations {
+    overallHealthScore: number;
+    tier: DeviceProfileTier;
+    recommendations: OptimizationRecommendationItem[];
+    estimatedDrawCallsBefore: number;
+    estimatedDrawCallsAfter: number;
+    estimatedVRAMBytesBefore: number;
+    estimatedVRAMBytesAfter: number;
+}

package/dist/3d/physics/benchmark.d.ts

@@ -0,0 +1,76 @@
+/**
+ * AF Motion — 3D Rigid Body Performance & Stacking Benchmarks
+ *
+ * Standardized execution benchmarks for multi-body simulations, vertical stacking,
+ * high-velocity CCD collision penetration tests, and broadphase throughput.
+ */
+export interface RigidBodyBenchmarkResult {
+    bodyCount: number;
+    steps: number;
+    totalTimeMs: number;
+    avgStepMs: number;
+    fpsEquivalent: number;
+}
+export interface StackingBenchmarkResult {
+    bodyCount: number;
+    height: number;
+    totalTimeMs: number;
+    avgStepMs: number;
+    stable: boolean;
+}
+export interface CCDBenchmarkResult {
+    impactSpeed: number;
+    tunneled: boolean;
+    timeOfImpact: number;
+    finalPositionZ: number;
+}
+/**
+ * Runs a performance benchmark simulating N dynamic rigid bodies falling under gravity.
+ */
+export declare function benchmarkRigidBodies(bodyCount?: number, steps?: number): RigidBodyBenchmarkResult;
+/**
+ * Runs a vertical box stacking stability benchmark.
+ */
+export declare function benchmarkStacking(stacks?: number, height?: number, steps?: number): StackingBenchmarkResult;
+/**
+ * Runs a high-velocity impact test to verify that Continuous Collision Detection
+ * prevents tunneling through a thin static barrier.
+ */
+export declare function benchmarkCCD(impactSpeed?: number): CCDBenchmarkResult;
+export interface RopeBenchmarkResult {
+    segments: number;
+    steps: number;
+    totalTimeMs: number;
+    avgStepMs: number;
+    fpsEquivalent: number;
+    lengthMaintained: boolean;
+}
+export declare function benchmarkRope(segments?: number, steps?: number): RopeBenchmarkResult;
+export interface ClothBenchmarkResult {
+    resolution: number;
+    particleCount: number;
+    constraintCount: number;
+    steps: number;
+    totalTimeMs: number;
+    avgStepMs: number;
+    fpsEquivalent: number;
+}
+export declare function benchmarkCloth(size?: number, steps?: number): ClothBenchmarkResult;
+export interface SoftBodyBenchmarkResult {
+    bodyCount: number;
+    totalParticles: number;
+    steps: number;
+    totalTimeMs: number;
+    avgStepMs: number;
+    fpsEquivalent: number;
+}
+export declare function benchmarkSoftBodies(count?: number, steps?: number): SoftBodyBenchmarkResult;
+export interface ArticulatedChainBenchmarkResult {
+    links: number;
+    steps: number;
+    totalTimeMs: number;
+    avgStepMs: number;
+    fpsEquivalent: number;
+    intact: boolean;
+}
+export declare function benchmarkArticulatedChain(links?: number, steps?: number): ArticulatedChainBenchmarkResult;

package/dist/3d/physics/body/inertia.d.ts

@@ -0,0 +1,61 @@
+/**
+ * AF Motion — 3D Rotational Inertia & Mass Properties
+ *
+ * Accurate analytical moment of inertia tensors for 3D primitive and compound
+ * colliders, parallel axis theorem (Huygens-Steiner), and world-space tensor rotations.
+ */
+import type { Matrix3, Vector3, Quaternion, Collider3D, ColliderShape3D } from "../types.js";
+/**
+ * Calculates geometric volume for 3D primitive collider shapes.
+ */
+export declare function computeShapeVolume(shape: ColliderShape3D): number;
+/**
+ * Calculates mass of a shape given its volume and density in kg/m^3.
+ */
+export declare function computeShapeMassFromDensity(shape: ColliderShape3D, density?: number): number;
+/**
+ * Computes the principal diagonal inertia tensor for a solid uniform sphere.
+ * I = (2/5) * m * r^2
+ */
+export declare function computeSphereInertia(radius: number, mass: number): Matrix3;
+/**
+ * Computes the principal diagonal inertia tensor for a solid uniform box.
+ * I_xx = (1/12) * m * (width_y^2 + width_z^2) = (1/3) * m * (hy^2 + hz^2)
+ */
+export declare function computeBoxInertia(halfExtents: Vector3, mass: number): Matrix3;
+/**
+ * Computes the principal inertia tensor for a solid capsule composed of
+ * a cylinder of radius r and height h, capped by two hemispheres.
+ */
+export declare function computeCapsuleInertia(radius: number, height: number, axis?: "x" | "y" | "z", mass?: number): Matrix3;
+/**
+ * Computes the local inertia tensor for an individual collider shape.
+ */
+export declare function computeColliderInertia(shape: ColliderShape3D, mass: number): Matrix3;
+/**
+ * Shifts an inertia tensor about an offset vector using the Parallel Axis Theorem:
+ * I_offset = I_cm + m * (||d||^2 * I_3 - d * d^T)
+ */
+export declare function applyParallelAxisTheorem(inertia: Matrix3, offset: Vector3, mass: number): Matrix3;
+/**
+ * Rotates a 3x3 inertia tensor by an orientation quaternion:
+ * I_rot = R * I * R^T
+ */
+export declare function rotateInertiaTensor(inertia: Matrix3, rotation: Quaternion): Matrix3;
+/**
+ * Computes the world-space inverse inertia tensor from the body's local inverse tensor
+ * and its current world orientation:
+ * I_world^-1 = R * I_local^-1 * R^T
+ */
+export declare function computeWorldInvInertiaTensor(invInertiaLocal: Matrix3, rotation: Quaternion): Matrix3;
+/**
+ * Computes compound mass, center of mass, and combined inertia tensor for a collection
+ * of sub-colliders with local offsets and orientations.
+ */
+export declare function computeCompoundMassProperties(colliders: readonly Collider3D[], defaultDensity?: number, explicitMass?: number): {
+    mass: number;
+    invMass: number;
+    centerOfMass: Vector3;
+    inertiaTensor: Matrix3;
+    invInertiaTensor: Matrix3;
+};

package/dist/3d/physics/collision/ccd.d.ts

@@ -0,0 +1,26 @@
+/**
+ * AF Motion — Continuous Collision Detection (CCD)
+ *
+ * Swept-volume and ray-based time-of-impact (TOI) estimation for high-velocity
+ * rigid bodies, preventing tunneling through thin colliders and boundaries.
+ */
+import type { RigidBodyState, Transform3D, Collider3D, Vector3 } from "../types.js";
+import type { SpatialQuery3D } from "../spatial/spatial-hash.js";
+export interface CCDResult {
+    hasCollision: boolean;
+    timeOfImpact: number;
+    hitPoint?: Vector3;
+    hitNormal?: Vector3;
+    hitCollider?: Collider3D;
+    hitBodyId?: string;
+}
+/**
+ * Evaluates whether continuous collision detection should be evaluated for a body.
+ * Activated if enableCCD is true or if displacement exceeds the body's conservative bounding radius.
+ */
+export declare function requiresCCD(body: RigidBodyState, displacement: Vector3, conservativeRadius?: number): boolean;
+/**
+ * Performs continuous collision sweep for a dynamic rigid body between its
+ * start transform and proposed end transform.
+ */
+export declare function sweepBodyCCD(body: RigidBodyState, startTransform: Transform3D, endTransform: Transform3D, spatialQuery: SpatialQuery3D, getBodyTransform: (bodyId?: string) => Transform3D): CCDResult;

package/dist/3d/physics/collision/narrowphase.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AF Motion — 3D Narrowphase Collision & Raycasting
+ *
+ * Geometric intersection tests between 3D primitive colliders, contact manifold
+ * generation, and accurate 3D raycasting against shapes.
+ */
+import type { Collider3D, CollisionManifold3D, Transform3D, Ray3D, RayHit3D, RigidBodyState } from "../types.js";
+/**
+ * Generates a collision manifold between two colliders if an intersection exists.
+ */
+export declare function generateCollisionManifold(bodyA: RigidBodyState | undefined, bodyB: RigidBodyState | undefined, colliderA: Collider3D, colliderB: Collider3D, bodyTransformA: Transform3D, bodyTransformB: Transform3D): CollisionManifold3D | null;
+/**
+ * Raycasts against a 3D collider at a given world transform.
+ */
+export declare function raycastCollider(ray: Ray3D, collider: Collider3D, bodyTransform: Transform3D): RayHit3D | null;

package/dist/3d/physics/collision/shapes.d.ts

@@ -0,0 +1,45 @@
+/**
+ * AF Motion — 3D Collision Shapes & Collider Factory
+ *
+ * Geometric representations for 3D collision bodies, layer filtering,
+ * and precise world-space AABB bounding calculations.
+ */
+import type { Collider3D, ColliderShape3D, SphereColliderShape, BoxColliderShape, CapsuleColliderShape, PlaneColliderShape, ConvexColliderShape, HeightfieldColliderShape, Transform3D, AABB3D, Vector3 } from "../types.js";
+/**
+ * Creates a 3D Sphere shape.
+ */
+export declare function createSphereShape(radius: number): SphereColliderShape;
+/**
+ * Creates a 3D Box shape from half-extents.
+ */
+export declare function createBoxShape(halfExtents: Vector3): BoxColliderShape;
+/**
+ * Creates a 3D Capsule shape.
+ */
+export declare function createCapsuleShape(radius: number, height: number, axis?: "x" | "y" | "z"): CapsuleColliderShape;
+/**
+ * Creates an infinite 3D Plane shape (plane equation: dot(normal, x) - constant = 0).
+ */
+export declare function createPlaneShape(normal: Vector3, constant?: number): PlaneColliderShape;
+/**
+ * Creates a Convex Polyhedron shape.
+ */
+export declare function createConvexShape(vertices: Float32Array | readonly Vector3[], indices?: Uint32Array | Uint16Array): ConvexColliderShape;
+/**
+ * Computes the world-space Axis-Aligned Bounding Box (AABB) for a 3D collider.
+ */
+export declare function computeColliderAABB(collider: Collider3D, bodyTransform?: Transform3D): AABB3D;
+/**
+ * Tests whether two colliders are eligible to collide based on layers and masks.
+ */
+export declare function canCollide(a: Collider3D, b: Collider3D): boolean;
+export declare const canCollideCollider3D: typeof canCollide;
+export declare const canCollide3D: typeof canCollide;
+/**
+ * Creates a fully validated 3D Collider instance.
+ */
+export declare function createCollider3D(shape: ColliderShape3D, options?: Partial<Collider3D>): Collider3D;
+/**
+ * Creates a Heightfield collider shape.
+ */
+export declare function createHeightfieldShape(width: number, length: number, cols: number, rows: number, heights: Float32Array, minHeight: number, maxHeight: number): HeightfieldColliderShape;

package/dist/3d/physics/constraints/advanced.d.ts

@@ -0,0 +1,40 @@
+/**
+ * AF Motion — 3D Advanced Constraint Factories
+ *
+ * Provides factory constructors for articulated joints: Hinge, Slider,
+ * Cone-Twist, Ball-and-Socket, Generic 6DOF, Fixed, and Damped Spring.
+ */
+import type { Constraint3D } from "../types.js";
+import type { DistanceConstraintConfig, FixedConstraintConfig, BallAndSocketConstraintConfig, HingeConstraintConfig, SliderConstraintConfig, ConeTwistConstraintConfig, Generic6DOFConstraintConfig, SpringConstraintConfig } from "./types.js";
+/**
+ * Creates a Distance Constraint maintaining a distance between two bodies.
+ */
+export declare function createDistanceConstraint3D(config: DistanceConstraintConfig): Constraint3D;
+/**
+ * Creates a Fixed Constraint completely locking relative position and orientation.
+ */
+export declare function createFixedConstraint3D(config: FixedConstraintConfig): Constraint3D;
+/**
+ * Creates a Ball-and-Socket (point-to-point) joint allowing free 3DOF rotation.
+ */
+export declare function createBallAndSocketConstraint3D(config: BallAndSocketConstraintConfig): Constraint3D;
+/**
+ * Creates a Hinge (revolute) constraint with angular limits and motor.
+ */
+export declare function createHingeConstraint3D(config: HingeConstraintConfig): Constraint3D;
+/**
+ * Creates a Slider (prismatic) constraint with linear limits and motor.
+ */
+export declare function createSliderConstraint3D(config: SliderConstraintConfig): Constraint3D;
+/**
+ * Creates a Cone-Twist constraint for universal joint / ragdoll limit behavior.
+ */
+export declare function createConeTwistConstraint3D(config: ConeTwistConstraintConfig): Constraint3D;
+/**
+ * Creates a Generic 6DOF constraint with customizable linear and angular limits.
+ */
+export declare function createGeneric6DOFConstraint3D(config: Generic6DOFConstraintConfig): Constraint3D;
+/**
+ * Creates a Damped Spring constraint between two bodies.
+ */
+export declare function createSpringConstraint3D(config: SpringConstraintConfig): Constraint3D;

package/dist/3d/physics/constraints/solver.d.ts

@@ -0,0 +1,34 @@
+/**
+ * AF Motion — 3D Advanced Constraint Solver & Articulated Island Engine
+ *
+ * Implements high-stability iterative solving for Hinge, Slider, Cone-Twist,
+ * Ball-and-Socket, Generic 6DOF, Fixed, and Spring constraints with angular
+ * and linear limits, motors, breaking thresholds, and connected body island sleeping.
+ */
+import type { Constraint3D, RigidBodyState } from "../types.js";
+import type { ConstraintSolver3D } from "../solver/types.js";
+export type ConstraintBreakCallback = (constraintId: string, constraint: Constraint3D, impulse: number) => void;
+/**
+ * Articulated Constraint Graph Component (Island).
+ */
+export interface BodyIsland {
+    id: string;
+    bodyIds: Set<string>;
+    constraintIds: Set<string>;
+    totalKineticEnergy: number;
+    isSleeping: boolean;
+}
+/**
+ * Advanced iterative constraint solver supporting articulated multibody mechanisms.
+ */
+export declare class AdvancedConstraintSolver3D implements ConstraintSolver3D {
+    readonly name = "advanced-constraint-solver";
+    private onBreak?;
+    constructor(onBreak?: ConstraintBreakCallback);
+    setOnBreakCallback(cb: ConstraintBreakCallback): void;
+    solveConstraints(constraints: readonly Constraint3D[], bodies: ReadonlyMap<string, RigidBodyState>, iterations: number, dt: number): void;
+}
+/**
+ * Computes connected body islands (articulated mechanisms) for group solving and sleeping.
+ */
+export declare function computeConstraintIslands(bodies: ReadonlyMap<string, RigidBodyState>, constraints: readonly Constraint3D[]): BodyIsland[];

package/dist/3d/physics/constraints/types.d.ts

@@ -0,0 +1,106 @@
+/**
+ * AF Motion — 3D Advanced Constraint Types
+ *
+ * Strongly-typed definitions for articulated rigid-body constraints:
+ * Hinge, Slider, Cone-Twist, Ball-and-Socket, Generic 6DOF, Fixed, and Spring.
+ */
+import type { Vector3, Transform3D } from "../types.js";
+export interface BaseConstraintConfig {
+    id?: string;
+    bodyAId: string;
+    bodyBId?: string;
+    pivotA?: Vector3;
+    pivotB?: Vector3;
+    stiffness?: number;
+    damping?: number;
+    enabled?: boolean;
+    breakingImpulse?: number;
+    userData?: unknown;
+}
+export interface DistanceConstraintConfig extends BaseConstraintConfig {
+    minDistance?: number;
+    maxDistance?: number;
+    distance?: number;
+}
+export interface FixedConstraintConfig extends BaseConstraintConfig {
+}
+export interface BallAndSocketConstraintConfig extends BaseConstraintConfig {
+}
+export interface HingeConstraintConfig extends BaseConstraintConfig {
+    /** Local rotation axis on body A. Default: { x: 0, y: 1, z: 0 }. */
+    axisA?: Vector3;
+    /** Local rotation axis on body B. Default: { x: 0, y: 1, z: 0 }. */
+    axisB?: Vector3;
+    /** Minimum allowable rotation angle in radians. */
+    lowerLimit?: number;
+    /** Maximum allowable rotation angle in radians. */
+    upperLimit?: number;
+    /** Whether the angular motor is active. */
+    motorEnabled?: boolean;
+    /** Target angular velocity in radians/sec. */
+    motorTargetVelocity?: number;
+    /** Maximum motor torque in N*m. */
+    motorMaxForce?: number;
+}
+export interface SliderConstraintConfig extends BaseConstraintConfig {
+    /** Local sliding axis on body A. Default: { x: 1, y: 0, z: 0 }. */
+    axisA?: Vector3;
+    /** Local sliding axis on body B. Default: { x: 1, y: 0, z: 0 }. */
+    axisB?: Vector3;
+    /** Minimum allowable linear translation in meters. */
+    lowerLimit?: number;
+    /** Maximum allowable linear translation in meters. */
+    upperLimit?: number;
+    /** Whether the linear motor is active. */
+    motorEnabled?: boolean;
+    /** Target linear velocity in m/s. */
+    motorTargetVelocity?: number;
+    /** Maximum linear motor force in N. */
+    motorMaxForce?: number;
+}
+export interface ConeTwistConstraintConfig extends BaseConstraintConfig {
+    /** Alignment axis on body A. Default: { x: 0, y: 1, z: 0 }. */
+    axisA?: Vector3;
+    /** Alignment axis on body B. Default: { x: 0, y: 1, z: 0 }. */
+    axisB?: Vector3;
+    /** Maximum cone deflection angle in radians. Default: Math.PI / 4. */
+    coneLimitAngle?: number;
+    /** Maximum twist angle in radians. Default: Math.PI / 6. */
+    twistLimitAngle?: number;
+}
+export interface Generic6DOFConstraintConfig extends BaseConstraintConfig {
+    /** Coordinate frame on body A. */
+    frameA?: Transform3D;
+    /** Coordinate frame on body B. */
+    frameB?: Transform3D;
+    /** Linear motion limits [min, max] per axis (X, Y, Z). */
+    linearLimits?: {
+        min: Vector3;
+        max: Vector3;
+    };
+    /** Angular motion limits [min, max] per axis (X, Y, Z). */
+    angularLimits?: {
+        min: Vector3;
+        max: Vector3;
+    };
+    /** Linear motor settings per axis. */
+    linearMotor?: {
+        enabled?: boolean;
+        targetVelocity?: Vector3;
+        maxForce?: Vector3;
+    };
+    /** Angular motor settings per axis. */
+    angularMotor?: {
+        enabled?: boolean;
+        targetVelocity?: Vector3;
+        maxForce?: Vector3;
+    };
+}
+export interface SpringConstraintConfig extends BaseConstraintConfig {
+    /** Equilibrium rest length. Default: distance between initial pivots. */
+    restLength?: number;
+    /** Hookean spring stiffness coefficient. Default: 100. */
+    stiffness?: number;
+    /** Viscous damping coefficient. Default: 5. */
+    damping?: number;
+}