af-motion 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,8 @@
+/**
+ * AF Motion 3D Environment Presets
+ *
+ * Professional staging backdrops and atmospheric effects.
+ */
+import type { EnvironmentPresetName, IntelligentEnvironmentConfig } from "./types.js";
+export declare const ENVIRONMENT_PRESETS: Readonly<Record<EnvironmentPresetName, IntelligentEnvironmentConfig>>;
+export declare function getEnvironmentPreset(name: EnvironmentPresetName): IntelligentEnvironmentConfig;

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

@@ -0,0 +1,36 @@
+/**
+ * AF Motion 3D Environment Intelligence Contracts
+ */
+import type { Environment3DConfig, Vector3Tuple } from "../types.js";
+export type EnvironmentPresetName = "studio-dark" | "studio-light" | "dawn" | "cyberpunk" | "desert" | "void" | "cloudy";
+export interface EnvironmentGradientConfig {
+    readonly type?: "linear" | "radial";
+    readonly colors: readonly string[];
+    readonly angle?: number;
+}
+export interface SkyConfig {
+    readonly sunPosition?: Vector3Tuple;
+    readonly turbidity?: number;
+    readonly rayleigh?: number;
+    readonly mieCoefficient?: number;
+}
+export interface GroundConfig {
+    readonly enabled?: boolean;
+    readonly size?: number;
+    readonly color?: string;
+    readonly receiveShadow?: boolean;
+    readonly roughness?: number;
+    readonly metalness?: number;
+}
+export interface EnvironmentLightingConfig {
+    readonly hdriUrl?: string;
+    readonly intensity?: number;
+    readonly blur?: number;
+}
+export interface IntelligentEnvironmentConfig extends Environment3DConfig {
+    readonly preset?: EnvironmentPresetName;
+    readonly gradient?: EnvironmentGradientConfig;
+    readonly sky?: SkyConfig;
+    readonly ground?: GroundConfig;
+    readonly environmentLighting?: EnvironmentLightingConfig;
+}

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

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

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

@@ -0,0 +1,37 @@
+/**
+ * AF Motion 3D Geometry Cache
+ *
+ * Bounded LRU cache for procedural geometries avoiding redundant regeneration.
+ */
+import type { GeometryBufferData, ProceduralGeometryDescriptor } from "./types.js";
+export declare class GeometryCache3D {
+    private readonly entries;
+    private readonly maxEntries;
+    constructor(options?: {
+        maxEntries?: number;
+    });
+    /**
+     * Retrieves or computes procedural geometry buffer data for a descriptor.
+     */
+    getOrGenerate(descriptor: ProceduralGeometryDescriptor): GeometryBufferData;
+    /**
+     * Checks if a geometry descriptor is already cached.
+     */
+    has(descriptor: ProceduralGeometryDescriptor): boolean;
+    /**
+     * Clears the cache.
+     */
+    clear(): void;
+    /**
+     * Evicts the least recently accessed geometry.
+     */
+    private evictOldest;
+    /**
+     * Returns cache stats.
+     */
+    getStats(): {
+        size: number;
+        maxEntries: number;
+    };
+}
+export declare function getDefaultGeometryCache(): GeometryCache3D;

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

@@ -0,0 +1,24 @@
+/**
+ * AF Motion 3D Procedural Geometry Generators
+ *
+ * Framework-independent mathematical generators for 11 procedural 3D geometries.
+ * Computes deterministic vertices, normals, UVs, indices, and bounding boxes.
+ */
+import type { BoundingBox3D } from "../schemas/types.js";
+import type { BoxGeometryConfig, CapsuleGeometryConfig, ConeGeometryConfig, CylinderGeometryConfig, ExtrudeGeometryConfig, GeometryBufferData, ParametricGeometryConfig, PlaneGeometryConfig, ProceduralGeometryDescriptor, RingGeometryConfig, RoundedBoxGeometryConfig, SphereGeometryConfig, TorusGeometryConfig } from "./types.js";
+/**
+ * Computes min, max, size, and center from a flat Float32Array of [x, y, z] vertex positions.
+ */
+export declare function computeBoundingBoxFromPositions(positions: Float32Array): BoundingBox3D;
+export declare function generateBoxGeometry(rawConfig?: BoxGeometryConfig): GeometryBufferData;
+export declare function generateSphereGeometry(rawConfig?: SphereGeometryConfig): GeometryBufferData;
+export declare function generatePlaneGeometry(rawConfig?: PlaneGeometryConfig): GeometryBufferData;
+export declare function generateCylinderGeometry(rawConfig?: CylinderGeometryConfig): GeometryBufferData;
+export declare function generateConeGeometry(rawConfig?: ConeGeometryConfig): GeometryBufferData;
+export declare function generateTorusGeometry(rawConfig?: TorusGeometryConfig): GeometryBufferData;
+export declare function generateCapsuleGeometry(rawConfig?: CapsuleGeometryConfig): GeometryBufferData;
+export declare function generateRingGeometry(rawConfig?: RingGeometryConfig): GeometryBufferData;
+export declare function generateRoundedBoxGeometry(rawConfig?: RoundedBoxGeometryConfig): GeometryBufferData;
+export declare function generateExtrudeGeometry(rawConfig?: ExtrudeGeometryConfig): GeometryBufferData;
+export declare function generateParametricGeometry(rawConfig?: ParametricGeometryConfig): GeometryBufferData;
+export declare function generateProceduralGeometry(descriptor: ProceduralGeometryDescriptor): GeometryBufferData;

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

