af-motion 0.0.0-stage → 1.0.0

package/dist/core/physics/validation.d.ts

@@ -0,0 +1,62 @@
+/**
+ * AF Motion — Foundational Physics Validation & Error System
+ *
+ * Implements strict runtime validation and custom error classes for
+ * configuration integrity, state stability, and lifecycle safety.
+ */
+import type { PhysicsConfiguration, PhysicsState } from "./types.js";
+/**
+ * Base error class for all physics engine exceptions.
+ */
+export declare class PhysicsError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a configuration parameter is invalid or out of bounds.
+ */
+export declare class PhysicsValidationError extends PhysicsError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an invalid lifecycle transition or access occurs (e.g. stepping a disposed simulation).
+ */
+export declare class PhysicsLifecycleError extends PhysicsError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when numerical instability, NaN, or infinite values are detected.
+ */
+export declare class PhysicsNumericalError extends PhysicsError {
+    constructor(message: string);
+}
+/**
+ * Structured validation report for physics configuration.
+ */
+export interface PhysicsValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+}
+/**
+ * Validates a physics configuration object.
+ */
+export declare function validatePhysicsConfig(config: unknown): PhysicsValidationResult;
+/**
+ * Asserts that a configuration is valid, throwing PhysicsValidationError if invalid.
+ */
+export declare function assertValidPhysicsConfig(config: unknown): asserts config is PhysicsConfiguration;
+/**
+ * Validates a physics state object.
+ */
+export declare function validatePhysicsState(state: unknown): PhysicsValidationResult;
+/**
+ * Asserts that a physics state is valid, throwing PhysicsValidationError if invalid.
+ */
+export declare function assertValidPhysicsState(state: unknown): asserts state is PhysicsState;
+/**
+ * Safely applies safe corrections to a partial physics configuration.
+ */
+export declare function correctPhysicsConfig(config?: Partial<PhysicsConfiguration>): {
+    corrected: Required<PhysicsConfiguration>;
+    corrections: string[];
+};

package/dist/core/pointer-capture.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Best-effort pointer capture shared by effects on the same element. Capture is only released
+ * once every effect that acquired it has released it, so one effect finishing never cancels
+ * another effect's active gesture.
+ */
+export declare function acquirePointerCapture(element: HTMLElement, pointerId: number): void;
+export declare function releasePointerCapture(element: HTMLElement, pointerId: number): void;

package/dist/core/reference-analysis/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * AF Motion Reference Analysis & Reference-to-React Engine
+ *
+ * Framework-independent reference analysis, visual style classification,
+ * React implementation planning, and deterministic code specifications.
+ */
+export * from "./types.js";
+export * from "./interpreter.js";
+export * from "./planner.js";
+export * from "./specification.js";

package/dist/core/reference-analysis/interpreter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * AF Motion Visual Reference Interpreter
+ *
+ * Deterministically analyzes structured visual references, classifies visual styles
+ * against the 19 supported genres, pairs with the 33 palettes and 5 Motion DNA profiles,
+ * and reports confidence and uncertainty.
+ */
+import type { VisualDesignInterpretation, VisualReferenceInput } from "./types.js";
+/**
+ * Interprets a structured visual reference input into a validated visual design interpretation.
+ */
+export declare function interpretVisualReference(input: VisualReferenceInput): VisualDesignInterpretation;

package/dist/core/reference-analysis/planner.d.ts

@@ -0,0 +1,15 @@
+/**
+ * AF Motion Reference-to-React Planning Engine
+ *
+ * Translates visual interpretations into structured React implementation plans:
+ * - Component hierarchies with minimal AF Motion bindings
+ * - Responsive layouts and breakpoint shifts
+ * - Motion plans honoring Motion DNA and accessibility defaults
+ * - Graphics and 3D orchestration
+ * - Asset requirements and validation checklists
+ */
+import type { ReactImplementationPlan, VisualDesignInterpretation, VisualReferenceInput } from "./types.js";
+/**
+ * Generates an end-to-end React implementation plan from a visual reference or interpretation.
+ */
+export declare function generateReactImplementationPlan(inputOrInterpretation: VisualReferenceInput | VisualDesignInterpretation): ReactImplementationPlan;

package/dist/core/reference-analysis/specification.d.ts

