rag-lite-ts 2.1.1 → 2.3.0

package/dist/esm/core/vector-index.js

@@ -0,0 +1,344 @@
+/**
+ * CORE MODULE — Shared between text-only (rag-lite-ts) and future multimodal (rag-lite-mm)
+ * Model-agnostic. No transformer or modality-specific logic.
+ *
+ * Worker-based implementation to prevent WebAssembly memory accumulation.
+ */
+import { Worker } from 'worker_threads';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { handleError, ErrorCategory, ErrorSeverity, createError } from './error-handler.js';
+import { createMissingFileError, createDimensionMismatchError } from './actionable-error-messages.js';
+export class VectorIndex {
+    worker = null;
+    indexPath;
+    options;
+    messageQueue = new Map();
+    messageId = 0;
+    isInitialized = false;
+    constructor(indexPath, options) {
+        this.indexPath = indexPath;
+        this.options = {
+            efConstruction: 200,
+            M: 16,
+            seed: 100,
+            ...options
+        };
+    }
+    /**
+     * Get the path to the worker script
+     * Always uses compiled .js files - workers cannot execute TypeScript directly
+     */
+    getWorkerPath() {
+        const currentFile = fileURLToPath(import.meta.url);
+        const currentDir = dirname(currentFile);
+        // Always prefer .js (compiled output)
+        const jsPath = join(currentDir, 'vector-index-worker.js');
+        // Check if .js exists in current directory (compiled)
+        if (existsSync(jsPath)) {
+            return jsPath;
+        }
+        // If running from src/ (development), try dist/ paths
+        if (currentDir.includes('src')) {
+            // Find project root (go up from src/core)
+            const projectRoot = currentDir.replace(/[\\/]src[\\/]core.*$/, '');
+            const distEsmPath = join(projectRoot, 'dist', 'esm', 'core', 'vector-index-worker.js');
+            const distCjsPath = join(projectRoot, 'dist', 'cjs', 'core', 'vector-index-worker.js');
+            if (existsSync(distEsmPath)) {
+                return distEsmPath;
+            }
+            if (existsSync(distCjsPath)) {
+                return distCjsPath;
+            }
+        }
+        // If running from node_modules (installed package), try dist paths
+        if (currentDir.includes('node_modules')) {
+            const packageRoot = currentDir.split('node_modules')[0];
+            const distEsmPath = join(packageRoot, 'node_modules', 'rag-lite-ts', 'dist', 'esm', 'core', 'vector-index-worker.js');
+            const distCjsPath = join(packageRoot, 'node_modules', 'rag-lite-ts', 'dist', 'cjs', 'core', 'vector-index-worker.js');
+            if (existsSync(distEsmPath)) {
+                return distEsmPath;
+            }
+            if (existsSync(distCjsPath)) {
+                return distCjsPath;
+            }
+        }
+        // Final fallback - will fail with clear error
+        throw new Error(`Worker file not found. Expected: ${jsPath}\n` +
+            'Please run "npm run build" to compile the vector-index-worker.ts file.\n' +
+            `Current directory: ${currentDir}\n` +
+            `Checked paths: ${jsPath}, ${currentDir.includes('src') ? join(currentDir.replace(/[\\/]src[\\/]core.*$/, ''), 'dist', 'esm', 'core', 'vector-index-worker.js') : 'N/A'}`);
+    }
+    /**
+     * Ensure worker is created and ready
+     */
+    async ensureWorker() {
+        if (this.worker) {
+            return;
+        }
+        const workerPath = this.getWorkerPath();
+        this.worker = new Worker(workerPath);
+        // Set up message handler
+        this.worker.on('message', (response) => {
+            const handler = this.messageQueue.get(response.id);
+            if (handler) {
+                this.messageQueue.delete(response.id);
+                if (response.type === 'error') {
+                    handler.reject(new Error(response.error || 'Unknown error'));
+                }
+                else {
+                    handler.resolve(response.payload);
+                }
+            }
+        });
+        // Handle worker errors
+        this.worker.on('error', (error) => {
+            console.error('VectorIndex worker error:', error);
+            // Reject all pending requests
+            for (const [id, handler] of this.messageQueue.entries()) {
+                handler.reject(error);
+            }
+            this.messageQueue.clear();
+        });
+        // Handle worker exit
+        this.worker.on('exit', (code) => {
+            if (code !== 0) {
+                console.error(`VectorIndex worker exited with code ${code}`);
+            }
+            // Reject all pending requests
+            for (const [id, handler] of this.messageQueue.entries()) {
+                handler.reject(new Error(`Worker exited with code ${code}`));
+            }
+            this.messageQueue.clear();
+            this.worker = null;
+            this.isInitialized = false;
+        });
+    }
+    /**
+     * Send a message to the worker and wait for response
+     */
+    async sendMessage(type, payload) {
+        await this.ensureWorker();
+        return new Promise((resolve, reject) => {
+            const id = this.messageId++;
+            this.messageQueue.set(id, { resolve, reject });
+            const request = { id, type, payload };
+            this.worker.postMessage(request);
+        });
+    }
+    /**
+     * Convert Float32Array to ArrayBuffer for transfer
+     */
+    float32ArrayToBuffer(vector) {
+        const buffer = vector.buffer.slice(vector.byteOffset, vector.byteOffset + vector.byteLength);
+        // Ensure we return ArrayBuffer, not SharedArrayBuffer
+        return buffer instanceof ArrayBuffer ? buffer : new ArrayBuffer(0);
+    }
+    /**
+     * Initialize the HNSW index with cosine similarity using hnswlib-wasm
+     */
+    async initialize() {
+        try {
+            const payload = {
+                dimensions: this.options.dimensions,
+                maxElements: this.options.maxElements,
+                M: this.options.M,
+                efConstruction: this.options.efConstruction,
+                seed: this.options.seed,
+                indexPath: this.indexPath // Pass indexPath to worker for saveIndex operations
+            };
+            await this.sendMessage('init', payload);
+            this.isInitialized = true;
+            console.log(`Initialized HNSW index with ${this.options.dimensions} dimensions using hnswlib-wasm (worker)`);
+        }
+        catch (error) {
+            handleError(createError.index(`Failed to initialize vector index: ${error instanceof Error ? error.message : String(error)}`), 'Vector Index Initialization', {
+                category: ErrorCategory.INDEX,
+                severity: ErrorSeverity.FATAL
+            });
+            throw error;
+        }
+    }
+    /**
+     * Load existing index from file using hnswlib-wasm
+     */
+    async loadIndex() {
+        if (!existsSync(this.indexPath)) {
+            throw createMissingFileError(this.indexPath, 'index', {
+                operationContext: 'VectorIndex.loadIndex'
+            });
+        }
+        try {
+            const payload = {
+                indexPath: this.indexPath
+            };
+            const result = await this.sendMessage('loadIndex', payload);
+            this.isInitialized = true;
+            console.log(`✓ Loaded HNSW index with ${result.count} vectors from ${this.indexPath} (worker)`);
+        }
+        catch (error) {
+            throw new Error(`Failed to load index from ${this.indexPath}: ${error}`);
+        }
+    }
+    /**
+     * Save index to binary format
+     */
+    async saveIndex() {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        try {
+            const result = await this.sendMessage('saveIndex');
+            const actualSize = result.count;
+            console.log(`✓ Saved HNSW index with ${actualSize} vectors (${(actualSize * this.options.dimensions * 4 / 1024).toFixed(2)} KB of vector data) to ${this.indexPath} (worker)`);
+        }
+        catch (error) {
+            throw new Error(`Failed to save index to ${this.indexPath}: ${error}`);
+        }
+    }
+    /**
+     * Add a single vector to the HNSW index
+     * Now async due to worker-based implementation
+     */
+    async addVector(embeddingId, vector) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        if (vector.length !== this.options.dimensions) {
+            throw createDimensionMismatchError(this.options.dimensions, vector.length, 'vector addition', { operationContext: 'VectorIndex.addVector' });
+        }
+        const payload = {
+            id: embeddingId,
+            vector: this.float32ArrayToBuffer(vector),
+            dimensions: vector.length
+        };
+        await this.sendMessage('addVector', payload);
+    }
+    /**
+     * Add multiple vectors to the index in batch
+     * Now async due to worker-based implementation
+     */
+    async addVectors(vectors) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        const payload = {
+            vectors: vectors.map(v => ({
+                id: v.id,
+                vector: this.float32ArrayToBuffer(v.vector),
+                dimensions: v.vector.length
+            }))
+        };
+        await this.sendMessage('addVectors', payload);
+    }
+    /**
+     * Search for k nearest neighbors using hnswlib-wasm
+     * Now async due to worker-based implementation
+     */
+    async search(queryVector, k = 5) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        if (queryVector.length !== this.options.dimensions) {
+            throw createDimensionMismatchError(this.options.dimensions, queryVector.length, 'vector search', { operationContext: 'VectorIndex.search' });
+        }
+        const payload = {
+            queryVector: this.float32ArrayToBuffer(queryVector),
+            dimensions: queryVector.length,
+            k
+        };
+        const result = await this.sendMessage('search', payload);
+        // Check if empty result
+        if (result.neighbors.length === 0 && result.distances.length === 0) {
+            return { neighbors: [], distances: [] };
+        }
+        return result;
+    }
+    /**
+     * Get current number of vectors in the index
+     * Now async due to worker-based implementation
+     */
+    async getCurrentCount() {
+        if (!this.isInitialized) {
+            return 0;
+        }
+        const result = await this.sendMessage('getCurrentCount');
+        return result.count;
+    }
+    /**
+     * Check if index exists on disk
+     */
+    indexExists() {
+        // This can be synchronous since it's just a file system check
+        return existsSync(this.indexPath);
+    }
+    /**
+     * Set search parameters for query time
+     * Now async due to worker-based implementation
+     */
+    async setEf(ef) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        const payload = { ef };
+        try {
+            await this.sendMessage('setEf', payload);
+        }
+        catch (error) {
+            console.log(`Failed to set ef: ${error}`);
+        }
+    }
+    /**
+     * Resize index to accommodate more vectors
+     * Now async due to worker-based implementation
+     */
+    async resizeIndex(newMaxElements) {
+        if (!this.isInitialized) {
+            throw new Error('Index not initialized');
+        }
+        if (newMaxElements <= this.options.maxElements) {
+            throw new Error(`New max elements (${newMaxElements}) must be greater than current (${this.options.maxElements})`);
+        }
+        const payload = { newMaxElements };
+        await this.sendMessage('resizeIndex', payload);
+        this.options.maxElements = newMaxElements;
+        console.log(`Resized index to accommodate ${newMaxElements} vectors`);
+    }
+    /**
+     * Reset the vector index to an empty state.
+     * Clears all vectors from the HNSW graph and vectorStorage.
+     * The index parameters (dimensions, M, efConstruction) are preserved.
+     */
+    async reset() {
+        console.log('🔄 VectorIndex: Resetting to empty state...');
+        await this.sendMessage('reset');
+        console.log('✓ VectorIndex reset: cleared all vectors');
+    }
+    /**
+     * Get index options (for external access to configuration)
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+    /**
+     * Cleanup: terminate worker and free all WebAssembly memory
+     */
+    async cleanup() {
+        if (this.worker) {
+            try {
+                // Send cleanup message (worker will acknowledge)
+                await this.sendMessage('cleanup');
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
+            // Terminate worker - this frees ALL WebAssembly memory
+            await this.worker.terminate();
+            this.worker = null;
+            this.isInitialized = false;
+            this.messageQueue.clear();
+        }
+    }
+}
+//# sourceMappingURL=vector-index.js.map