@@ -0,0 +1,10 @@
+/**
+ * AF Motion 3D Procedural Geometry Hashing
+ *
+ * Deterministic hash computation for geometry caching and reuse.
+ */
+import type { ProceduralGeometryDescriptor } from "./types.js";
+/**
+ * Computes a deterministic canonical string hash of a geometry descriptor.
+ */
+export declare function computeGeometryHash(descriptor: ProceduralGeometryDescriptor): string;

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

@@ -0,0 +1,9 @@
+/**
+ * AF Motion 3D Geometry Module
+ */
+export * from "./types.js";
+export * from "./validation.js";
+export * from "./generators.js";
+export * from "./hash.js";
+export * from "./cache.js";
+export * from "./three-adapter.js";

package/dist/3d/geometry/three-adapter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AF Motion 3D Geometry Three.js Adapter
+ *
+ * Optional conversion of procedural geometry descriptors and buffer data
+ * into Three.js BufferGeometry instances.
+ */
+import type { GeometryBufferData, ProceduralGeometryDescriptor } from "./types.js";
+/**
+ * Converts a procedural geometry descriptor or buffer data into a Three.js BufferGeometry.
+ */
+export declare function toThreeGeometry(descriptorOrBuffer: ProceduralGeometryDescriptor | GeometryBufferData, threeInstance?: any): any;
+/**
+ * Disposes a Three.js geometry instance.
+ */
+export declare function disposeThreeGeometry(geometry: any): void;

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

