af-motion 0.0.0-stage → 1.0.0

package/dist/core/resource-intelligence/types.d.ts

@@ -0,0 +1,232 @@
+/**
+ * AF Motion — Memory & Resource Intelligence Types
+ *
+ * Unified resource taxonomy, ownership contracts, lifecycle states,
+ * memory budget configuration, cache contracts, and diagnostics.
+ */
+/**
+ * Universal resource category classification.
+ */
+export type ResourceCategory = "cpu_buffer" | "typed_array" | "geometry" | "material" | "texture" | "gpu_buffer" | "gpu_texture" | "framebuffer" | "render_target" | "shader_program" | "webgl_resource" | "webgpu_resource" | "physics_body" | "simulation_resource" | "animation_controller" | "event_subscription" | "worker" | "cached_asset";
+/**
+ * Resource lifecycle states.
+ */
+export type ResourceLifecycleState = "created" | "active" | "idle" | "pooled" | "disposing" | "disposed" | "lost";
+/**
+ * Disposal strategy applied when a resource is freed.
+ */
+export type DisposalStrategy = "immediate" | "pooled" | "deferred" | "manual";
+/**
+ * System-wide memory pressure level.
+ */
+export type MemoryPressureLevel = "normal" | "elevated" | "high" | "critical";
+/**
+ * Interface representing an object that can be safely disposed.
+ */
+export interface IDisposable {
+    dispose(): void;
+    readonly id?: string;
+}
+/**
+ * Registration options for adding a resource to the registry.
+ */
+export interface ResourceRegistrationOptions<T = any> {
+    readonly id?: string;
+    readonly category: ResourceCategory;
+    readonly ownerId?: string;
+    readonly scopeId?: string;
+    readonly resource: T;
+    readonly estimatedBytes?: number;
+    readonly disposalStrategy?: DisposalStrategy;
+    readonly onDispose?: (resource: T) => void;
+    readonly dependencies?: readonly string[];
+    readonly isPinned?: boolean;
+    readonly metadata?: Readonly<Record<string, any>>;
+}
+/**
+ * Immutable record representing a tracked resource in the registry.
+ */
+export interface ResourceRecord<T = any> {
+    readonly id: string;
+    readonly category: ResourceCategory;
+    readonly ownerId: string;
+    readonly scopeId?: string;
+    readonly createdAt: number;
+    readonly lastAccessedAt: number;
+    readonly estimatedBytes: number;
+    readonly state: ResourceLifecycleState;
+    readonly refCount: number;
+    readonly disposalStrategy: DisposalStrategy;
+    readonly dependencies: readonly string[];
+    readonly isPinned: boolean;
+    readonly metadata: Readonly<Record<string, any>>;
+}
+/**
+ * Hierarchical cleanup scope tracking resource ownership and child scopes.
+ */
+export interface ResourceScope {
+    readonly id: string;
+    readonly ownerId: string;
+    readonly parentScopeId?: string;
+    readonly childScopeIds: readonly string[];
+    readonly resourceIds: readonly string[];
+    readonly isDisposed: boolean;
+    readonly createdAt: number;
+    dispose(): void;
+}
+/**
+ * Memory budget limits by category.
+ */
+export interface MemoryBudgetConfig {
+    cpuBytes?: number;
+    geometryBytes?: number;
+    textureBytes?: number;
+    gpuBytes?: number;
+    simulationBytes?: number;
+    cacheBytes?: number;
+    temporaryBytes?: number;
+    totalBytes?: number;
+    warningThresholdRatio?: number;
+    criticalThresholdRatio?: number;
+}
+/**
+ * Budget utilization status for a specific category or total.
+ */
+export interface MemoryBudgetStatus {
+    readonly currentBytes: number;
+    readonly limitBytes: number;
+    readonly utilizationRatio: number;
+    readonly status: "normal" | "warning" | "critical";
+}
+/**
+ * Point-in-time snapshot of system memory usage.
+ */
+export interface MemorySnapshot {
+    readonly timestamp: number;
+    readonly isMeasured: boolean;
+    readonly totalEstimatedBytes: number;
+    readonly measuredHeapUsedBytes?: number;
+    readonly measuredHeapTotalBytes?: number;
+    readonly categoryBytes: Readonly<Record<ResourceCategory, number>>;
+    readonly resourceCounts: Readonly<Record<ResourceCategory, number>>;
+    readonly totalTrackedResources: number;
+    readonly activeResourceCount: number;
+    readonly idleResourceCount: number;
+    readonly pooledResourceCount: number;
+    readonly budgetStatuses: Readonly<Record<string, MemoryBudgetStatus>>;
+    readonly memoryPressureLevel: MemoryPressureLevel;
+}
+/**
+ * Suspected memory or resource leak diagnostic item.
+ */
+export interface ResourceLeakItem {
+    readonly resourceId: string;
+    readonly category: ResourceCategory;
+    readonly ownerId: string;
+    readonly ageMs: number;
+    readonly estimatedBytes: number;
+    readonly severity: "low" | "medium" | "high";
+    readonly description: string;
+    readonly suspectedCause: string;
+}
+/**
+ * Statistics reported by a ResourceCache.
+ */
+export interface ResourceCacheStats {
+    readonly entryCount: number;
+    readonly maxEntries: number;
+    readonly estimatedBytes: number;
+    readonly maxBytes: number;
+    readonly hits: number;
+    readonly misses: number;
+    readonly hitRatio: number;
+    readonly evictions: number;
+}
+/**
+ * Consolidated resource intelligence diagnostics report.
+ */
+export interface ResourceIntelligenceReport {
+    readonly timestamp: number;
+    readonly totalTrackedResources: number;
+    readonly resourcesByCategory: Readonly<Record<ResourceCategory, number>>;
+    readonly activeCount: number;
+    readonly idleCount: number;
+    readonly pooledCount: number;
+    readonly totalEstimatedBytes: number;
+    readonly memoryPressureLevel: MemoryPressureLevel;
+    readonly budgetSummary: Readonly<Record<string, MemoryBudgetStatus>>;
+    readonly cacheStats?: ResourceCacheStats;
+    readonly poolStats?: {
+        pooledArraysCount: number;
+        pooledBytes: number;
+    };
+    readonly suspectedLeaks: readonly ResourceLeakItem[];
+    readonly recommendations: readonly string[];
+}
+/**
+ * Contract for Universal Resource Registry.
+ */
+export interface IResourceRegistry {
+    readonly size: number;
+    registerResource<T = any>(options: ResourceRegistrationOptions<T>): string;
+    unregisterResource(resourceId: string, forceDispose?: boolean): boolean;
+    getResourceRecord(resourceId: string): ResourceRecord | undefined;
+    getRawResource<T = any>(resourceId: string): T | undefined;
+    hasResource(resourceId: string): boolean;
+    retainResource(resourceId: string): number;
+    releaseResource(resourceId: string): number;
+    transferResourceOwnership(resourceId: string, newOwnerId: string): boolean;
+    createResourceScope(ownerId?: string, parentScopeId?: string): ResourceScope;
+    disposeResourceScope(scopeId: string): boolean;
+    disposeResource(resourceId: string): boolean;
+    getAllRecords(): readonly ResourceRecord[];
+    getRecordsByCategory(category: ResourceCategory): readonly ResourceRecord[];
+    getRecordsByOwner(ownerId: string): readonly ResourceRecord[];
+    disposeAll(): void;
+}
+/**
+ * Contract for Memory Monitor.
+ */
+export interface IMemoryMonitor {
+    readonly latestSnapshot: MemorySnapshot;
+    captureSnapshot(): MemorySnapshot;
+    getHistoricalSnapshots(): readonly MemorySnapshot[];
+    configureBudgets(config: Partial<MemoryBudgetConfig>): void;
+    getBudgetStatus(category?: string): MemoryBudgetStatus;
+    getOverallPressureLevel(): MemoryPressureLevel;
+    reset(): void;
+    dispose(): void;
+}
+/**
+ * Contract for Resource Cache.
+ */
+export interface IResourceCache<K = string, V = any> {
+    readonly size: number;
+    get(key: K): V | undefined;
+    set(key: K, value: V, estimatedBytes?: number, ttlMs?: number): void;
+    has(key: K): boolean;
+    pin(key: K): boolean;
+    unpin(key: K): boolean;
+    isPinned(key: K): boolean;
+    invalidate(key: K): boolean;
+    trimToMemoryLimit(targetBytes?: number): number;
+    clear(): void;
+    getStats(): ResourceCacheStats;
+    dispose(): void;
+}
+/**
+ * Contract for Memory Pressure Controller.
+ */
+export interface IMemoryPressureController {
+    readonly currentPressure: MemoryPressureLevel;
+    evaluatePressure(snapshot?: MemorySnapshot): MemoryPressureLevel;
+    setPressure(level: MemoryPressureLevel): void;
+    onPressureChange(listener: (level: MemoryPressureLevel) => void): {
+        unsubscribe: () => void;
+    };
+    respondToPressure(level?: MemoryPressureLevel): {
+        cacheEntriesEvicted: number;
+        bytesReclaimed: number;
+    };
+    dispose(): void;
+}