package/dist/esm/dom-polyfills.d.ts

@@ -0,0 +1,6 @@
+/**
+ * DOM polyfills for Node.js environment
+ * Required for transformers.js and other browser-dependent libraries
+ */
+export {};
+//# sourceMappingURL=dom-polyfills.d.ts.map

package/dist/esm/dom-polyfills.js

@@ -0,0 +1,37 @@
+/**
+ * DOM polyfills for Node.js environment
+ * Required for transformers.js and other browser-dependent libraries
+ */
+import { JSDOM } from 'jsdom';
+// Only set up polyfills if we're in Node.js (not browser)
+if (typeof window === 'undefined') {
+    console.log('Setting up DOM polyfills for Node.js environment...');
+    // Create a minimal DOM environment
+    const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+        pretendToBeVisual: true,
+        resources: 'usable'
+    });
+    // Set up global objects that transformers.js expects
+    if (typeof globalThis.self === 'undefined') {
+        globalThis.self = globalThis;
+    }
+    // Also set on global for older Node.js versions
+    if (typeof global.self === 'undefined') {
+        global.self = global;
+    }
+    console.log('DOM polyfills set up successfully. self is now:', typeof self !== 'undefined' ? 'defined' : 'undefined');
+    if (typeof globalThis.window === 'undefined') {
+        globalThis.window = dom.window;
+    }
+    if (typeof globalThis.document === 'undefined') {
+        globalThis.document = dom.window.document;
+    }
+    // Additional polyfills that might be needed
+    if (typeof globalThis.navigator === 'undefined') {
+        globalThis.navigator = dom.window.navigator;
+    }
+    // Note: Do NOT polyfill createImageBitmap with a fake implementation
+    // RawImage.fromURL() will handle image loading correctly without it
+    // Setting a fake createImageBitmap that throws errors breaks image loading
+}
+//# sourceMappingURL=dom-polyfills.js.map