@@ -0,0 +1,120 @@
+/**
+ * AF Motion 3D Procedural Geometry Types
+ *
+ * Framework-independent geometry configurations, buffer data contracts,
+ * and procedural shape descriptors.
+ */
+import type { BoundingBox3D } from "../schemas/types.js";
+export type Geometry3DType = "box" | "sphere" | "plane" | "cylinder" | "cone" | "torus" | "capsule" | "ring" | "rounded-box" | "extrude" | "parametric";
+export interface GeometryBufferData {
+    readonly type: Geometry3DType;
+    readonly positions: Float32Array;
+    readonly normals: Float32Array;
+    readonly uvs: Float32Array;
+    readonly indices?: Uint16Array | Uint32Array;
+    readonly vertexCount: number;
+    readonly triangleCount: number;
+    readonly boundingBox: BoundingBox3D;
+    readonly generatedAt?: number;
+}
+export interface BoxGeometryConfig {
+    readonly type: "box";
+    readonly width?: number;
+    readonly height?: number;
+    readonly depth?: number;
+    readonly widthSegments?: number;
+    readonly heightSegments?: number;
+    readonly depthSegments?: number;
+}
+export interface SphereGeometryConfig {
+    readonly type: "sphere";
+    readonly radius?: number;
+    readonly widthSegments?: number;
+    readonly heightSegments?: number;
+    readonly phiStart?: number;
+    readonly phiLength?: number;
+    readonly thetaStart?: number;
+    readonly thetaLength?: number;
+}
+export interface PlaneGeometryConfig {
+    readonly type: "plane";
+    readonly width?: number;
+    readonly height?: number;
+    readonly widthSegments?: number;
+    readonly heightSegments?: number;
+}
+export interface CylinderGeometryConfig {
+    readonly type: "cylinder";
+    readonly radiusTop?: number;
+    readonly radiusBottom?: number;
+    readonly height?: number;
+    readonly radialSegments?: number;
+    readonly heightSegments?: number;
+    readonly openEnded?: boolean;
+    readonly thetaStart?: number;
+    readonly thetaLength?: number;
+}
+export interface ConeGeometryConfig {
+    readonly type: "cone";
+    readonly radius?: number;
+    readonly height?: number;
+    readonly radialSegments?: number;
+    readonly heightSegments?: number;
+    readonly openEnded?: boolean;
+    readonly thetaStart?: number;
+    readonly thetaLength?: number;
+}
+export interface TorusGeometryConfig {
+    readonly type: "torus";
+    readonly radius?: number;
+    readonly tube?: number;
+    readonly radialSegments?: number;
+    readonly tubularSegments?: number;
+    readonly arc?: number;
+}
+export interface CapsuleGeometryConfig {
+    readonly type: "capsule";
+    readonly radius?: number;
+    readonly length?: number;
+    readonly capSubdivisions?: number;
+    readonly radialSegments?: number;
+}
+export interface RingGeometryConfig {
+    readonly type: "ring";
+    readonly innerRadius?: number;
+    readonly outerRadius?: number;
+    readonly thetaSegments?: number;
+    readonly phiSegments?: number;
+    readonly thetaStart?: number;
+    readonly thetaLength?: number;
+}
+export interface RoundedBoxGeometryConfig {
+    readonly type: "rounded-box";
+    readonly width?: number;
+    readonly height?: number;
+    readonly depth?: number;
+    readonly radius?: number;
+    readonly smoothness?: number;
+}
+export interface ExtrudeGeometryConfig {
+    readonly type: "extrude";
+    readonly points: readonly (readonly [number, number])[];
+    readonly depth?: number;
+    readonly bevelEnabled?: boolean;
+    readonly bevelThickness?: number;
+    readonly bevelSize?: number;
+    readonly bevelSegments?: number;
+}
+export type ParametricEvaluator = (u: number, v: number, target: [number, number, number]) => void;
+export interface ParametricGeometryConfig {
+    readonly type: "parametric";
+    readonly evaluatorName?: "plane" | "wave" | "sphere" | "klein" | "mobius" | "torus-knot";
+    readonly evaluator?: ParametricEvaluator;
+    readonly uSegments?: number;
+    readonly vSegments?: number;
+}
+export type ProceduralGeometryDescriptor = BoxGeometryConfig | SphereGeometryConfig | PlaneGeometryConfig | CylinderGeometryConfig | ConeGeometryConfig | TorusGeometryConfig | CapsuleGeometryConfig | RingGeometryConfig | RoundedBoxGeometryConfig | ExtrudeGeometryConfig | ParametricGeometryConfig;
+export interface GeometryValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+}

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

@@ -0,0 +1,6 @@
+/**
+ * AF Motion 3D Procedural Geometry Validation and Correction
+ */
+import type { GeometryValidationResult, ProceduralGeometryDescriptor } from "./types.js";
+export declare function validateGeometryDescriptor(descriptor: unknown): GeometryValidationResult;
+export declare function correctGeometryDescriptor(descriptor: ProceduralGeometryDescriptor): ProceduralGeometryDescriptor;

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

@@ -0,0 +1,32 @@
+/**
+ * AF Motion 3D Infrastructure Module
+ *
+ * Dedicated framework-independent 3D scene engine, camera, lighting,
+ * environment, material intelligence, asset management, procedural geometry,
+ * interactive environment engine, scroll-driven scenes, AI compositions,
+ * 3D physics architecture, procedural terrain, procedural world generation,
+ * and 3D model intelligence & optimization.
+ */
+export * from "./types.js";
+export * from "./capabilities.js";
+export * from "./adapter.js";
+export * from "./scene.js";
+export * from "./schema.js";
+export * from "./r3f.js";
+export * from "./schemas/index.js";
+export * from "./camera/index.js";
+export * from "./lighting/index.js";
+export * from "./environment/index.js";
+export * from "./materials/index.js";
+export * from "./assets/index.js";
+export * from "./geometry/index.js";
+export * from "./interaction/index.js";
+export * from "./scroll/index.js";
+export * from "./composition/index.js";
+export * from "./physics/index.js";
+export * from "./terrain/index.js";
+export * from "./world/index.js";
+export * from "./optimization/index.js";
+export * from "./morphing/index.js";
+export type { Vector3, Quaternion, Transform3D } from "./schemas/index.js";
+export type { Vector3Tuple } from "./types.js";