package/dist/core/scene-generation/engine.d.ts

@@ -0,0 +1,31 @@
+/**
+ * AF Motion AI Scene Generation Master Engine (Prompt 143)
+ *
+ * Coordinates the full AI Scene Generation pipeline:
+ * Scene Description → Scene Understanding → Scene Planning → Object Generation →
+ * Animation Planning → Composition Assembly → Validation → Multi-Target Export.
+ *
+ * Deterministic, offline-capable, and framework-independent.
+ */
+import type { AISceneGenerationInput, AISceneGenerationOptions, GeneratedSceneResult, IAISceneGenerationProvider } from "./types.js";
+export declare class AISceneGenerationEngine implements IAISceneGenerationProvider {
+    readonly id = "af-motion-ai-scene-generation-engine";
+    readonly name = "AF Motion AI Scene Generation Engine";
+    private readonly cache;
+    private readonly maxCacheSize;
+    constructor(options?: {
+        maxCacheSize?: number;
+    });
+    /**
+     * Generates a complete scene synchronously.
+     */
+    generateSync(input: AISceneGenerationInput, options?: AISceneGenerationOptions): GeneratedSceneResult;
+    /**
+     * Generates a complete scene asynchronously with timeout/abort support.
+     */
+    generate(input: AISceneGenerationInput, options?: AISceneGenerationOptions): Promise<GeneratedSceneResult>;
+    clearCache(): void;
+    private computeCacheKey;
+    private putCache;
+}
+export declare const aiSceneGenerationEngine: AISceneGenerationEngine;