package/dist/esm/factories/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Factory exports for creating RAG instances
+ * Provides convenient factory functions for common use cases
+ *
+ * This module serves as the main entry point for factory functions that
+ * simplify the creation of search and ingestion systems.
+ * The factories handle complex initialization while providing clean APIs.
+ *
+ * MAIN FACTORY CLASSES:
+ * - IngestionFactory: Creates IngestionPipeline instances for document ingestion
+ * - SearchFactory: Creates SearchEngine with automatic mode detection (recommended)
+ *
+ * @example
+ * ```typescript
+ * import { IngestionFactory, SearchFactory } from './factories';
+ *
+ * // Create ingestion pipeline
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin');
+ *
+ * // Create search engine with automatic mode detection
+ * const search = await SearchFactory.create('./index.bin', './db.sqlite');
+ * ```
+ */
+export { IngestionFactory } from './ingestion-factory.js';
+export { SearchFactory } from './search-factory.js';
+export type { IngestionFactoryOptions, ContentSystemConfig } from './ingestion-factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/factories/index.js

@@ -0,0 +1,29 @@
+/**
+ * Factory exports for creating RAG instances
+ * Provides convenient factory functions for common use cases
+ *
+ * This module serves as the main entry point for factory functions that
+ * simplify the creation of search and ingestion systems.
+ * The factories handle complex initialization while providing clean APIs.
+ *
+ * MAIN FACTORY CLASSES:
+ * - IngestionFactory: Creates IngestionPipeline instances for document ingestion
+ * - SearchFactory: Creates SearchEngine with automatic mode detection (recommended)
+ *
+ * @example
+ * ```typescript
+ * import { IngestionFactory, SearchFactory } from './factories';
+ *
+ * // Create ingestion pipeline
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin');
+ *
+ * // Create search engine with automatic mode detection
+ * const search = await SearchFactory.create('./index.bin', './db.sqlite');
+ * ```
+ */
+// Main factory classes
+export { IngestionFactory } from './ingestion-factory.js';
+// Polymorphic search factory (recommended for automatic mode detection)
+// Re-exported from core for convenience
+export { SearchFactory } from './search-factory.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/factories/ingestion-factory.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Factory functions for creating text-specific search and ingestion instances
+ * Handles complex initialization logic while providing clean API for common use cases
+ *
+ * FACTORY PATTERN BENEFITS:
+ * - Abstracts complex initialization (model loading, database setup, index initialization)
+ * - Provides simple API for common use cases while preserving access to dependency injection
+ * - Clear validation and error handling without fallback mechanisms
+ * - Supports different embedding models and configurations
+ * - Enables clean separation between simple usage and advanced customization
+ *
+ * MODE SELECTION GUIDE:
+ * - Text Mode (default): Optimized for text-only content
+ *   - Uses sentence-transformer models (fast, accurate for text)
+ *   - Images converted to text descriptions
+ *   - Best for: document search, text clustering, semantic similarity
+ *
+ * - Multimodal Mode: Optimized for mixed text/image content
+ *   - Uses CLIP models (unified embedding space)
+ *   - True cross-modal search (text finds images, images find text)
+ *   - Best for: image search, visual QA, multimodal retrieval
+ *
+ * USAGE PATTERNS:
+ *
+ * 1. Mode Selection:
+ * ```typescript
+ * // Text mode (default) - optimized for text-only content
+ * const textIngestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
+ *   mode: 'text',
+ *   embeddingModel: 'sentence-transformers/all-MiniLM-L6-v2'
+ * });
+ *
+ * // Multimodal mode - enables cross-modal search
+ * const multimodalIngestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
+ *   mode: 'multimodal',
+ *   embeddingModel: 'Xenova/clip-vit-base-patch32',
+ *   rerankingStrategy: 'text-derived'
+ * });
+ * ```
+ */
+import { IngestionPipeline } from '../core/ingestion.js';
+/**
+ * Content system configuration options
+ */
+export interface ContentSystemConfig {
+    /** Content directory path (default: '.raglite/content') */
+    contentDir?: string;
+    /** Maximum file size in bytes (default: 50MB) */
+    maxFileSize?: number;
+    /** Maximum content directory size in bytes (default: 2GB) */
+    maxContentDirSize?: number;
+    /** Enable content deduplication (default: true) */
+    enableDeduplication?: boolean;
+    /** Enable storage tracking (default: true) */
+    enableStorageTracking?: boolean;
+}
+/**
+ * Options for text ingestion factory
+ */
+export interface IngestionFactoryOptions {
+    /** Embedding model name override */
+    embeddingModel?: string;
+    /** Embedding batch size override */
+    batchSize?: number;
+    /** Chunk size override */
+    chunkSize?: number;
+    /** Chunk overlap override */
+    chunkOverlap?: number;
+    /** Whether to force rebuild the index */
+    forceRebuild?: boolean;
+    /** Mode for the ingestion pipeline (text or multimodal) */
+    mode?: 'text' | 'multimodal';
+    /** Reranking strategy for multimodal mode */
+    rerankingStrategy?: 'cross-encoder' | 'text-derived' | 'metadata' | 'hybrid' | 'disabled';
+    /** Content system configuration */
+    contentSystemConfig?: ContentSystemConfig;
+}
+/**
+ * Factory for creating text-based IngestionPipeline instances
+ * Handles model loading, database initialization, and index setup
+ *
+ * This factory abstracts the complex initialization process required for text ingestion:
+ * 1. Creates necessary directories if they don't exist
+ * 2. Validates mode-model compatibility (no fallback mechanisms)
+ * 3. Loads and validates embedding models with clear error reporting
+ * 4. Establishes database connections and initializes schema
+ * 5. Stores mode configuration in database for automatic detection
+ * 6. Creates or loads vector indexes with proper configuration
+ * 7. Creates IngestionPipeline with proper dependency injection
+ *
+ * Mode Configuration:
+ * - Text Mode (default): Uses sentence-transformer models for text-only content
+ * - Multimodal Mode: Uses CLIP models for mixed text/image content
+ * - Mode is stored in database and auto-detected during search
+ * - Clear validation prevents mode-model mismatches
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin');
+ * await ingestion.ingestDirectory('./documents');
+ *
+ * // With custom configuration
+ * const ingestion = await IngestionFactory.create('./db.sqlite', './index.bin', {
+ *   embeddingModel: 'all-MiniLM-L6-v2',
+ *   chunkSize: 512,
+ *   chunkOverlap: 50,
+ *   forceRebuild: true
+ * });
+ *
+ * // With defaults
+ * const ingestion = await IngestionFactory.createWithDefaults({
+ *   batchSize: 32 // Faster processing
+ * });
+ * ```
+ */
+export declare class IngestionFactory {
+    /**
+     * Create an IngestionPipeline configured for text ingestion
+     *
+     * This method handles the complete initialization process:
+     * - Creates necessary directories if they don't exist
+     * - Loads text embedding model (with lazy initialization)
+     * - Opens database connection and initializes schema
+     * - Creates or loads vector index (with force rebuild option)
+     * - Creates IngestionPipeline with dependency injection
+     * - Validates the complete setup
+     *
+     * @param dbPath - Path to the SQLite database file (will be created if doesn't exist)
+     * @param indexPath - Path to the vector index file (will be created if doesn't exist)
+     * @param options - Optional configuration overrides
+     * @param options.embeddingModel - Override embedding model (default: from config)
+     * @param options.batchSize - Override embedding batch size (default: from config)
+     * @param options.chunkSize - Override chunk size (default: from config)
+     * @param options.chunkOverlap - Override chunk overlap (default: from config)
+     * @param options.forceRebuild - Force rebuild of existing index (default: false)
+     * @param options.contentSystemConfig - Content system configuration options
+     * @param options.contentSystemConfig.contentDir - Content directory path (default: '.raglite/content')
+     * @param options.contentSystemConfig.maxFileSize - Maximum file size in bytes (default: 50MB)
+     * @param options.contentSystemConfig.maxContentDirSize - Maximum content directory size (default: 2GB)
+     * @param options.contentSystemConfig.enableDeduplication - Enable content deduplication (default: true)
+     * @param options.contentSystemConfig.enableStorageTracking - Enable storage tracking (default: true)
+     * @returns Promise resolving to configured IngestionPipeline
+     * @throws {Error} If initialization fails
+     *
+     * @example
+     * ```typescript
+     * // Create ingestion pipeline with default content system
+     * const ingestion = await IngestionFactory.create('./my-db.sqlite', './my-index.bin');
+     *
+     * // Create with custom content system configuration
+     * const ingestion = await IngestionFactory.create('./my-db.sqlite', './my-index.bin', {
+     *   contentSystemConfig: {
+     *     contentDir: './custom-content',
+     *     maxFileSize: 100 * 1024 * 1024, // 100MB
+     *     maxContentDirSize: 5 * 1024 * 1024 * 1024, // 5GB
+     *     enableDeduplication: true
+     *   }
+     * });
+     *
+     * // Ingest documents from directory
+     * const result = await ingestion.ingestDirectory('./documents');
+     * console.log(`Processed ${result.documentsProcessed} documents`);
+     *
+     * // Ingest content from memory (MCP integration)
+     * const contentId = await ingestion.ingestFromMemory(buffer, {
+     *   displayName: 'uploaded-file.pdf',
+     *   contentType: 'application/pdf'
+     * });
+     *
+     * // Clean up when done
+     * await ingestion.cleanup();
+     * ```
+     */
+    static create(dbPath: string, indexPath: string, options?: IngestionFactoryOptions): Promise<IngestionPipeline>;
+    /**
+     * Create an IngestionPipeline with automatic path resolution
+     * Uses default paths based on current working directory
+     * @param options - Optional configuration overrides
+     * @returns Promise resolving to configured IngestionPipeline
+     */
+    static createWithDefaults(options?: IngestionFactoryOptions): Promise<IngestionPipeline>;
+    /**
+     * Handles mode storage during ingestion
+     * Creates or validates system info based on the provided mode and options
+     * @private
+     */
+    private static handleModeStorage;
+    /**
+     * Updates system info in the database
+     * @private
+     */
+    private static updateSystemInfo;
+    /**
+     * Validates and prepares content system configuration
+     * @private
+     */
+    private static validateAndPrepareContentSystemConfig;
+}
+//# sourceMappingURL=ingestion-factory.d.ts.map