package/dist/3d/interaction/camera-controls.d.ts

@@ -0,0 +1,58 @@
+/**
+ * AF Motion 3D Camera Controls Engine
+ *
+ * Framework-independent Orbit, Pan, Zoom, Focus, and Damping controller
+ * with reduced-motion respect and boundary enforcement.
+ */
+import type { Camera3DConfig, Vector3Tuple } from "../types.js";
+import type { BoundingBox3D } from "../schemas/types.js";
+import type { CameraControlsConfig, CameraControlsState } from "./types.js";
+export declare class CameraControls3D {
+    private config;
+    private target;
+    private currentAzimuth;
+    private targetAzimuth;
+    private currentPolar;
+    private targetPolar;
+    private currentDistance;
+    private targetDistance;
+    private isInteracting;
+    constructor(initialCamera?: Camera3DConfig, config?: CameraControlsConfig);
+    /**
+     * Applies rotation delta in spherical coordinates (azimuth and polar angles).
+     */
+    rotate(deltaAzimuth: number, deltaPolar: number): void;
+    /**
+     * Pans target and camera in screen-aligned coordinates.
+     */
+    pan(deltaX: number, deltaY: number): void;
+    /**
+     * Zooms by adjusting distance to target.
+     */
+    zoom(delta: number): void;
+    /**
+     * Smoothly frames a 3D bounding box within the camera field of view.
+     */
+    focusOn(boundingBox: BoundingBox3D, fov?: number): void;
+    /**
+     * Updates look-at target.
+     */
+    lookAt(target: Vector3Tuple): void;
+    /**
+     * Sets interacting state flag.
+     */
+    setInteracting(interacting: boolean): void;
+    /**
+     * Updates controls by delta time (seconds), applying damping and auto-rotation.
+     * Returns updated camera configuration.
+     */
+    update(deltaTime?: number): Camera3DConfig;
+    /**
+     * Returns current internal state.
+     */
+    getState(): CameraControlsState;
+    /**
+     * Updates configuration dynamically.
+     */
+    updateConfig(partial: Partial<CameraControlsConfig>): void;
+}

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

@@ -0,0 +1,8 @@
+/**
+ * AF Motion 3D Interaction Module
+ */
+export * from "./types.js";
+export * from "./raycaster.js";
+export * from "./camera-controls.js";
+export * from "./manager.js";
+export * from "./presets.js";

package/dist/3d/interaction/manager.d.ts

@@ -0,0 +1,61 @@
+/**
+ * AF Motion 3D Interaction Manager
+ *
+ * Coordinates pointer, touch, keyboard, raycasting, selection,
+ * hover, focus, and camera navigation in 3D scenes.
+ */
+import type { Interaction3DOptions, InteractionState3D } from "./types.js";
+import { CameraControls3D } from "./camera-controls.js";
+type InteractionListener = (state: InteractionState3D) => void;
+export declare class InteractionManager3D {
+    private element;
+    private readonly options;
+    private readonly cameraControls;
+    private readonly listeners;
+    private state;
+    private isPointerDown;
+    private pointerStartX;
+    private pointerStartY;
+    private lastPointerX;
+    private lastPointerY;
+    private hasMovedBeyondThreshold;
+    private initialTouchDistance;
+    private isSuspended;
+    constructor(options?: Interaction3DOptions, cameraControls?: CameraControls3D);
+    /**
+     * Attaches interaction listeners to an HTML element (typically a canvas or wrapper).
+     */
+    attach(element: HTMLElement): void;
+    /**
+     * Detaches interaction listeners and cleans up.
+     */
+    detach(): void;
+    /**
+     * Subscribes to interaction state changes.
+     */
+    subscribe(listener: InteractionListener): () => void;
+    /**
+     * Updates suspension state (e.g., when offscreen).
+     */
+    setSuspended(suspended: boolean): void;
+    /**
+     * Programmatic selection control.
+     */
+    select(objectId: string, multi?: boolean): void;
+    deselect(objectId: string): void;
+    clearSelection(): void;
+    getState(): InteractionState3D;
+    getCameraControls(): CameraControls3D;
+    private updateState;
+    private computeNdc;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerLeave;
+    private handleWheel;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    private handleKeyDown;
+}
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * AF Motion 3D Interactive Environment Presets
+ *
+ * Composable environment setups for product showcases, portfolios,
+ * spatial storytelling, and narrative displays.
+ */
+import type { InteractionEnvironmentPreset, InteractionPresetName } from "./types.js";
+export declare const INTERACTION_PRESETS: Record<InteractionPresetName, InteractionEnvironmentPreset>;
+export declare function getInteractionPreset(name: InteractionPresetName): InteractionEnvironmentPreset;