package/dist/core/scene-generation/generator.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AF Motion AI Scene Generator & Multi-Target Exporter (Prompt 143)
+ *
+ * Translates Planned Scenes into:
+ * 1. MotionComposition instances (core DOM / cross-system orchestration)
+ * 2. Scene3DSpecification (3D scenes with camera, lights, materials)
+ * 3. Multi-target code exports (React, Vanilla TS, Scene JSON, CSS tokens)
+ */
+import type { StructuredSceneSpecification, ScenePlan, AISceneExportArtifacts } from "./types.js";
+import { type MotionComposition } from "../composition.js";
+import type { Scene3DSpecification } from "../../3d/schemas/types.js";
+export declare function generateSceneComposition(spec: StructuredSceneSpecification, plan: ScenePlan): MotionComposition;
+export declare function generateScene3DSpec(spec: StructuredSceneSpecification): Scene3DSpecification | undefined;
+export declare function generateSceneExportArtifacts(spec: StructuredSceneSpecification, composition: MotionComposition, scene3dSpec?: Scene3DSpecification): AISceneExportArtifacts;

package/dist/core/scene-generation/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AF Motion AI Scene Generation Subsystem (Prompt 143)
+ *
+ * Transforms scene descriptions and structured scene specifications into
+ * complete, multi-system animated AF Motion scenes (DOM, 3D, physics, particles).
+ */
+export * from "./types.js";
+export * from "./input-parser.js";
+export * from "./scene-analyzer.js";
+export * from "./scene-planner.js";
+export * from "./generator.js";
+export * from "./validator.js";
+export * from "./presets.js";
+export * from "./engine.js";

package/dist/core/scene-generation/input-parser.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AF Motion AI Scene Input Parser (Prompt 143)
+ *
+ * Normalizes natural-language scene descriptions, structured scene specifications,
+ * and design tokens into a validated, deterministic scene input representation.
+ */
+import type { AISceneGenerationInput, SceneCategory, StructuredSceneSpecification, MotionDNAPersonalityOption } from "./types.js";
+export interface NormalizedSceneInput {
+    readonly rawPrompt?: string;
+    readonly category: SceneCategory;
+    readonly motionDNA: MotionDNAPersonalityOption;
+    readonly paletteName: string;
+    readonly paletteColors: {
+        readonly primary: string;
+        readonly secondary: string;
+        readonly accent: string;
+        readonly background: string;
+    };
+    readonly timingMultiplier: number;
+    readonly reducedMotion: boolean;
+    readonly partialSpec?: Partial<StructuredSceneSpecification>;
+    readonly validationIssues: readonly string[];
+}
+export declare function parseAndNormalizeSceneInput(input: AISceneGenerationInput): NormalizedSceneInput;

