agentic-qe 1.1.0 → 1.3.0

package/dist/core/neural/types.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Neural Training Type Definitions
+ *
+ * Types for AgentDB-powered neural training with 9 RL algorithms
+ */
+/**
+ * Reinforcement Learning Algorithms
+ */
+export type RLAlgorithm = 'decision-transformer' | 'q-learning' | 'sarsa' | 'actor-critic' | 'ppo' | 'ddpg' | 'td3' | 'sac' | 'dqn';
+/**
+ * Neural Configuration
+ */
+export interface NeuralConfig {
+    /** Enable neural training */
+    enabled: boolean;
+    /** RL algorithm to use */
+    algorithm: RLAlgorithm;
+    /** Learning rate */
+    learningRate: number;
+    /** Training batch size */
+    batchSize: number;
+    /** Number of training epochs */
+    epochs: number;
+    /** Validation split (0-1) */
+    validationSplit: number;
+    /** Save model every N episodes */
+    modelSaveInterval: number;
+    /** Create checkpoint every N episodes */
+    checkpointInterval: number;
+    /** Maximum number of checkpoints to keep */
+    maxCheckpoints: number;
+    /** Use GPU acceleration if available */
+    useGPU: boolean;
+    /** Experience replay buffer size */
+    memorySize: number;
+    /** Discount factor (gamma) for future rewards */
+    gamma: number;
+    /** Exploration rate (epsilon) */
+    epsilon: number;
+    /** Soft update coefficient (tau) for target networks */
+    tau: number;
+}
+/**
+ * State representation
+ */
+export interface State {
+    /** Task complexity (0-1) */
+    taskComplexity?: number;
+    /** Required capabilities */
+    capabilities?: string[];
+    /** Context features */
+    contextFeatures?: Record<string, any>;
+    /** Resource availability (0-1) */
+    resourceAvailability?: number;
+    /** Previous attempts count */
+    previousAttempts?: number;
+    /** Custom state features */
+    [key: string]: any;
+}
+/**
+ * Action representation
+ */
+export interface Action {
+    /** Action type */
+    type: string;
+    /** Action parameters */
+    parameters: Record<string, any>;
+    /** Predicted Q-value (optional) */
+    qValue?: number;
+}
+/**
+ * Experience for training
+ */
+export interface Experience {
+    /** Unique experience ID */
+    id?: string;
+    /** Current state */
+    state: State;
+    /** Action taken */
+    action: Action;
+    /** Reward received */
+    reward: number;
+    /** Next state after action */
+    nextState: State;
+    /** Episode done flag */
+    done: boolean;
+    /** Q-value (optional) */
+    qValue?: number;
+    /** Timestamp */
+    timestamp?: Date;
+}
+/**
+ * Training metrics
+ */
+export interface TrainingMetrics {
+    /** Algorithm used */
+    algorithm: RLAlgorithm;
+    /** Training loss */
+    loss: number;
+    /** Validation loss (optional) */
+    valLoss?: number;
+    /** Number of epochs completed */
+    epochs: number;
+    /** Number of experiences used */
+    experienceCount: number;
+    /** Training duration (ms) */
+    duration: number;
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Prediction result
+ */
+export interface PredictionResult {
+    /** Predicted best action */
+    action: Action;
+    /** Confidence score (0-1) */
+    confidence: number;
+    /** Predicted Q-value */
+    qValue: number;
+    /** Algorithm used */
+    algorithm: RLAlgorithm;
+    /** Alternative actions */
+    alternativeActions: Array<{
+        action: Action;
+        qValue: number;
+        confidence: number;
+    }>;
+}
+/**
+ * Trained model
+ */
+export interface Model {
+    /** Model ID */
+    id: string;
+    /** Algorithm used */
+    algorithm: RLAlgorithm;
+    /** Agent ID */
+    agentId: string;
+    /** Episode count when saved */
+    episodeCount: number;
+    /** Experience count when saved */
+    experienceCount: number;
+    /** Training metrics history */
+    metrics: Array<{
+        algorithm: RLAlgorithm;
+        latestMetrics: TrainingMetrics;
+    }>;
+    /** Configuration used */
+    config: NeuralConfig;
+    /** Save timestamp */
+    savedAt: Date;
+    /** Model version */
+    version: string;
+}
+/**
+ * Model checkpoint
+ */
+export interface ModelCheckpoint {
+    /** Checkpoint ID */
+    id: string;
+    /** Episode count at checkpoint */
+    episodeCount: number;
+    /** Algorithm at checkpoint */
+    algorithm: RLAlgorithm;
+    /** Metrics at checkpoint */
+    metrics: TrainingMetrics;
+    /** Checkpoint timestamp */
+    timestamp: Date;
+}
+/**
+ * Neural training result
+ */
+export interface NeuralTrainingResult {
+    /** Algorithm used */
+    algorithm: RLAlgorithm;
+    /** Training metrics */
+    metrics: TrainingMetrics;
+    /** Total episode count */
+    episodeCount: number;
+    /** Model updated flag */
+    modelUpdated: boolean;
+    /** Training duration (ms) */
+    duration: number;
+}
+/**
+ * Neural training options
+ */
+export interface NeuralTrainingOptions {
+    /** Override epochs */
+    epochs?: number;
+    /** Override batch size */
+    batchSize?: number;
+    /** Override learning rate */
+    learningRate?: number;
+    /** Save model after training */
+    saveModel?: boolean;
+    /** Create checkpoint after training */
+    createCheckpoint?: boolean;
+}
+/**
+ * Experience collection config
+ */
+export interface ExperienceCollectionConfig {
+    /** Enable experience collection */
+    enabled: boolean;
+    /** Collect every N tasks */
+    collectionInterval: number;
+    /** Minimum reward to collect */
+    minReward?: number;
+    /** Maximum experiences to buffer */
+    maxBuffer: number;
+    /** Auto-train when buffer full */
+    autoTrain: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/neural/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/neural/types.ts"],"names":[],"mappings":"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"}

package/dist/core/neural/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Neural Training Type Definitions
+ *
+ * Types for AgentDB-powered neural training with 9 RL algorithms
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/core/neural/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/neural/types.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}

package/dist/core/quantization/QuantizationManager.d.ts

@@ -0,0 +1,83 @@
+/**
+ * QuantizationManager - Centralized Vector Quantization management
+ * Provides utilities for optimal quantization selection, monitoring, and tuning
+ */
+export type QuantizationType = 'scalar' | 'binary' | 'product' | 'none';
+export interface QuantizationMetrics {
+    type: QuantizationType;
+    memoryReduction: number;
+    estimatedAccuracyLoss: number;
+    searchSpeedIncrease: number;
+    memoryUsageMB: number;
+    vectorCount: number;
+    timestamp: Date;
+}
+export interface QuantizationRecommendation {
+    type: QuantizationType;
+    reason: string;
+    expectedBenefits: {
+        memoryReduction: string;
+        speedIncrease: string;
+        accuracyImpact: string;
+    };
+    useCase: string;
+}
+export interface AgentProfile {
+    vectorCount: number;
+    memoryConstraint?: 'low' | 'medium' | 'high';
+    accuracyPriority?: 'low' | 'medium' | 'high' | 'critical';
+    speedPriority?: 'low' | 'medium' | 'high' | 'critical';
+    deployment?: 'cloud' | 'edge' | 'mobile' | 'desktop';
+}
+export declare class QuantizationManager {
+    private static metricsHistory;
+    /**
+     * Get optimal quantization type based on agent profile
+     */
+    static getRecommendation(profile: AgentProfile): QuantizationRecommendation;
+    /**
+     * Calculate memory usage for given configuration
+     */
+    static calculateMemoryUsage(vectorCount: number, dimensions?: number, quantizationType?: QuantizationType): {
+        bytesPerVector: number;
+        totalMB: number;
+        reduction: string;
+    };
+    /**
+     * Record quantization metrics for monitoring
+     */
+    static recordMetrics(agentId: string, metrics: QuantizationMetrics): void;
+    /**
+     * Get metrics for an agent
+     */
+    static getMetrics(agentId: string): QuantizationMetrics[];
+    /**
+     * Get aggregated metrics across all agents
+     */
+    static getAggregatedMetrics(): {
+        totalVectors: number;
+        totalMemoryMB: number;
+        averageMemoryReduction: number;
+        quantizationTypes: Record<QuantizationType, number>;
+    };
+    /**
+     * Compare quantization types side-by-side
+     */
+    static compareQuantizationTypes(vectorCount: number, dimensions?: number): Array<{
+        type: QuantizationType;
+        memoryMB: number;
+        reduction: string;
+        speedMultiplier: string;
+        accuracyLoss: string;
+        recommended: boolean;
+    }>;
+    /**
+     * Generate quantization report for diagnostics
+     */
+    static generateReport(): string;
+    /**
+     * Clear all metrics (for testing)
+     */
+    static clearMetrics(): void;
+}
+//# sourceMappingURL=QuantizationManager.d.ts.map

package/dist/core/quantization/QuantizationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuantizationManager.d.ts","sourceRoot":"","sources":["../../../src/core/quantization/QuantizationManager.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAC;AAExE,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,gBAAgB,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,gBAAgB,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE;QAChB,eAAe,EAAE,MAAM,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC7C,gBAAgB,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IAC1D,aAAa,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACvD,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAC;CACtD;AAED,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAC,cAAc,CAAiD;IAE9E;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,0BAA0B;IAoG3E;;OAEG;IACH,MAAM,CAAC,oBAAoB,CACzB,WAAW,EAAE,MAAM,EACnB,UAAU,GAAE,MAAY,EACxB,gBAAgB,GAAE,gBAA2B,GAC5C;QAAE,cAAc,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAqCjE;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAazE;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB,EAAE;IAIzD;;OAEG;IACH,MAAM,CAAC,oBAAoB,IAAI;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,iBAAiB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;KACrD;IA+BD;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,GAAE,MAAY,GAAG,KAAK,CAAC;QACpF,IAAI,EAAE,gBAAgB,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,OAAO,CAAC;KACtB,CAAC;IA0CF;;OAEG;IACH,MAAM,CAAC,cAAc,IAAI,MAAM;IAwB/B;;OAEG;IACH,MAAM,CAAC,YAAY,IAAI,IAAI;CAG5B"}

package/dist/core/quantization/QuantizationManager.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * QuantizationManager - Centralized Vector Quantization management
+ * Provides utilities for optimal quantization selection, monitoring, and tuning
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantizationManager = void 0;
+class QuantizationManager {
+    /**
+     * Get optimal quantization type based on agent profile
+     */
+    static getRecommendation(profile) {
+        const { vectorCount, memoryConstraint, accuracyPriority, speedPriority, deployment } = profile;
+        // Critical accuracy requirement - no quantization
+        if (accuracyPriority === 'critical') {
+            return {
+                type: 'none',
+                reason: 'Critical accuracy requirement demands full precision',
+                expectedBenefits: {
+                    memoryReduction: '1x (no reduction)',
+                    speedIncrease: '1x (baseline)',
+                    accuracyImpact: '0% loss'
+                },
+                useCase: 'Production systems requiring maximum accuracy'
+            };
+        }
+        // Mobile/Edge deployment - aggressive compression
+        if (deployment === 'mobile' || deployment === 'edge' || memoryConstraint === 'low') {
+            return {
+                type: 'binary',
+                reason: 'Mobile/edge deployment requires aggressive memory optimization',
+                expectedBenefits: {
+                    memoryReduction: '32x (e.g., 3GB → 96MB)',
+                    speedIncrease: '10x faster search',
+                    accuracyImpact: '2-5% loss (95-98% accuracy)'
+                },
+                useCase: 'Mobile apps, edge devices, low-memory environments'
+            };
+        }
+        // Large scale (1M+ vectors) - product quantization
+        if (vectorCount > 1000000) {
+            return {
+                type: 'product',
+                reason: 'Large-scale deployment benefits from product quantization',
+                expectedBenefits: {
+                    memoryReduction: '8-16x (e.g., 3GB → 192MB)',
+                    speedIncrease: '5x faster search',
+                    accuracyImpact: '3-7% loss (93-97% accuracy)'
+                },
+                useCase: 'Large-scale vector databases (>1M vectors)'
+            };
+        }
+        // High speed priority - binary or product
+        if (speedPriority === 'critical' || speedPriority === 'high') {
+            return {
+                type: vectorCount > 100000 ? 'product' : 'binary',
+                reason: 'High speed priority requires aggressive optimization',
+                expectedBenefits: {
+                    memoryReduction: vectorCount > 100000 ? '8-16x' : '32x',
+                    speedIncrease: vectorCount > 100000 ? '5x' : '10x',
+                    accuracyImpact: vectorCount > 100000 ? '3-7% loss' : '2-5% loss'
+                },
+                useCase: 'Real-time search, low-latency applications'
+            };
+        }
+        // Medium scale (10K-1M vectors) - scalar quantization (RECOMMENDED DEFAULT)
+        if (vectorCount >= 10000 && vectorCount <= 1000000) {
+            return {
+                type: 'scalar',
+                reason: 'Balanced performance/accuracy for medium-scale deployment',
+                expectedBenefits: {
+                    memoryReduction: '4x (e.g., 3GB → 768MB)',
+                    speedIncrease: '3x faster search',
+                    accuracyImpact: '1-2% loss (98-99% accuracy)'
+                },
+                useCase: 'Production applications, medium datasets (10K-1M vectors)'
+            };
+        }
+        // Small scale (<10K vectors) - no quantization needed
+        if (vectorCount < 10000) {
+            return {
+                type: 'none',
+                reason: 'Small dataset doesn\'t benefit significantly from quantization',
+                expectedBenefits: {
+                    memoryReduction: '1x (no reduction)',
+                    speedIncrease: '1x (baseline)',
+                    accuracyImpact: '0% loss'
+                },
+                useCase: 'Development, small datasets (<10K vectors)'
+            };
+        }
+        // Default recommendation - scalar (safe choice)
+        return {
+            type: 'scalar',
+            reason: 'Balanced default choice for general use',
+            expectedBenefits: {
+                memoryReduction: '4x',
+                speedIncrease: '3x',
+                accuracyImpact: '1-2% loss'
+            },
+            useCase: 'General-purpose applications'
+        };
+    }
+    /**
+     * Calculate memory usage for given configuration
+     */
+    static calculateMemoryUsage(vectorCount, dimensions = 768, quantizationType = 'scalar') {
+        const float32BytesPerDim = 4;
+        const baseBytes = dimensions * float32BytesPerDim;
+        let bytesPerVector;
+        let reductionFactor;
+        switch (quantizationType) {
+            case 'binary':
+                bytesPerVector = Math.ceil(dimensions / 8); // 1 bit per dimension
+                reductionFactor = 32;
+                break;
+            case 'scalar':
+                bytesPerVector = dimensions; // uint8 per dimension
+                reductionFactor = 4;
+                break;
+            case 'product':
+                bytesPerVector = Math.ceil(dimensions / 16); // Product quantization ~16x
+                reductionFactor = 16;
+                break;
+            case 'none':
+            default:
+                bytesPerVector = baseBytes;
+                reductionFactor = 1;
+                break;
+        }
+        const totalBytes = vectorCount * bytesPerVector;
+        const totalMB = totalBytes / (1024 * 1024);
+        return {
+            bytesPerVector,
+            totalMB: Math.round(totalMB * 100) / 100,
+            reduction: reductionFactor === 1 ? 'none' : `${reductionFactor}x`
+        };
+    }
+    /**
+     * Record quantization metrics for monitoring
+     */
+    static recordMetrics(agentId, metrics) {
+        if (!this.metricsHistory.has(agentId)) {
+            this.metricsHistory.set(agentId, []);
+        }
+        this.metricsHistory.get(agentId).push(metrics);
+        // Keep only last 100 metrics per agent
+        const history = this.metricsHistory.get(agentId);
+        if (history.length > 100) {
+            history.shift();
+        }
+    }
+    /**
+     * Get metrics for an agent
+     */
+    static getMetrics(agentId) {
+        return this.metricsHistory.get(agentId) || [];
+    }
+    /**
+     * Get aggregated metrics across all agents
+     */
+    static getAggregatedMetrics() {
+        let totalVectors = 0;
+        let totalMemoryMB = 0;
+        let totalReduction = 0;
+        let count = 0;
+        const quantizationTypes = {
+            none: 0,
+            scalar: 0,
+            binary: 0,
+            product: 0
+        };
+        for (const metrics of this.metricsHistory.values()) {
+            if (metrics.length > 0) {
+                const latest = metrics[metrics.length - 1];
+                totalVectors += latest.vectorCount;
+                totalMemoryMB += latest.memoryUsageMB;
+                totalReduction += latest.memoryReduction;
+                count++;
+                quantizationTypes[latest.type]++;
+            }
+        }
+        return {
+            totalVectors,
+            totalMemoryMB: Math.round(totalMemoryMB * 100) / 100,
+            averageMemoryReduction: count > 0 ? totalReduction / count : 1,
+            quantizationTypes
+        };
+    }
+    /**
+     * Compare quantization types side-by-side
+     */
+    static compareQuantizationTypes(vectorCount, dimensions = 768) {
+        const types = ['none', 'scalar', 'binary', 'product'];
+        const profile = { vectorCount };
+        const recommendation = this.getRecommendation(profile);
+        return types.map(type => {
+            const { totalMB, reduction } = this.calculateMemoryUsage(vectorCount, dimensions, type);
+            let speedMultiplier;
+            let accuracyLoss;
+            switch (type) {
+                case 'binary':
+                    speedMultiplier = '10x';
+                    accuracyLoss = '2-5%';
+                    break;
+                case 'scalar':
+                    speedMultiplier = '3x';
+                    accuracyLoss = '1-2%';
+                    break;
+                case 'product':
+                    speedMultiplier = '5x';
+                    accuracyLoss = '3-7%';
+                    break;
+                case 'none':
+                default:
+                    speedMultiplier = '1x';
+                    accuracyLoss = '0%';
+                    break;
+            }
+            return {
+                type,
+                memoryMB: totalMB,
+                reduction,
+                speedMultiplier,
+                accuracyLoss,
+                recommended: type === recommendation.type
+            };
+        });
+    }
+    /**
+     * Generate quantization report for diagnostics
+     */
+    static generateReport() {
+        const aggregated = this.getAggregatedMetrics();
+        const report = [
+            '═══════════════════════════════════════════════════════════',
+            '           VECTOR QUANTIZATION REPORT',
+            '═══════════════════════════════════════════════════════════',
+            '',
+            '📊 AGGREGATE METRICS:',
+            `  Total Vectors: ${aggregated.totalVectors.toLocaleString()}`,
+            `  Total Memory Usage: ${aggregated.totalMemoryMB.toFixed(2)} MB`,
+            `  Average Reduction: ${aggregated.averageMemoryReduction.toFixed(1)}x`,
+            '',
+            '🔧 QUANTIZATION DISTRIBUTION:',
+            `  None (Full Precision): ${aggregated.quantizationTypes.none} agents`,
+            `  Scalar (4x):           ${aggregated.quantizationTypes.scalar} agents`,
+            `  Binary (32x):          ${aggregated.quantizationTypes.binary} agents`,
+            `  Product (8-16x):       ${aggregated.quantizationTypes.product} agents`,
+            '',
+            '═══════════════════════════════════════════════════════════'
+        ];
+        return report.join('\n');
+    }
+    /**
+     * Clear all metrics (for testing)
+     */
+    static clearMetrics() {
+        this.metricsHistory.clear();
+    }
+}
+exports.QuantizationManager = QuantizationManager;
+QuantizationManager.metricsHistory = new Map();
+//# sourceMappingURL=QuantizationManager.js.map

package/dist/core/quantization/QuantizationManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QuantizationManager.js","sourceRoot":"","sources":["../../../src/core/quantization/QuantizationManager.ts"],"names":[],"mappings":"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"}

package/dist/core/quantization/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Vector Quantization exports
+ */
+export { QuantizationManager, type QuantizationType, type QuantizationMetrics, type QuantizationRecommendation, type AgentProfile } from './QuantizationManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/quantization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/quantization/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,KAAK,mBAAmB,EAAE,KAAK,0BAA0B,EAAE,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/core/quantization/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Vector Quantization exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantizationManager = void 0;
+var QuantizationManager_1 = require("./QuantizationManager");
+Object.defineProperty(exports, "QuantizationManager", { enumerable: true, get: function () { return QuantizationManager_1.QuantizationManager; } });
+//# sourceMappingURL=index.js.map

package/dist/core/quantization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/quantization/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,6DAAiK;AAAxJ,0HAAA,mBAAmB,OAAA"}