rag-lite-ts 2.1.0 → 2.2.0

package/dist/{cli → cjs/cli}/indexer.js

@@ -198,7 +198,7 @@ export async function runIngest(path, options = {}) {
                 showProgress: true,
                 maxWaitMs: 15000 // Longer timeout for ingestion
             });
-            const result = await pipeline.ingestPath(resolvedPath);
+            const result = await pipeline.ingestPath(resolvedPath, { mode: factoryOptions.mode });
             // Display final results
             console.log('\n' + '='.repeat(50));
             console.log('INGESTION SUMMARY');

package/dist/{cli → cjs/cli}/search.js

@@ -137,6 +137,11 @@ export async function runSearch(query, options = {}) {
             if (options['top-k'] !== undefined) {
                 searchOptions.top_k = options['top-k'];
             }
+            // Set content type filter for search-level filtering
+            const contentTypeFilter = options['content-type'];
+            if (contentTypeFilter && contentTypeFilter !== 'all') {
+                searchOptions.contentType = contentTypeFilter;
+            }
             // Phase 2: Disable reranking for image-to-image searches to preserve visual similarity
             let rerankingForciblyDisabled = false;
             if (isImage && embedder) {
@@ -174,16 +179,6 @@ export async function runSearch(query, options = {}) {
                 results = await searchEngine.search(query, searchOptions);
             }
             const searchTime = Date.now() - startTime;
-            // Apply content type filter if specified
-            const contentTypeFilter = options['content-type'];
-            if (contentTypeFilter && contentTypeFilter !== 'all') {
-                const originalCount = results.length;
-                results = results.filter(r => r.contentType === contentTypeFilter);
-                if (results.length < originalCount) {
-                    console.log(`Filtered to ${results.length} ${contentTypeFilter} result${results.length === 1 ? '' : 's'} (from ${originalCount} total)`);
-                    console.log('');
-                }
-            }
             // Display results
             if (results.length === 0) {
                 console.log('No results found.');

package/dist/{core → cjs/core}/binary-index-format.d.ts

@@ -25,10 +25,19 @@ export interface BinaryIndexData {
         id: number;
         vector: Float32Array;
     }>;
+    hasContentTypeGroups?: boolean;
+    textVectors?: Array<{
+        id: number;
+        vector: Float32Array;
+    }>;
+    imageVectors?: Array<{
+        id: number;
+        vector: Float32Array;
+    }>;
 }
 export declare class BinaryIndexFormat {
     /**
-     * Save index data to binary format
+     * Save index data to binary format (original format for backward compatibility)
      *
      * File structure:
      * - Header (24 bytes): dimensions, maxElements, M, efConstruction, seed, currentSize
@@ -39,7 +48,24 @@ export declare class BinaryIndexFormat {
      */
     static save(indexPath: string, data: BinaryIndexData): Promise<void>;
     /**
-     * Load index data from binary format
+     * Save index data to grouped binary format
+     *
+     * File structure:
+     * - Extended Header (40 bytes):
+     *   - Original 6 fields (24 bytes)
+     *   - hasGroups flag (4 bytes)
+     *   - textOffset (4 bytes)
+     *   - textCount (4 bytes)
+     *   - imageOffset (4 bytes)
+     *   - imageCount (4 bytes)
+     * - Data section: [text vectors...][image vectors...]
+     *
+     * @param indexPath Path to save the binary index file
+     * @param data Index data to serialize
+     */
+    static saveGrouped(indexPath: string, data: BinaryIndexData): Promise<void>;
+    /**
+     * Load index data from binary format (supports both original and grouped formats)
      *
      * Uses zero-copy Float32Array views for efficient loading.
      * Copies the views to ensure data persistence after buffer lifecycle.

package/dist/cjs/core/binary-index-format.js

@@ -0,0 +1,291 @@
+/**
+ * Binary Index Format Module
+ *
+ * Provides efficient binary serialization for HNSW vector indices.
+ *
+ * Format Specification:
+ * - Header: 24 bytes (6 × uint32)
+ * - Vectors: N × (4 + D × 4) bytes
+ * - Little-endian encoding for cross-platform compatibility
+ * - 4-byte alignment for Float32Array zero-copy views
+ *
+ * Performance:
+ * - 3.66x smaller than JSON format
+ * - 3.5x faster loading
+ * - Zero-copy Float32Array views
+ */
+import { readFileSync, writeFileSync } from 'fs';
+export class BinaryIndexFormat {
+    /**
+     * Save index data to binary format (original format for backward compatibility)
+     *
+     * File structure:
+     * - Header (24 bytes): dimensions, maxElements, M, efConstruction, seed, currentSize
+     * - Vectors: For each vector: id (4 bytes) + vector data (dimensions × 4 bytes)
+     *
+     * @param indexPath Path to save the binary index file
+     * @param data Index data to serialize
+     */
+    static async save(indexPath, data) {
+        // Calculate total size
+        const headerSize = 24; // 6 uint32 fields
+        const vectorSize = 4 + (data.dimensions * 4); // id + vector
+        const totalSize = headerSize + (data.currentSize * vectorSize);
+        const buffer = new ArrayBuffer(totalSize);
+        const view = new DataView(buffer);
+        let offset = 0;
+        // Write header (24 bytes, all little-endian)
+        view.setUint32(offset, data.dimensions, true);
+        offset += 4;
+        view.setUint32(offset, data.maxElements, true);
+        offset += 4;
+        view.setUint32(offset, data.M, true);
+        offset += 4;
+        view.setUint32(offset, data.efConstruction, true);
+        offset += 4;
+        view.setUint32(offset, data.seed, true);
+        offset += 4;
+        view.setUint32(offset, data.currentSize, true);
+        offset += 4;
+        // Write vectors
+        for (const item of data.vectors) {
+            // Ensure 4-byte alignment (should always be true with our format)
+            if (offset % 4 !== 0) {
+                throw new Error(`Offset ${offset} is not 4-byte aligned`);
+            }
+            // Write vector ID
+            view.setUint32(offset, item.id, true);
+            offset += 4;
+            // Write vector data
+            for (let i = 0; i < item.vector.length; i++) {
+                view.setFloat32(offset, item.vector[i], true);
+                offset += 4;
+            }
+        }
+        // Write to file
+        writeFileSync(indexPath, Buffer.from(buffer));
+    }
+    /**
+     * Save index data to grouped binary format
+     *
+     * File structure:
+     * - Extended Header (40 bytes):
+     *   - Original 6 fields (24 bytes)
+     *   - hasGroups flag (4 bytes)
+     *   - textOffset (4 bytes)
+     *   - textCount (4 bytes)
+     *   - imageOffset (4 bytes)
+     *   - imageCount (4 bytes)
+     * - Data section: [text vectors...][image vectors...]
+     *
+     * @param indexPath Path to save the binary index file
+     * @param data Index data to serialize
+     */
+    static async saveGrouped(indexPath, data) {
+        if (!data.hasContentTypeGroups || !data.textVectors || !data.imageVectors) {
+            // Fallback to original format
+            return this.save(indexPath, data);
+        }
+        const headerSize = 44; // Extended header: 24 + 20 bytes (hasGroups + textOffset + textCount + imageOffset + imageCount)
+        const vectorSize = 4 + (data.dimensions * 4); // id + vector
+        // Calculate offsets and total size
+        const textOffset = headerSize;
+        const imageOffset = textOffset + (data.textVectors.length * vectorSize);
+        const totalSize = imageOffset + (data.imageVectors.length * vectorSize);
+        const buffer = new ArrayBuffer(totalSize);
+        const view = new DataView(buffer);
+        let offset = 0;
+        // Write extended header (40 bytes, all little-endian)
+        if (offset + 40 > buffer.byteLength) {
+            throw new Error(`Header write would exceed buffer bounds: offset=${offset}, headerSize=40, bufferSize=${buffer.byteLength}`);
+        }
+        view.setUint32(offset, data.dimensions, true);
+        offset += 4;
+        view.setUint32(offset, data.maxElements, true);
+        offset += 4;
+        view.setUint32(offset, data.M, true);
+        offset += 4;
+        view.setUint32(offset, data.efConstruction, true);
+        offset += 4;
+        view.setUint32(offset, data.seed, true);
+        offset += 4;
+        view.setUint32(offset, data.currentSize, true);
+        offset += 4;
+        // Extended fields
+        view.setUint32(offset, 1, true);
+        offset += 4; // hasGroups = 1
+        view.setUint32(offset, textOffset, true);
+        offset += 4;
+        view.setUint32(offset, data.textVectors.length, true);
+        offset += 4;
+        view.setUint32(offset, imageOffset, true);
+        offset += 4;
+        view.setUint32(offset, data.imageVectors.length, true);
+        offset += 4;
+        // Write text vectors
+        for (const item of data.textVectors) {
+            // Ensure 4-byte alignment
+            if (offset % 4 !== 0) {
+                throw new Error(`Offset ${offset} is not 4-byte aligned`);
+            }
+            // Check bounds before writing
+            if (offset + 4 > buffer.byteLength) {
+                throw new Error(`ID write would exceed buffer bounds: offset=${offset}, bufferSize=${buffer.byteLength}`);
+            }
+            // Write vector ID
+            view.setUint32(offset, item.id, true);
+            offset += 4;
+            // Check bounds for vector data
+            const vectorDataSize = item.vector.length * 4;
+            if (offset + vectorDataSize > buffer.byteLength) {
+                throw new Error(`Vector data write would exceed buffer bounds: offset=${offset}, dataSize=${vectorDataSize}, bufferSize=${buffer.byteLength}`);
+            }
+            // Write vector data
+            for (let i = 0; i < item.vector.length; i++) {
+                view.setFloat32(offset, item.vector[i], true);
+                offset += 4;
+            }
+        }
+        // Write image vectors
+        for (const item of data.imageVectors) {
+            // Ensure 4-byte alignment
+            if (offset % 4 !== 0) {
+                throw new Error(`Offset ${offset} is not 4-byte aligned`);
+            }
+            // Check bounds before writing
+            if (offset + 4 > buffer.byteLength) {
+                throw new Error(`ID write would exceed buffer bounds: offset=${offset}, bufferSize=${buffer.byteLength}`);
+            }
+            // Write vector ID
+            view.setUint32(offset, item.id, true);
+            offset += 4;
+            // Check bounds for vector data
+            const vectorDataSize = item.vector.length * 4;
+            if (offset + vectorDataSize > buffer.byteLength) {
+                throw new Error(`Vector data write would exceed buffer bounds: offset=${offset}, dataSize=${vectorDataSize}, bufferSize=${buffer.byteLength}`);
+            }
+            // Write vector data
+            for (let i = 0; i < item.vector.length; i++) {
+                view.setFloat32(offset, item.vector[i], true);
+                offset += 4;
+            }
+        }
+        // Write to file
+        writeFileSync(indexPath, Buffer.from(buffer));
+    }
+    /**
+     * Load index data from binary format (supports both original and grouped formats)
+     *
+     * Uses zero-copy Float32Array views for efficient loading.
+     * Copies the views to ensure data persistence after buffer lifecycle.
+     *
+     * @param indexPath Path to the binary index file
+     * @returns Deserialized index data
+     */
+    static async load(indexPath) {
+        const buffer = readFileSync(indexPath);
+        const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        let offset = 0;
+        // Read basic header (24 bytes, all little-endian)
+        const dimensions = view.getUint32(offset, true);
+        offset += 4;
+        const maxElements = view.getUint32(offset, true);
+        offset += 4;
+        const M = view.getUint32(offset, true);
+        offset += 4;
+        const efConstruction = view.getUint32(offset, true);
+        offset += 4;
+        const seed = view.getUint32(offset, true);
+        offset += 4;
+        const currentSize = view.getUint32(offset, true);
+        offset += 4;
+        // Check if this is the extended grouped format (40+ bytes header)
+        const hasGroups = buffer.byteLength >= 40 ? view.getUint32(offset, true) : 0;
+        if (hasGroups === 1 && buffer.byteLength >= 40) {
+            // Load grouped format
+            const textOffset = view.getUint32(offset + 4, true);
+            const textCount = view.getUint32(offset + 8, true);
+            const imageOffset = view.getUint32(offset + 12, true);
+            const imageCount = view.getUint32(offset + 16, true);
+            // Load text vectors
+            const textVectors = [];
+            offset = textOffset;
+            for (let i = 0; i < textCount; i++) {
+                // Ensure 4-byte alignment
+                if (offset % 4 !== 0) {
+                    throw new Error(`Offset ${offset} is not 4-byte aligned`);
+                }
+                // Read vector ID
+                const id = view.getUint32(offset, true);
+                offset += 4;
+                // Zero-copy Float32Array view
+                const vectorView = new Float32Array(buffer.buffer, buffer.byteOffset + offset, dimensions);
+                // Copy to avoid buffer lifecycle issues
+                const vector = new Float32Array(vectorView);
+                offset += dimensions * 4;
+                textVectors.push({ id, vector });
+            }
+            // Load image vectors
+            const imageVectors = [];
+            offset = imageOffset;
+            for (let i = 0; i < imageCount; i++) {
+                // Ensure 4-byte alignment
+                if (offset % 4 !== 0) {
+                    throw new Error(`Offset ${offset} is not 4-byte aligned`);
+                }
+                // Read vector ID
+                const id = view.getUint32(offset, true);
+                offset += 4;
+                // Zero-copy Float32Array view
+                const vectorView = new Float32Array(buffer.buffer, buffer.byteOffset + offset, dimensions);
+                // Copy to avoid buffer lifecycle issues
+                const vector = new Float32Array(vectorView);
+                offset += dimensions * 4;
+                imageVectors.push({ id, vector });
+            }
+            // Combine all vectors for backward compatibility
+            const allVectors = [...textVectors, ...imageVectors];
+            return {
+                dimensions,
+                maxElements,
+                M,
+                efConstruction,
+                seed,
+                currentSize,
+                vectors: allVectors,
+                hasContentTypeGroups: true,
+                textVectors,
+                imageVectors
+            };
+        }
+        else {
+            // Load original format
+            const vectors = [];
+            for (let i = 0; i < currentSize; i++) {
+                // Ensure 4-byte alignment (should always be true with our format)
+                if (offset % 4 !== 0) {
+                    throw new Error(`Offset ${offset} is not 4-byte aligned`);
+                }
+                // Read vector ID
+                const id = view.getUint32(offset, true);
+                offset += 4;
+                // Zero-copy Float32Array view (fast!)
+                const vectorView = new Float32Array(buffer.buffer, buffer.byteOffset + offset, dimensions);
+                // Copy to avoid buffer lifecycle issues
+                const vector = new Float32Array(vectorView);
+                offset += dimensions * 4;
+                vectors.push({ id, vector });
+            }
+            return {
+                dimensions,
+                maxElements,
+                M,
+                efConstruction,
+                seed,
+                currentSize,
+                vectors
+            };
+        }
+    }
+}
+//# sourceMappingURL=binary-index-format.js.map

package/dist/{core → cjs/core}/ingestion.d.ts

@@ -162,9 +162,13 @@ export declare class IngestionPipeline {
      */
     private storeDocumentsAndChunksWithContentTypes;
     /**
-     * Update vector index with new embeddings
+     * Update vector index with new embeddings (supports grouped content type storage)
      */
     private updateVectorIndex;
+    /**
+     * Filter documents based on ingestion mode to avoid processing incompatible content types
+     */
+    private filterDocumentsByMode;
     /**
      * Converts MIME type to simple content type for embedding function
      * @param mimeType - MIME type string (e.g., 'text/plain', 'image/jpeg')

package/dist/{core → cjs/core}/ingestion.js

@@ -287,21 +287,30 @@ export class IngestionPipeline {
         try {
             // Phase 1: File Discovery and Processing with Content-Type Detection
             console.log('\n--- Phase 1: File Discovery and Processing ---');
-            const fileResult = await discoverAndProcessFiles(path, options.fileOptions, this.pathManager);
-            if (fileResult.documents.length === 0) {
+            const mode = options.mode || 'text';
+            const fileOptions = {
+                recursive: true,
+                maxFileSize: 10 * 1024 * 1024, // 10MB
+                ...options.fileOptions,
+                mode
+            };
+            const fileResult = await discoverAndProcessFiles(path, fileOptions, this.pathManager);
+            // Additional filtering as fallback (should be minimal with mode-aware discovery)
+            const filteredResult = this.filterDocumentsByMode(fileResult, mode);
+            if (filteredResult.documents.length === 0) {
                 console.log('No documents found to process');
                 return {
                     documentsProcessed: 0,
                     chunksCreated: 0,
                     embeddingsGenerated: 0,
-                    documentErrors: fileResult.processingResult.errors.length,
+                    documentErrors: filteredResult.processingResult.errors.length,
                     embeddingErrors: 0,
                     processingTimeMs: Date.now() - startTime,
                     contentIds: []
                 };
             }
             // Content-type detection and routing
-            const contentTypeStats = this.analyzeContentTypes(fileResult.documents);
+            const contentTypeStats = this.analyzeContentTypes(filteredResult.documents);
             console.log(`📊 Content analysis: ${contentTypeStats.text} text, ${contentTypeStats.image} image, ${contentTypeStats.other} other files`);
             // Phase 2: Document Chunking with Content-Type Awareness
             console.log('\n--- Phase 2: Document Chunking ---');
@@ -309,7 +318,7 @@ export class IngestionPipeline {
                 chunkSize: config.chunk_size,
                 chunkOverlap: config.chunk_overlap
             };
-            const chunkingResult = await this.chunkDocumentsWithContentTypes(fileResult.documents, effectiveChunkConfig, options.mode);
+            const chunkingResult = await this.chunkDocumentsWithContentTypes(filteredResult.documents, effectiveChunkConfig, options.mode);
             if (chunkingResult.totalChunks === 0) {
                 console.log('No chunks created from documents');
                 return {
@@ -334,10 +343,10 @@ export class IngestionPipeline {
             const endTime = Date.now();
             const processingTimeMs = endTime - startTime;
             const result = {
-                documentsProcessed: fileResult.documents.length,
+                documentsProcessed: filteredResult.documents.length,
                 chunksCreated: chunkingResult.totalChunks,
                 embeddingsGenerated: embeddingResult.embeddings.length,
-                documentErrors: fileResult.processingResult.errors.length,
+                documentErrors: filteredResult.processingResult.errors.length,
                 embeddingErrors: embeddingResult.errors,
                 processingTimeMs,
                 contentIds
@@ -595,16 +604,35 @@ export class IngestionPipeline {
         return contentIds;
     }
     /**
-     * Update vector index with new embeddings
+     * Update vector index with new embeddings (supports grouped content type storage)
      */
     async updateVectorIndex(embeddings) {
+        console.log('updateVectorIndex called with', embeddings.length, 'embeddings');
         if (embeddings.length === 0) {
             console.log('No embeddings to add to vector index');
             return;
         }
         console.log(`Adding ${embeddings.length} vector${embeddings.length === 1 ? '' : 's'} to search index...`);
         try {
-            await this.indexManager.addVectors(embeddings);
+            // Group embeddings by content type for optimized storage
+            const groupedEmbeddings = embeddings.reduce((groups, embedding) => {
+                const contentType = embedding.contentType || 'text';
+                if (!groups[contentType]) {
+                    groups[contentType] = [];
+                }
+                groups[contentType].push(embedding);
+                return groups;
+            }, {});
+            const textEmbeddings = groupedEmbeddings.text || [];
+            const imageEmbeddings = groupedEmbeddings.image || [];
+            console.log(`Grouped: ${textEmbeddings.length} text, ${imageEmbeddings.length} image vectors`);
+            // Use grouped storage method if available, fallback to regular method
+            if (this.indexManager.addGroupedEmbeddings) {
+                await this.indexManager.addGroupedEmbeddings(textEmbeddings, imageEmbeddings);
+            }
+            else {
+                await this.indexManager.addVectors(embeddings);
+            }
             console.log(`✓ Vector index updated successfully with ${embeddings.length} new vectors`);
         }
         catch (error) {
@@ -612,6 +640,45 @@ export class IngestionPipeline {
             throw error;
         }
     }
+    /**
+     * Filter documents based on ingestion mode to avoid processing incompatible content types
+     */
+    filterDocumentsByMode(fileResult, mode) {
+        if (mode === 'multimodal') {
+            // In multimodal mode, keep all documents
+            return fileResult;
+        }
+        // In text mode, filter out image documents
+        const filteredDocuments = fileResult.documents.filter(doc => {
+            const contentType = doc.metadata?.contentType || 'text';
+            const isCompatible = contentType === 'text' ||
+                contentType.startsWith('text/') ||
+                contentType === 'application/pdf' ||
+                contentType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+            if (!isCompatible) {
+                console.log(`⚠️ Skipping ${doc.source} (${contentType}) - not compatible with text mode`);
+            }
+            return isCompatible;
+        });
+        // Update processing result to reflect filtering
+        const filteredProcessingResult = {
+            ...fileResult.processingResult,
+            skippedFiles: [
+                ...(fileResult.processingResult.skippedFiles || []),
+                ...fileResult.documents
+                    .filter(doc => !filteredDocuments.includes(doc))
+                    .map(doc => ({
+                    path: doc.source,
+                    reason: `Content type not compatible with ${mode} mode`
+                }))
+            ]
+        };
+        return {
+            documents: filteredDocuments,
+            discoveryResult: fileResult.discoveryResult,
+            processingResult: filteredProcessingResult
+        };
+    }
     /**
      * Converts MIME type to simple content type for embedding function
      * @param mimeType - MIME type string (e.g., 'text/plain', 'image/jpeg')

package/dist/{core → cjs/core}/model-validator.js

@@ -105,7 +105,7 @@ export class ModelValidator {
             }
             // Fallback: try to detect from package.json import
             try {
-                const packageInfo = await import('@huggingface/transformers/package.json');
+                const packageInfo = await import('@huggingface/transformers/package.json' + '');
                 if (packageInfo.version) {
                     this.currentTransformersVersion = packageInfo.version;
                     return packageInfo.version;

package/dist/{core → cjs/core}/reranking-strategies.js

@@ -194,7 +194,7 @@ export class TextDerivedRerankingStrategy {
         catch (error) {
             console.warn(`Failed to generate description for image ${imagePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
             // Fallback to filename-based description
-            const filename = imagePath.split('/').pop() || imagePath.split('\\').pop() || imagePath;
+            const filename = imagePath.split('/').pop() || imagePath;
             return `Image file: ${filename}`;
         }
     }
@@ -211,17 +211,16 @@ export class TextDerivedRerankingStrategy {
             // Step 1: Convert images to text descriptions
             const processedResults = await Promise.all(results.map(async (result) => {
                 if (result.contentType === 'image') {
-                    // Generate text description for image using the file path from document.source
-                    const description = await this.generateImageDescription(result.document.source);
+                    // Generate text description for image
+                    const description = await this.generateImageDescription(result.content);
                     return {
                         ...result,
                         content: description,
-                        contentType: 'text', // Change to 'text' so cross-encoder will process it
                         originalContent: result.content,
                         originalContentType: result.contentType,
                         metadata: {
                             ...result.metadata,
-                            originalImagePath: result.document.source,
+                            originalImagePath: result.content,
                             generatedDescription: description
                         }
                     };

package/dist/{core → cjs/core}/search.js

@@ -139,7 +139,8 @@ export class SearchEngine {
             const searchStartTime = performance.now();
             let searchResult;
             try {
-                searchResult = this.indexManager.search(queryVector, topK);
+                const contentType = options.contentType;
+                searchResult = this.indexManager.search(queryVector, topK, contentType);
             }
             catch (error) {
                 if (error instanceof Error && error.message.includes('No embedding ID found for hash')) {

package/dist/{core → cjs/core}/types.d.ts

@@ -49,7 +49,7 @@ export interface RerankingInterface {
 export interface SearchOptions {
     top_k?: number;
     rerank?: boolean;
-    contentType?: string;
+    contentType?: 'text' | 'image' | 'combined';
 }
 export interface Chunk {
     text: string;

package/dist/{core → cjs/core}/vector-index.d.ts

@@ -64,5 +64,9 @@ export declare class VectorIndex {
      * Resize index to accommodate more vectors
      */
     resizeIndex(newMaxElements: number): void;
+    /**
+     * Get index options (for external access to configuration)
+     */
+    getOptions(): VectorIndexOptions;
 }
 //# sourceMappingURL=vector-index.d.ts.map

package/dist/{core → cjs/core}/vector-index.js

@@ -81,7 +81,8 @@ export class VectorIndex {
                     originalConsoleError.apply(console, args);
                 };
                 try {
-                    const { loadHnswlib } = await import('hnswlib-wasm/dist/hnswlib.js');
+                    const hnswlibModule = await import('hnswlib-wasm/dist/hnswlib.js');
+                    const { loadHnswlib } = hnswlibModule;
                     this.hnswlib = await loadHnswlib();
                 }
                 finally {
@@ -143,7 +144,8 @@ export class VectorIndex {
                     originalConsoleError.apply(console, args);
                 };
                 try {
-                    const { loadHnswlib } = await import('hnswlib-wasm/dist/hnswlib.js');
+                    const hnswlibModule = await import('hnswlib-wasm/dist/hnswlib.js');
+                    const { loadHnswlib } = hnswlibModule;
                     this.hnswlib = await loadHnswlib();
                 }
                 finally {
@@ -321,5 +323,11 @@ export class VectorIndex {
             throw new Error(`Failed to resize index: ${error}`);
         }
     }
+    /**
+     * Get index options (for external access to configuration)
+     */
+    getOptions() {
+        return { ...this.options };
+    }
 }
 //# sourceMappingURL=vector-index.js.map

package/dist/{file-processor.d.ts → cjs/file-processor.d.ts}

@@ -8,6 +8,8 @@ export interface FileProcessorOptions {
     recursive?: boolean;
     /** Maximum file size in bytes (default: 10MB) */
     maxFileSize?: number;
+    /** Processing mode to filter compatible files */
+    mode?: 'text' | 'multimodal';
 }
 /**
  * Default options for file processing