@@ -0,0 +1,14 @@
+/**
+ * AF Motion Reference-to-React Specification Engine
+ *
+ * Emits framework-independent React code generation specifications:
+ * - Deterministic component blueprints
+ * - Normalized AF Motion imports partitioned by official subpaths
+ * - Global CSS custom properties
+ * - Non-executable code templates for coding agents
+ */
+import type { ReactCodeSpecification, ReactImplementationPlan } from "./types.js";
+/**
+ * Generates an end-to-end React code generation specification from an implementation plan.
+ */
+export declare function generateReactSpecification(plan: ReactImplementationPlan): ReactCodeSpecification;

package/dist/core/reference-analysis/types.d.ts

@@ -0,0 +1,244 @@
+/**
+ * AF Motion Reference-to-React Implementation Contracts
+ *
+ * Framework-independent types for analyzing structured visual reference data,
+ * classifying visual styles and palettes, generating React implementation plans,
+ * and producing deterministic code generation specifications.
+ */
+export type VisualStyleName = "minimal" | "glassmorphism" | "brutalist" | "brutalism" | "neumorphism" | "claymorphism" | "cyberpunk" | "editorial" | "swiss" | "bauhaus" | "aurora" | "steampunk" | "skeuomorphism" | "vaporwave" | "psychedelic" | "liquid" | "neon" | "retro-computing" | string;
+export type MotionDNAPersonality = "precise" | "playful" | "elegant" | "energetic" | "editorial-flow" | "snappy" | "calm" | "cinematic" | "minimal";
+export type ReferenceTargetPlatform = "web" | "mobile" | "responsive";
+export interface ExtractedColorRole {
+    role: "background" | "primary" | "secondary" | "accent" | "surface" | "text" | "muted";
+    value: string;
+}
+export interface ExtractedTypography {
+    headingFont?: string;
+    bodyFont?: string;
+    codeFont?: string;
+    scale?: "compact" | "normal" | "editorial" | "dramatic";
+    weights?: number[];
+}
+export interface ExtractedSurface {
+    name: string;
+    kind: "glass" | "flat" | "neumorphic" | "metallic" | "clay" | "brutalist" | "glow";
+    blur?: number;
+    opacity?: number;
+    borderWidth?: string | number;
+    borderColor?: string;
+    boxShadow?: string;
+}
+export interface ExtractedLayout {
+    type: "single-column" | "split" | "grid" | "dashboard" | "sticky-story" | "hero-showcase";
+    columns?: number;
+    alignment?: "left" | "center" | "right";
+    spacingDensity?: "compact" | "normal" | "spacious";
+    hasStickyElements?: boolean;
+}
+export interface ExtractedMotionCharacteristics {
+    feel?: "snappy" | "bouncy" | "smooth" | "dramatic" | "minimal";
+    speed?: "fast" | "normal" | "slow";
+    hasParallax?: boolean;
+    hasStagger?: boolean;
+    hasSpringFeedback?: boolean;
+    hasPageTransitions?: boolean;
+}
+export interface ExtractedGraphics {
+    hasBackgroundEffect?: boolean;
+    effectType?: "aurora" | "particles" | "mesh-gradient" | "waves" | "noise" | "cosmic";
+    isInteractive?: boolean;
+}
+export interface Extracted3D {
+    has3DScene?: boolean;
+    geometryType?: "torus" | "sphere" | "box" | "custom-model";
+    materialType?: "glass" | "metallic" | "pbr" | "wireframe";
+    interactiveControls?: boolean;
+}
+export interface ExtractedVisualProperties {
+    dominantColors?: string[];
+    colorRoles?: ExtractedColorRole[];
+    paletteName?: string;
+    typography?: ExtractedTypography;
+    surfaces?: ExtractedSurface[];
+    shadows?: string[];
+    borderRadius?: string | number;
+    layout?: ExtractedLayout;
+    motion?: ExtractedMotionCharacteristics;
+    graphics?: ExtractedGraphics;
+    scene3D?: Extracted3D;
+}
+export interface ExtractedComponent {
+    id: string;
+    name: string;
+    role: "header" | "hero" | "card" | "button" | "input" | "grid" | "footer" | "navigation" | "modal" | "graphic-canvas" | "viewport-3d";
+    description?: string;
+    properties?: Record<string, unknown>;
+    children?: ExtractedComponent[];
+}
+export interface ReferenceMetadata {
+    sourceType?: "json-tokens" | "structured-analysis" | "user-prompt" | "design-system";
+    author?: string;
+    timestamp?: number;
+    fidelity?: "wireframe" | "concept" | "high-fidelity";
+}
+export interface VisualReferenceInput {
+    name: string;
+    description?: string;
+    extractedProperties?: ExtractedVisualProperties;
+    components?: ExtractedComponent[];
+    targetPlatform?: ReferenceTargetPlatform;
+    metadata?: ReferenceMetadata;
+}
+export interface UncertaintyArea {
+    property: string;
+    reason: string;
+    assumedDefault: unknown;
+    confidence: number;
+}
+export interface ConfidenceReport {
+    overallScore: number;
+    styleConfidence: number;
+    paletteConfidence: number;
+    motionConfidence: number;
+    uncertaintyAreas: UncertaintyArea[];
+}
+export interface StyleClassificationResult {
+    style: VisualStyleName;
+    confidence: number;
+    reasoning: string;
+    alternatives: VisualStyleName[];
+}
+export interface PaletteMappingResult {
+    matchedPaletteId: string;
+    matchedPaletteName: string;
+    colors: Record<string, string>;
+    confidence: number;
+}
+export interface MotionDNAMappingResult {
+    matchedDNA: MotionDNAPersonality;
+    timingMultiplier: number;
+    confidence: number;
+    reasoning: string;
+}
+export interface DesignTokenMapping {
+    colors: Record<string, string>;
+    radii: Record<string, string>;
+    shadows: Record<string, string>;
+    spacing: Record<string, string>;
+    fonts: Record<string, string>;
+}
+export interface VisualDesignInterpretation {
+    referenceName: string;
+    styleClassification: StyleClassificationResult;
+    paletteMapping: PaletteMappingResult;
+    motionDNA: MotionDNAMappingResult;
+    designTokens: DesignTokenMapping;
+    surfaces: ExtractedSurface[];
+    layout: ExtractedLayout;
+    graphics?: ExtractedGraphics;
+    scene3D?: Extracted3D;
+    capabilitiesRequired: string[];
+    confidenceReport: ConfidenceReport;
+}
+export interface PlannedComponentNode {
+    id: string;
+    name: string;
+    category: "layout" | "content" | "interactive" | "canvas" | "3d";
+    afMotionBinding?: {
+        component?: string;
+        hook?: string;
+        subpath: "af-motion" | "af-motion/react" | "af-motion/catalogue" | "af-motion/presets";
+        config?: Record<string, unknown>;
+    };
+    props: Record<string, unknown>;
+    children?: PlannedComponentNode[];
+}
+export interface PlannedMotionItem {
+    id: string;
+    targetId: string;
+    trigger: "mount" | "scroll" | "hover" | "press" | "continuous";
+    capability: string;
+    family: string;
+    durationMs: number;
+    easing: string;
+    delayMs?: number;
+    reducedMotionFallback: "instant" | "opacity" | "disabled";
+}
+export interface ResponsiveStrategy {
+    mobileFirst: boolean;
+    breakpoints: Record<string, string>;
+    layoutShifts: Record<string, string>;
+}
+export interface PlannedGraphicsAnd3D {
+    backgroundCanvas?: {
+        effect: "aurora" | "particleField" | "cosmic" | "waves";
+        subpath: "af-motion";
+        interactive: boolean;
+    };
+    viewport3D?: {
+        geometry: string;
+        material: string;
+        lighting: string;
+        controls: boolean;
+    };
+}
+export interface AssetRequirement {
+    id: string;
+    type: "image" | "font" | "icon" | "3d-model";
+    description: string;
+    fallback: string;
+}
+export interface AccessibilityRequirement {
+    rule: string;
+    strategy: string;
+    verified: boolean;
+}
+export interface ReactImplementationPlan {
+    id: string;
+    title: string;
+    componentHierarchy: PlannedComponentNode[];
+    responsiveStrategy: ResponsiveStrategy;
+    visualStyleConfig: {
+        style: VisualStyleName;
+        palette: string;
+        motionDNA: MotionDNAPersonality;
+    };
+    motionPlans: PlannedMotionItem[];
+    graphicsAnd3D: PlannedGraphicsAnd3D;
+    assetRequirements: AssetRequirement[];
+    accessibilityRequirements: AccessibilityRequirement[];
+    validationChecklist: string[];
+}
+export interface ReactComponentSpec {
+    name: string;
+    fileHint: string;
+    isClientComponent: boolean;
+    responsibilities: string[];
+    props: {
+        name: string;
+        type: string;
+        optional?: boolean;
+    }[];
+    state: {
+        name: string;
+        type: string;
+        initialValue: string;
+    }[];
+    afMotionImports: {
+        name: string;
+        subpath: string;
+    }[];
+    jsxBlueprint: string;
+}
+export interface ReactCodeSpecification {
+    planId: string;
+    title: string;
+    components: ReactComponentSpec[];
+    requiredImports: {
+        subpath: string;
+        namedImports: string[];
+    }[];
+    globalCSSVariables: Record<string, string>;
+    accessibilityNotes: string[];
+    codeTemplate: string;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * AF Motion — Intelligent Resource Cache
+ *
+ * Implements deterministic LRU eviction, TTL expiration, memory budget clamping,
+ * resource pinning protection, and hit/miss observability.
+ */
+import type { IResourceCache, ResourceCacheStats, IResourceRegistry } from "./types.js";
+export interface ResourceCacheOptions {
+    maxEntries?: number;
+    maxBytes?: number;
+    defaultTtlMs?: number;
+    registry?: IResourceRegistry;
+    ownerId?: string;
+}
+export declare class ResourceCache<K = string, V = any> implements IResourceCache<K, V> {
+    private readonly _entries;
+    private readonly _maxEntries;
+    private readonly _maxBytes;
+    private readonly _defaultTtlMs?;
+    private readonly _registry?;
+    private readonly _ownerId;
+    private _accessSequence;
+    private _hits;
+    private _misses;
+    private _evictions;
+    private _totalBytes;
+    private _isDisposed;
+    constructor(options?: ResourceCacheOptions);
+    get 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;
+    private enforceCapacityLimits;
+}
+export declare function createResourceCache<K = string, V = any>(options?: ResourceCacheOptions): ResourceCache<K, V>;

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

@@ -0,0 +1,19 @@
+/**
+ * AF Motion — GPU Resource Intelligence & Context Lifecycle
+ *
+ * WebGL and WebGPU context loss resilience, texture/buffer lifecycle tracking,
+ * and safe disposal that avoids crashes when underlying GPU contexts are invalidated.
+ */
+import type { IResourceRegistry } from "./types.js";
+export declare class GpuResourceIntelligence {
+    private readonly _registry;
+    private _isContextLost;
+    constructor(registry: IResourceRegistry);
+    get isContextLost(): boolean;
+    handleContextLost(): void;
+    handleContextRestored(): void;
+    safeGpuDispose(resource: {
+        dispose?: () => void;
+        deleteBuffer?: () => void;
+    }): void;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * AF Motion — Memory & Resource Intelligence Engine
+ *
+ * Framework-independent resource lifecycle tracking, hierarchical scopes,
+ * memory budgeting, intelligent caching, pooling safety, leak detection,
+ * GPU resilience, and React integration.
+ */
+export * from "./types.js";
+export * from "./registry.js";
+export * from "./memory.js";
+export * from "./cache.js";
+export * from "./pooling.js";
+export * from "./leaks.js";
+export * from "./gpu.js";
+export * from "./pressure.js";
+export * from "./reports.js";

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

@@ -0,0 +1,13 @@
+/**
+ * AF Motion — Resource Leak Detection Diagnostics
+ *
+ * Deterministically analyzes registered resources to detect abandoned scopes,
+ * unreleased temporary allocations, unbalanced reference counts, and GPU leaks.
+ */
+import type { IResourceRegistry, ResourceLeakItem } from "./types.js";
+export interface LeakDetectionOptions {
+    temporaryMaxAgeMs?: number;
+    idleMaxAgeMs?: number;
+    maxExpectedRefCount?: number;
+}
+export declare function detectResourceLeaks(registry: IResourceRegistry, options?: LeakDetectionOptions): readonly ResourceLeakItem[];

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

@@ -0,0 +1,27 @@
+/**
+ * AF Motion — Memory Intelligence & Budget Manager
+ *
+ * Quantifies memory consumption across typed arrays, geometry buffers, textures,
+ * GPU allocations, and caches. Enforces configurable category budgets and pressure states.
+ */
+import type { IMemoryMonitor, IResourceRegistry, MemoryBudgetConfig, MemoryBudgetStatus, MemorySnapshot, MemoryPressureLevel } from "./types.js";
+export declare const DEFAULT_MEMORY_BUDGETS: MemoryBudgetConfig;
+export declare class MemoryMonitor implements IMemoryMonitor {
+    private readonly _registry;
+    private readonly _budgets;
+    private readonly _snapshots;
+    private readonly _maxSnapshots;
+    private _isDisposed;
+    constructor(registry: IResourceRegistry, budgets?: Partial<MemoryBudgetConfig>);
+    get latestSnapshot(): MemorySnapshot;
+    captureSnapshot(): MemorySnapshot;
+    getHistoricalSnapshots(): readonly MemorySnapshot[];
+    configureBudgets(config: Partial<MemoryBudgetConfig>): void;
+    getBudgetStatus(category?: string): MemoryBudgetStatus;
+    getOverallPressureLevel(): MemoryPressureLevel;
+    reset(): void;
+    dispose(): void;
+    private computeBudgetStatus;
+    private pushSnapshot;
+}
+export declare function createMemoryMonitor(registry: IResourceRegistry, budgets?: Partial<MemoryBudgetConfig>): MemoryMonitor;

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

@@ -0,0 +1,32 @@
+/**
+ * AF Motion — Resource Pooling Intelligence
+ *
+ * Integrates directly with sharedBufferPool and TypedArrayPool to provide
+ * use-after-release protection, detached buffer safety, and pool memory statistics.
+ */
+import { TypedArrayPool } from "../../graphics/simulation/optimizer.js";
+import type { IResourceRegistry } from "./types.js";
+export interface PoolStats {
+    activeAcquiredCount: number;
+    totalAcquiredBytes: number;
+    doubleReleaseAttempts: number;
+    detachedBuffersDetected: number;
+}
+export declare class SafeBufferPoolManager {
+    private readonly _pool;
+    private readonly _registry?;
+    private readonly _activeFloatBuffers;
+    private readonly _activeUintBuffers;
+    private _acquiredCount;
+    private _acquiredBytes;
+    private _doubleReleaseAttempts;
+    private _detachedDetected;
+    constructor(pool?: TypedArrayPool, registry?: IResourceRegistry);
+    acquireFloat32(length: number): Float32Array;
+    releaseFloat32(arr: Float32Array): boolean;
+    acquireUint32(length: number): Uint32Array;
+    releaseUint32(arr: Uint32Array): boolean;
+    getStats(): PoolStats;
+    clear(): void;
+}
+export declare const safeBufferPoolManager: SafeBufferPoolManager;

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

@@ -0,0 +1,32 @@
+/**
+ * AF Motion — Memory Pressure Controller
+ *
+ * Evaluates multi-level memory pressure (normal, elevated, high, critical)
+ * and triggers coordinated cache trimming, pool reclamation, and quality adjustments.
+ */
+import type { IMemoryPressureController, MemoryPressureLevel, MemorySnapshot, IResourceCache } from "./types.js";
+import type { IAdaptiveQualityController } from "../adaptive-quality/types.js";
+export interface MemoryPressureControllerOptions {
+    cache?: IResourceCache;
+    adaptiveQualityController?: IAdaptiveQualityController;
+}
+export declare class MemoryPressureController implements IMemoryPressureController {
+    private _currentPressure;
+    private readonly _listeners;
+    private readonly _cache?;
+    private readonly _adaptiveQualityController?;
+    private _isDisposed;
+    constructor(options?: MemoryPressureControllerOptions);
+    get 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;
+}
+export declare function createMemoryPressureController(options?: MemoryPressureControllerOptions): MemoryPressureController;

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

@@ -0,0 +1,63 @@
+/**
+ * AF Motion — React Resource & Memory Intelligence Hooks
+ *
+ * React 18 & 19 compatible hooks and components with Strict Mode safety,
+ * SSR safety, and automatic unmount scope cleanup.
+ */
+import { type ReactNode } from "react";
+import type { IResourceRegistry, ResourceScope, MemorySnapshot, MemoryPressureLevel, ResourceIntelligenceReport, ResourceRegistrationOptions } from "./types.js";
+import { ResourceRegistry } from "./registry.js";
+import { MemoryMonitor } from "./memory.js";
+import { MemoryPressureController } from "./pressure.js";
+export declare const defaultResourceRegistry: ResourceRegistry;
+export declare const defaultMemoryMonitor: MemoryMonitor;
+export declare const defaultPressureController: MemoryPressureController;
+export declare const ResourceRegistryContext: import("react").Context<IResourceRegistry>;
+export declare const ResourceScopeContext: import("react").Context<ResourceScope | null>;
+/**
+ * Hook providing a dedicated, automatically disposed ResourceScope tied to component lifecycle.
+ */
+export declare function useResourceScope(ownerId?: string): {
+    scope: ResourceScope;
+    register: <T>(options: Omit<ResourceRegistrationOptions<T>, "scopeId">) => string;
+    dispose: () => void;
+};
+/**
+ * Hook providing reactive MemoryMonitor access and snapshots.
+ */
+export declare function useMemoryMonitor(customRegistry?: IResourceRegistry): {
+    snapshot: MemorySnapshot;
+    capture: () => MemorySnapshot;
+    pressureLevel: MemoryPressureLevel;
+};
+/**
+ * Hook returning point-in-time MemorySnapshot.
+ */
+export declare function useMemorySnapshot(): MemorySnapshot;
+/**
+ * Hook returning consolidated ResourceIntelligenceReport.
+ */
+export declare function useResourceReport(): ResourceIntelligenceReport;
+/**
+ * Hook to observe live system MemoryPressureLevel.
+ */
+export declare function useMemoryPressure(): MemoryPressureLevel;
+/**
+ * Component boundary establishing an isolated ResourceScope for descendants.
+ */
+export declare function ResourceScopeBoundary({ ownerId, children, }: {
+    ownerId?: string;
+    children?: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<ResourceScope | null>>;
+/**
+ * Headless memory monitoring component.
+ */
+export declare function MemoryMonitorComponent({ onPressureChange, children, }: {
+    onPressureChange?: (level: MemoryPressureLevel) => void;
+    children?: ReactNode;
+}): import("react").DetailedReactHTMLElement<{
+    "data-af-memory-monitor": string;
+    style: {
+        display: "contents";
+    };
+}, HTMLElement>;

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

@@ -0,0 +1,33 @@
+/**
+ * AF Motion — Universal Resource Registry & Ownership Engine
+ *
+ * Tracks cross-system resource lifecycles, manages hierarchical cleanup scopes,
+ * handles reference counting and ownership transfer, and guarantees idempotent,
+ * dependency-ordered disposal.
+ */
+import type { IResourceRegistry, ResourceCategory, ResourceRecord, ResourceRegistrationOptions, ResourceScope } from "./types.js";
+export declare class ResourceRegistry implements IResourceRegistry {
+    private readonly _entries;
+    private readonly _scopes;
+    private _sequence;
+    private _isDisposed;
+    get 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;
+    private toRecord;
+    private createScopeHandle;
+}
+export declare function createResourceRegistry(): ResourceRegistry;

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

@@ -0,0 +1,14 @@
+/**
+ * AF Motion — Resource Intelligence Diagnostics & Reporting
+ *
+ * Compiles comprehensive system reports covering tracked resource counts,
+ * memory breakdowns, cache/pool telemetry, and actionable health recommendations.
+ */
+import type { IResourceRegistry, IMemoryMonitor, IMemoryPressureController, IResourceCache, ResourceIntelligenceReport } from "./types.js";
+export interface ResourceReportOptions {
+    registry: IResourceRegistry;
+    memoryMonitor?: IMemoryMonitor;
+    pressureController?: IMemoryPressureController;
+    cache?: IResourceCache;
+}
+export declare function getResourceReport(options: ResourceReportOptions): ResourceIntelligenceReport;