package/dist/core/scene-generation/presets.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AF Motion AI Scene Generation Presets (Prompt 143)
+ *
+ * 10 curated scene generation templates covering 3D heroes, product showcases,
+ * physics playgrounds, ambient particle fields, portfolios, and kinetic storytelling.
+ */
+import type { AIScenePreset } from "./types.js";
+export declare const AI_SCENE_PRESETS: readonly AIScenePreset[];
+export declare function listAIScenePresets(): readonly AIScenePreset[];
+export declare function getAIScenePreset(id: string): AIScenePreset | undefined;

package/dist/core/scene-generation/react.d.ts

@@ -0,0 +1,13 @@
+import type { AISceneGenerationInput, AISceneGenerationOptions, GeneratedSceneResult } from "./types.js";
+export interface UseAISceneGenerationReturn {
+    readonly result: GeneratedSceneResult | null;
+    readonly isGenerating: boolean;
+    readonly error: string | null;
+    readonly input: AISceneGenerationInput;
+    readonly setInput: (input: AISceneGenerationInput | ((prev: AISceneGenerationInput) => AISceneGenerationInput)) => void;
+    readonly generate: (overrideInput?: AISceneGenerationInput) => Promise<GeneratedSceneResult | null>;
+    readonly applyPreset: (presetId: string) => void;
+    readonly activePresetId: string | null;
+    readonly clear: () => void;
+}
+export declare function useAISceneGeneration(initialInput?: AISceneGenerationInput, options?: AISceneGenerationOptions): UseAISceneGenerationReturn;

package/dist/core/scene-generation/scene-analyzer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * AF Motion AI Scene Analyzer (Prompt 143)
+ *
+ * Performs deep semantic scene understanding, identifying primary subjects,
+ * spatial relationships, multi-system participation, and performance constraints.
+ */
+import type { NormalizedSceneInput } from "./input-parser.js";
+import type { SceneUnderstandingResult } from "./types.js";
+export declare function analyzeSceneSpecification(normalized: NormalizedSceneInput): SceneUnderstandingResult;

package/dist/core/scene-generation/scene-planner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AF Motion AI Scene Planning Engine (Prompt 143)
+ *
+ * Coordinates spatial layout, layer depth, lighting, particles, camera framing,
+ * and choreographed animation sequences influenced by Motion DNA personalities.
+ */
+import type { NormalizedSceneInput } from "./input-parser.js";
+import type { SceneUnderstandingResult, ScenePlan, StructuredSceneSpecification } from "./types.js";
+export declare function planSceneExecution(understanding: SceneUnderstandingResult, normalized: NormalizedSceneInput): {
+    plan: ScenePlan;
+    spec: StructuredSceneSpecification;
+};

package/dist/core/scene-generation/types.d.ts