package/dist/3d/interaction/raycaster.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AF Motion 3D Raycasting & Hit Testing Adapters
+ *
+ * Framework-independent spatial hit-testing and optional Three.js Raycaster adapter.
+ */
+import type { Vector3Tuple } from "../types.js";
+import type { RaycastAdapter3D } from "./types.js";
+/**
+ * Creates a basic spatial raycaster that tests against object bounding boxes or positions.
+ */
+export declare function createBoundingBoxRaycaster(objectCatalog?: readonly {
+    id: string;
+    position: Vector3Tuple;
+    radius?: number;
+    userData?: Record<string, unknown>;
+}[]): RaycastAdapter3D;
+/**
+ * Creates an optional Three.js Raycaster adapter using THREE.Raycaster and THREE.Vector2.
+ */
+export declare function createThreeRaycastAdapter(threeInstance?: any, getCamera?: () => any, getScene?: () => any): RaycastAdapter3D;

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

@@ -0,0 +1,78 @@
+/**
+ * AF Motion 3D Interaction Engine Types
+ *
+ * Framework-independent definitions for pointer, touch, keyboard,
+ * raycasting, selection, camera controls, and interaction state.
+ */
+import type { Vector3Tuple } from "../types.js";
+export type PointerInteractionType = "pointerdown" | "pointermove" | "pointerup" | "click" | "pointerenter" | "pointerleave" | "dragstart" | "drag" | "dragend";
+export interface RaycastHit3D {
+    readonly objectId: string;
+    readonly point: Vector3Tuple;
+    readonly distance: number;
+    readonly normal?: Vector3Tuple;
+    readonly meshName?: string;
+    readonly userData?: Record<string, unknown>;
+}
+export interface RaycastAdapter3D {
+    readonly raycast: (ndcX: number, ndcY: number, objects?: readonly unknown[]) => readonly RaycastHit3D[];
+}
+export interface InteractionState3D {
+    readonly hoveredObjectId: string | null;
+    readonly selectedObjectIds: readonly string[];
+    readonly focusedObjectId: string | null;
+    readonly isDragging: boolean;
+    readonly pointerNdc: readonly [number, number];
+    readonly dragDelta: readonly [number, number];
+    readonly activeHits: readonly RaycastHit3D[];
+}
+export interface Interaction3DOptions {
+    readonly dragThreshold?: number;
+    readonly multiSelect?: boolean;
+    readonly enableKeyboard?: boolean;
+    readonly enableHighlight?: boolean;
+    readonly highlightColor?: string;
+    readonly reducedMotion?: boolean;
+    readonly raycaster?: RaycastAdapter3D;
+    readonly onHover?: (objectId: string | null, hit?: RaycastHit3D) => void;
+    readonly onSelect?: (selectedIds: readonly string[]) => void;
+    readonly onClick?: (objectId: string | null, hit?: RaycastHit3D) => void;
+    readonly onDrag?: (delta: readonly [number, number], state: InteractionState3D) => void;
+}
+export type CameraControlMode = "orbit" | "pan" | "zoom" | "combined" | "none";
+export interface CameraControlsConfig {
+    readonly mode?: CameraControlMode;
+    readonly enableOrbit?: boolean;
+    readonly enablePan?: boolean;
+    readonly enableZoom?: boolean;
+    readonly enableDamping?: boolean;
+    readonly dampingFactor?: number;
+    readonly rotateSpeed?: number;
+    readonly panSpeed?: number;
+    readonly zoomSpeed?: number;
+    readonly minDistance?: number;
+    readonly maxDistance?: number;
+    readonly minPolarAngle?: number;
+    readonly maxPolarAngle?: number;
+    readonly minAzimuthAngle?: number;
+    readonly maxAzimuthAngle?: number;
+    readonly target?: Vector3Tuple;
+    readonly autoRotate?: boolean;
+    readonly autoRotateSpeed?: number;
+    readonly reducedMotion?: boolean;
+}
+export interface CameraControlsState {
+    readonly azimuth: number;
+    readonly polar: number;
+    readonly distance: number;
+    readonly target: Vector3Tuple;
+    readonly position: Vector3Tuple;
+    readonly isInteracting: boolean;
+}
+export type InteractionPresetName = "product-showcase" | "portfolio" | "immersive-landing" | "spatial-story" | "object-display" | "scroll-narrative";
+export interface InteractionEnvironmentPreset {
+    readonly name: InteractionPresetName;
+    readonly description: string;
+    readonly cameraControls: CameraControlsConfig;
+    readonly interactionOptions: Interaction3DOptions;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * AF Motion 3D Lighting Intelligence Module
+ */
+export * from "./types.js";
+export * from "./presets.js";
+export * from "./validation.js";

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

@@ -0,0 +1,8 @@
+/**
+ * AF Motion 3D Lighting Presets
+ *
+ * Professional lighting setups: studio, cinematic, dramatic, daylight, sunset, neon, product.
+ */
+import type { IntelligentLightingConfig, LightingPresetName } from "./types.js";
+export declare const LIGHTING_3D_PRESETS: Readonly<Record<LightingPresetName, IntelligentLightingConfig>>;
+export declare function getLighting3DPreset(name: LightingPresetName): IntelligentLightingConfig;

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

@@ -0,0 +1,31 @@
+/**
+ * AF Motion 3D Lighting Intelligence Contracts
+ */
+import type { Lighting3DConfig, Vector3Tuple } from "../types.js";
+export type LightingPresetName = "studio" | "cinematic" | "dramatic" | "daylight" | "sunset" | "neon" | "product";
+export interface HemisphereLightConfig {
+    readonly skyColor?: string;
+    readonly groundColor?: string;
+    readonly intensity?: number;
+}
+export interface AreaLightConfig {
+    readonly color?: string;
+    readonly intensity?: number;
+    readonly width?: number;
+    readonly height?: number;
+    readonly position?: Vector3Tuple;
+}
+export interface Shadow3DConfig {
+    readonly enabled?: boolean;
+    readonly mapSize?: number;
+    readonly bias?: number;
+    readonly radius?: number;
+}
+export type ShadowConfig = Shadow3DConfig;
+export interface IntelligentLightingConfig extends Lighting3DConfig {
+    readonly preset?: LightingPresetName;
+    readonly hemisphere?: HemisphereLightConfig;
+    readonly area?: readonly AreaLightConfig[];
+    readonly shadows?: Shadow3DConfig;
+    readonly environmentIntensity?: number;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * AF Motion 3D Lighting Validation & Fallback Resolution
+ */
+import type { IntelligentLightingConfig } from "./types.js";
+export declare function validateLightingConfig(config: unknown): {
+    valid: boolean;
+    errors: string[];
+};
+export declare function correctLightingConfig(raw: unknown): IntelligentLightingConfig;
+/**
+ * Gracefully fall back unsupported light types (e.g. hemisphere or area lights)
+ * to standard ambient/point/directional lights.
+ */
+export declare function resolveLightingFallbacks(config: IntelligentLightingConfig, supported?: {
+    readonly hemisphere?: boolean;
+    readonly area?: boolean;
+}): IntelligentLightingConfig;

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

@@ -0,0 +1,11 @@
+/**
+ * AF Motion 2D Surface to 3D Material Bridge
+ *
+ * Maps Prompt 72 2D surface concepts into 3D physically based material specifications.
+ */
+import type { SurfaceDefinition } from "../../graphics/materials/types.js";
+import type { IntelligentMaterial3DConfig } from "./types.js";
+/**
+ * Convert a Prompt 72 SurfaceDefinition into a 3D material specification.
+ */
+export declare function surfaceToMaterial3D(surface: SurfaceDefinition): IntelligentMaterial3DConfig;

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

@@ -0,0 +1,7 @@
+/**
+ * AF Motion 3D Material Intelligence Module
+ */
+export * from "./types.js";
+export * from "./presets.js";
+export * from "./bridge.js";
+export * from "./validation.js";

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

@@ -0,0 +1,9 @@
+/**
+ * AF Motion 3D Material Presets
+ *
+ * Professional material recipes: chrome, gold, frosted-glass, clear-glass,
+ * matte-plastic, glossy-plastic, velvet, neon-glow.
+ */
+import type { IntelligentMaterial3DConfig, Material3DPresetName } from "./types.js";
+export declare const MATERIAL_3D_PRESETS: Readonly<Record<Material3DPresetName, IntelligentMaterial3DConfig>>;
+export declare function getMaterial3DPreset(name: Material3DPresetName): IntelligentMaterial3DConfig;