@@ -0,0 +1,236 @@
+/**
+ * AF Motion AI Scene & Animation Generation Types (Prompt 143)
+ *
+ * Data contracts for transforming natural-language scene descriptions and
+ * structured scene specifications into complete, animated, multi-system AF Motion scenes.
+ */
+import type { MotionComposition } from "../composition.js";
+import type { Scene3DSpecification } from "../../3d/schemas/types.js";
+import type { AIMotionIntentType, QualityFinding, IntelligentMotionRecommendation, MotionQualityEvaluationResult } from "../ai-motion-intelligence/types.js";
+import type { MotionDNAPersonalityOption } from "../design-to-motion/types.js";
+export type { MotionDNAPersonalityOption } from "../design-to-motion/types.js";
+export declare const SCENE_GENERATION_SPEC_VERSION = "1.0.0";
+export type SceneCategory = "hero" | "product-showcase" | "interactive-interface" | "portfolio" | "cinematic-sequence" | "physics-playground" | "particle-environment" | "3d-world" | "scroll-storytelling";
+export type SceneObjectType = "dom-element" | "text" | "card" | "shape" | "3d-object" | "particle-system" | "physics-body" | "camera" | "light";
+export type SceneLayerId = "background" | "middleground" | "foreground" | "overlay";
+export interface SceneObjectTransform {
+    readonly position: readonly [number, number, number];
+    readonly rotation?: readonly [number, number, number];
+    readonly scale?: readonly [number, number, number] | number;
+}
+export interface SceneObjectVisuals {
+    readonly color?: string;
+    readonly opacity?: number;
+    readonly roughness?: number;
+    readonly metalness?: number;
+    readonly geometryType?: "box" | "sphere" | "cylinder" | "torus" | "plane";
+    readonly dimensions?: readonly [number, number, number?];
+}
+export interface SceneObjectAnimation {
+    readonly entrance?: {
+        readonly properties: readonly string[];
+        readonly from: Record<string, unknown>;
+        readonly to: Record<string, unknown>;
+        readonly durationMs: number;
+        readonly delayMs: number;
+        readonly easing: string;
+    };
+    readonly ambient?: {
+        readonly type: "float" | "rotate" | "pulse" | "drift" | "orbit";
+        readonly amplitude?: number;
+        readonly speed?: number;
+        readonly axis?: "x" | "y" | "z" | "all";
+    };
+    readonly exit?: {
+        readonly properties: readonly string[];
+        readonly to: Record<string, unknown>;
+        readonly durationMs: number;
+        readonly easing: string;
+    };
+}
+export interface SceneObjectInteraction {
+    readonly hover?: {
+        readonly scale?: number;
+        readonly elevateZ?: number;
+        readonly highlightColor?: string;
+    };
+    readonly clickOrPress?: {
+        readonly triggerEffect?: "pulse" | "explode" | "modal" | "select";
+        readonly recoil?: number;
+    };
+    readonly draggable?: boolean;
+    readonly magnetic?: {
+        readonly radius: number;
+        readonly strength: number;
+    };
+}
+export interface ScenePhysicsConfig {
+    readonly mass: number;
+    readonly restitution: number;
+    readonly friction: number;
+    readonly isStatic?: boolean;
+    readonly colliderType?: "box" | "sphere" | "capsule" | "mesh";
+}
+export interface SceneParticleConfig {
+    readonly count: number;
+    readonly speed: number;
+    readonly color: string;
+    readonly size: number;
+    readonly spread: number;
+    readonly shape?: "points" | "stars" | "bubbles" | "glow-orbs";
+}
+export interface SceneObjectDefinition {
+    readonly id: string;
+    readonly name: string;
+    readonly type: SceneObjectType;
+    readonly layer: SceneLayerId;
+    readonly parentId?: string;
+    readonly transform: SceneObjectTransform;
+    readonly visuals?: SceneObjectVisuals;
+    readonly animation?: SceneObjectAnimation;
+    readonly interaction?: SceneObjectInteraction;
+    readonly physics?: ScenePhysicsConfig;
+    readonly particles?: SceneParticleConfig;
+    readonly enabled?: boolean;
+}
+export interface SceneCameraDefinition {
+    readonly type: "perspective" | "orthographic";
+    readonly fov?: number;
+    readonly position: readonly [number, number, number];
+    readonly target?: readonly [number, number, number];
+    readonly interactive?: boolean;
+}
+export interface SceneLightingDefinition {
+    readonly ambientColor: string;
+    readonly ambientIntensity: number;
+    readonly directionalColor?: string;
+    readonly directionalIntensity?: number;
+    readonly directionalPosition?: readonly [number, number, number];
+    readonly pointLightColor?: string;
+    readonly pointLightPosition?: readonly [number, number, number];
+}
+export interface SceneEnvironmentDefinition {
+    readonly backgroundType: "color" | "gradient" | "particles" | "aurora" | "3d-skybox";
+    readonly backgroundColor: string;
+    readonly fogColor?: string;
+    readonly fogDensity?: number;
+    readonly particleField?: SceneParticleConfig;
+}
+export interface StructuredSceneSpecification {
+    readonly id: string;
+    readonly name: string;
+    readonly version: string;
+    readonly category: SceneCategory;
+    readonly canvasDimensions: {
+        readonly width: number;
+        readonly height: number;
+        readonly isResponsive: boolean;
+    };
+    readonly camera: SceneCameraDefinition;
+    readonly lighting: SceneLightingDefinition;
+    readonly environment: SceneEnvironmentDefinition;
+    readonly objects: readonly SceneObjectDefinition[];
+    readonly motionDNA: MotionDNAPersonalityOption;
+    readonly paletteName: string;
+    readonly timingMultiplier: number;
+    readonly reducedMotion: boolean;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface SceneNaturalLanguageInput {
+    readonly prompt: string;
+    readonly categoryHint?: SceneCategory;
+    readonly targetDNA?: MotionDNAPersonalityOption;
+    readonly targetPalette?: string;
+}
+export interface AISceneGenerationInput {
+    readonly naturalLanguage?: SceneNaturalLanguageInput | string;
+    readonly specification?: Partial<StructuredSceneSpecification>;
+    readonly paletteName?: string;
+    readonly motionDNA?: MotionDNAPersonalityOption;
+    readonly timingMultiplier?: number;
+    readonly reducedMotion?: boolean;
+}
+export interface SceneUnderstandingResult {
+    readonly category: SceneCategory;
+    readonly primarySubject: string;
+    readonly supportingElements: readonly string[];
+    readonly requiredSystems: {
+        readonly has3D: boolean;
+        readonly hasParticles: boolean;
+        readonly hasPhysics: boolean;
+        readonly hasDOM: boolean;
+        readonly hasInteractions: boolean;
+    };
+    readonly inferredIntent: AIMotionIntentType;
+    readonly intentConfidence: number;
+    readonly spatialComplexity: "minimal" | "moderate" | "rich";
+    readonly evidence: readonly string[];
+    readonly warnings: readonly string[];
+}
+export interface ScenePlan {
+    readonly id: string;
+    readonly name: string;
+    readonly summary: string;
+    readonly category: SceneCategory;
+    readonly layers: readonly SceneLayerId[];
+    readonly durationMs: number;
+    readonly matchedPatternIds: readonly string[];
+    readonly objectCount: number;
+    readonly systemParticipation: {
+        readonly animation: boolean;
+        readonly background: boolean;
+        readonly scene3d: boolean;
+        readonly physics: boolean;
+        readonly interactions: boolean;
+        readonly simulations: boolean;
+    };
+}
+export interface AISceneExportArtifacts {
+    readonly reactCode: string;
+    readonly vanillaCode: string;
+    readonly sceneJson: string;
+    readonly compositionJson: string;
+    readonly scene3dJson?: string;
+    readonly cssTokens: Record<string, string>;
+}
+export interface GeneratedSceneResult {
+    readonly id: string;
+    readonly sourceInput: AISceneGenerationInput;
+    readonly understanding: SceneUnderstandingResult;
+    readonly plan: ScenePlan;
+    readonly specification: StructuredSceneSpecification;
+    readonly composition: MotionComposition;
+    readonly scene3dSpec?: Scene3DSpecification;
+    readonly validation: {
+        readonly isValid: boolean;
+        readonly qualityScore: number;
+        readonly qualityGrade: string;
+        readonly detailedScore: MotionQualityEvaluationResult;
+        readonly findings: readonly QualityFinding[];
+        readonly recommendations: readonly IntelligentMotionRecommendation[];
+    };
+    readonly exportArtifacts: AISceneExportArtifacts;
+    readonly generatedAt: number;
+}
+export interface AIScenePreset {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly category: SceneCategory;
+    readonly defaultDNA: MotionDNAPersonalityOption;
+    readonly defaultPalette: string;
+    readonly defaultInput: AISceneGenerationInput;
+    readonly capabilities: readonly string[];
+}
+export interface AISceneGenerationOptions {
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+    readonly maxObjects?: number;
+    readonly forceReducedMotion?: boolean;
+}
+export interface IAISceneGenerationProvider {
+    readonly id: string;
+    readonly name: string;
+    generate(input: AISceneGenerationInput, options?: AISceneGenerationOptions): Promise<GeneratedSceneResult>;
+    generateSync(input: AISceneGenerationInput, options?: AISceneGenerationOptions): GeneratedSceneResult;
+}

package/dist/core/scene-generation/validator.d.ts

@@ -0,0 +1,18 @@
+/**
+ * AF Motion AI Scene Validation Pipeline (Prompt 143)
+ *
+ * Validates complete scenes, object relationships, multi-system compatibility,
+ * accessibility constraints, and runs Prompt 141's quality evaluation & recommendations.
+ */
+import type { StructuredSceneSpecification } from "./types.js";
+import type { MotionComposition } from "../composition.js";
+import type { QualityFinding, IntelligentMotionRecommendation, MotionQualityEvaluationResult } from "../ai-motion-intelligence/types.js";
+export interface SceneValidationResult {
+    readonly isValid: boolean;
+    readonly qualityScore: number;
+    readonly qualityGrade: string;
+    readonly detailedScore: MotionQualityEvaluationResult;
+    readonly findings: readonly QualityFinding[];
+    readonly recommendations: readonly IntelligentMotionRecommendation[];
+}
+export declare function validateGeneratedScene(spec: StructuredSceneSpecification, composition: MotionComposition): SceneValidationResult;