rag-lite-ts 2.1.0 → 2.2.0

package/dist/esm/text/sentence-transformer-embedder.js

@@ -0,0 +1,340 @@
+/**
+ * TEXT IMPLEMENTATION — Sentence Transformer Embedder Implementation
+ * Implements UniversalEmbedder interface for sentence-transformer models
+ * Adapts existing text embedding logic to the universal interface
+ */
+// Ensure DOM polyfills are set up before any other imports
+import '../dom-polyfills.js';
+import { BaseUniversalEmbedder } from '../core/abstract-embedder.js';
+import { EmbeddingEngine } from './embedder.js';
+import { getResourceManager } from '../core/resource-manager.js';
+// =============================================================================
+// SENTENCE TRANSFORMER EMBEDDER IMPLEMENTATION
+// =============================================================================
+/**
+ * Sentence transformer embedder implementation
+ * Supports sentence-transformers/all-MiniLM-L6-v2 and Xenova/all-mpnet-base-v2
+ * Ensures consistent EmbeddingResult format with contentType='text'
+ * Adapts existing EmbeddingEngine to UniversalEmbedder interface
+ */
+export class SentenceTransformerEmbedder extends BaseUniversalEmbedder {
+    embeddingEngine = null;
+    resourceManager = getResourceManager();
+    embedderResourceId;
+    engineResourceId;
+    constructor(modelName, options = {}) {
+        super(modelName, options);
+        // Register this embedder with the resource manager
+        this.embedderResourceId = this.resourceManager.registerEmbedder(this);
+    }
+    // =============================================================================
+    // MODEL LIFECYCLE METHODS
+    // =============================================================================
+    /**
+     * Load the sentence transformer model using existing EmbeddingEngine
+     */
+    async loadModel() {
+        // Check if already loaded and engine is ready
+        if (this._isLoaded && this.embeddingEngine?.isLoaded()) {
+            return;
+        }
+        try {
+            this.logModelLoading('Loading sentence transformer model');
+            // Create EmbeddingEngine if not exists
+            if (!this.embeddingEngine) {
+                this.embeddingEngine = new EmbeddingEngine(this.modelName, this.options.maxBatchSize || this._modelInfo.capabilities.maxBatchSize || 8);
+            }
+            // Load the model using the existing engine (only if not already loaded)
+            if (!this.embeddingEngine.isLoaded()) {
+                await this.embeddingEngine.loadModel();
+            }
+            // Register the embedding engine with resource manager if not already registered
+            if (!this.engineResourceId) {
+                this.engineResourceId = this.resourceManager.registerModel(this.embeddingEngine, this.modelName, 'sentence-transformer');
+            }
+            // Synchronize loading state
+            this._isLoaded = this.embeddingEngine.isLoaded();
+            if (this._isLoaded) {
+                this.logModelLoading('Model loaded successfully');
+            }
+            else {
+                throw new Error('Model loading failed - engine reports not loaded');
+            }
+        }
+        catch (error) {
+            // Reset state on failure
+            this._isLoaded = false;
+            const enhancedError = this.handleLoadingError(error);
+            throw enhancedError;
+        }
+    }
+    /**
+     * Clean up model resources with comprehensive disposal
+     */
+    async cleanup() {
+        let cleanupErrors = [];
+        try {
+            // Clean up embedding engine resources
+            if (this.embeddingEngine) {
+                try {
+                    // Use resource manager for proper cleanup
+                    if (this.engineResourceId) {
+                        await this.resourceManager.cleanupResource(this.engineResourceId);
+                        this.engineResourceId = undefined;
+                    }
+                    // Clear the reference (EmbeddingEngine doesn't have cleanup methods)
+                    this.embeddingEngine = null;
+                    this.logModelLoading('Sentence transformer embedding engine disposed');
+                }
+                catch (error) {
+                    const errorMsg = `Failed to dispose embedding engine: ${error instanceof Error ? error.message : 'Unknown error'}`;
+                    cleanupErrors.push(errorMsg);
+                    console.warn(errorMsg);
+                    // Force clear reference even if disposal failed
+                    this.embeddingEngine = null;
+                }
+            }
+            // Clear embedder resource registration (don't call resource manager to avoid circular cleanup)
+            if (this.embedderResourceId) {
+                this.embedderResourceId = undefined;
+            }
+        }
+        finally {
+            // Always clear loaded state regardless of cleanup success
+            this._isLoaded = false;
+            // Remove from lazy loading cache to ensure fresh instances
+            try {
+                const { LazyEmbedderLoader } = await import('../core/lazy-dependency-loader.js');
+                LazyEmbedderLoader.removeEmbedderFromCache(this.modelName, 'sentence-transformer');
+            }
+            catch (error) {
+                console.warn('Failed to remove embedder from cache:', error);
+            }
+            // Force garbage collection for sentence transformer models
+            if (global.gc) {
+                global.gc();
+                this.logModelLoading('Forced garbage collection after sentence transformer cleanup');
+            }
+            // Log cleanup completion
+            if (cleanupErrors.length === 0) {
+                this.logModelLoading('Sentence transformer resources cleaned up successfully');
+            }
+            else {
+                this.logModelLoading(`Sentence transformer cleanup completed with ${cleanupErrors.length} errors`);
+                // Don't throw errors during cleanup - just log them
+            }
+        }
+    }
+    // =============================================================================
+    // EMBEDDING METHODS
+    // =============================================================================
+    /**
+     * Embed text using the existing EmbeddingEngine
+     */
+    async embedText(text) {
+        // Validate input first, before checking if model is loaded
+        if (!text || text.trim().length === 0) {
+            throw new Error('Text input cannot be empty');
+        }
+        this.ensureLoaded();
+        // Update resource usage tracking
+        if (this.embedderResourceId) {
+            this.resourceManager.updateResourceUsage(this.embedderResourceId);
+        }
+        if (this.engineResourceId) {
+            this.resourceManager.updateResourceUsage(this.engineResourceId);
+        }
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        try {
+            // Validate and truncate text if necessary
+            this.validateTextLength(text);
+            const processedText = this.truncateText(text.trim());
+            // Use the existing EmbeddingEngine to generate embeddings
+            const result = await this.embeddingEngine.embedSingle(processedText);
+            // Validate embedding dimensions
+            if (result.vector.length !== this.dimensions) {
+                throw new Error(`Embedding dimension mismatch: expected ${this.dimensions}, got ${result.vector.length}`);
+            }
+            // Ensure contentType is always present for UniversalEmbedder interface
+            return {
+                ...result,
+                contentType: 'text'
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to embed text: ${error.message}`);
+            }
+            throw new Error('Failed to embed text: Unknown error');
+        }
+    }
+    // =============================================================================
+    // BATCH PROCESSING OPTIMIZATION
+    // =============================================================================
+    /**
+     * Optimized batch processing using existing EmbeddingEngine and BatchProcessingOptimizer
+     * Overrides the base implementation for better performance with progress reporting
+     */
+    async processBatch(batch) {
+        this.ensureLoaded();
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        // Filter for text content only (sentence transformers don't support other types)
+        const textItems = batch.filter(item => item.contentType === 'text');
+        if (textItems.length === 0) {
+            return [];
+        }
+        // For small batches, use the existing EmbeddingEngine directly
+        if (textItems.length <= 10) {
+            try {
+                // Prepare texts for batch processing
+                const texts = textItems.map(item => this.truncateText(item.content.trim()));
+                // Use the existing EmbeddingEngine's batch processing
+                const results = await this.embeddingEngine.embedBatch(texts);
+                // Validate dimensions for all results
+                for (let i = 0; i < results.length; i++) {
+                    if (results[i].vector.length !== this.dimensions) {
+                        throw new Error(`Embedding dimension mismatch for item ${i}: expected ${this.dimensions}, got ${results[i].vector.length}`);
+                    }
+                }
+                return results;
+            }
+            catch (error) {
+                // Fall back to individual processing if batch fails
+                console.warn(`Batch processing failed, falling back to individual processing: ${error}`);
+                return super.processBatch(batch);
+            }
+        }
+        // For larger batches, use the BatchProcessingOptimizer
+        try {
+            const { createTextBatchProcessor } = await import('../core/batch-processing-optimizer.js');
+            const batchProcessor = createTextBatchProcessor();
+            // Convert to EmbeddingBatchItem format
+            const batchItems = textItems.map(item => ({
+                content: this.truncateText(item.content.trim()),
+                contentType: item.contentType,
+                metadata: item.metadata
+            }));
+            // Create embed function that uses this embedder
+            const embedFunction = async (item) => {
+                const result = await this.embeddingEngine.embedSingle(item.content);
+                // Validate dimensions
+                if (result.vector.length !== this.dimensions) {
+                    throw new Error(`Embedding dimension mismatch: expected ${this.dimensions}, got ${result.vector.length}`);
+                }
+                return result;
+            };
+            // Process with optimization and progress reporting
+            const batchResult = await batchProcessor.processBatch(batchItems, embedFunction, (stats) => {
+                if (stats.totalItems > 50) { // Only log for larger batches
+                    console.log(`Text embedding progress: ${stats.processedItems}/${stats.totalItems} (${Math.round((stats.processedItems / stats.totalItems) * 100)}%)`);
+                }
+            });
+            // Log final statistics for large batches
+            if (batchResult.stats.totalItems > 50) {
+                console.log(`✓ Text embedding complete: ${batchResult.stats.processedItems} processed, ${batchResult.stats.failedItems} failed`);
+                console.log(`  Processing time: ${Math.round(batchResult.stats.processingTimeMs / 1000)}s, Rate: ${Math.round(batchResult.stats.itemsPerSecond)} items/sec`);
+                if (batchResult.stats.peakMemoryUsageMB > 100) {
+                    console.log(`  Peak memory usage: ${batchResult.stats.peakMemoryUsageMB}MB`);
+                }
+            }
+            return batchResult.results;
+        }
+        catch (error) {
+            // Fall back to existing implementation if optimizer fails
+            console.warn(`Batch processing optimizer failed, using fallback: ${error}`);
+            try {
+                const texts = textItems.map(item => this.truncateText(item.content.trim()));
+                const results = await this.embeddingEngine.embedBatch(texts);
+                for (let i = 0; i < results.length; i++) {
+                    if (results[i].vector.length !== this.dimensions) {
+                        throw new Error(`Embedding dimension mismatch for item ${i}: expected ${this.dimensions}, got ${results[i].vector.length}`);
+                    }
+                }
+                return results;
+            }
+            catch (fallbackError) {
+                console.warn(`Fallback batch processing failed, using individual processing: ${fallbackError}`);
+                return super.processBatch(batch);
+            }
+        }
+    }
+    // =============================================================================
+    // UTILITY METHODS
+    // =============================================================================
+    /**
+     * Get model-specific information
+     */
+    getModelInfo() {
+        const baseInfo = super.getModelInfo();
+        return {
+            ...baseInfo,
+            capabilities: {
+                ...baseInfo.capabilities,
+                // Sentence transformers are optimized for text similarity
+                supportsSemanticSimilarity: true,
+                supportsTextClassification: true,
+                supportsTextClustering: true,
+                recommendedUseCase: 'text similarity and semantic search'
+            }
+        };
+    }
+    /**
+     * Check if the model is suitable for a specific task
+     */
+    isSuitableForTask(task) {
+        // Sentence transformers are suitable for all text-based tasks
+        const supportedTasks = ['similarity', 'classification', 'clustering', 'retrieval'];
+        return supportedTasks.includes(task);
+    }
+    // =============================================================================
+    // ADDITIONAL METHODS FOR COMPATIBILITY WITH EXISTING SYSTEM
+    // =============================================================================
+    /**
+     * Embed document batch using existing EmbeddingEngine's optimized method
+     * This method provides compatibility with the existing document ingestion pipeline
+     */
+    async embedDocumentBatch(chunks) {
+        this.ensureLoaded();
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        // Use the existing EmbeddingEngine's document batch processing
+        // which includes progress logging and error handling
+        return await this.embeddingEngine.embedDocumentBatch(chunks);
+    }
+    /**
+     * Get the model version from the underlying EmbeddingEngine
+     */
+    getModelVersion() {
+        if (!this.embeddingEngine) {
+            throw new Error('Embedding engine not initialized');
+        }
+        return this.embeddingEngine.getModelVersion();
+    }
+    /**
+     * Get the batch size from the underlying EmbeddingEngine
+     */
+    getBatchSize() {
+        if (!this.embeddingEngine) {
+            return this.options.maxBatchSize || this._modelInfo.capabilities.maxBatchSize || 8;
+        }
+        return this.embeddingEngine.getBatchSize();
+    }
+    /**
+     * Check if the underlying EmbeddingEngine is loaded
+     */
+    isEngineLoaded() {
+        return this.embeddingEngine ? this.embeddingEngine.isLoaded() : false;
+    }
+    /**
+     * Override isLoaded to check both internal state and engine state
+     */
+    isLoaded() {
+        return this._isLoaded && this.isEngineLoaded();
+    }
+}
+//# sourceMappingURL=sentence-transformer-embedder.js.map

package/dist/esm/text/tokenizer.d.ts

@@ -0,0 +1,22 @@
+import '../dom-polyfills.js';
+import type { PreTrainedTokenizer } from '@huggingface/transformers';
+/**
+ * Count tokens in a text string using the MiniLM-L6-v2 tokenizer
+ * This ensures token counts match exactly with the embedding model
+ *
+ * @param text - Text to count tokens for
+ * @returns Number of tokens in the text
+ * @throws {Error} If tokenizer fails to initialize or tokenize
+ */
+export declare function countTokens(text: string): Promise<number>;
+/**
+ * Get the tokenizer instance (for testing purposes)
+ * @internal
+ */
+export declare function getTokenizer(): Promise<PreTrainedTokenizer>;
+/**
+ * Reset the tokenizer instance (for testing purposes)
+ * @internal
+ */
+export declare function resetTokenizer(): void;
+//# sourceMappingURL=tokenizer.d.ts.map

package/dist/esm/text/tokenizer.js

@@ -0,0 +1,64 @@
+import '../dom-polyfills.js';
+/**
+ * Tokenizer instance for consistent token counting
+ * Uses the same tokenizer as the embedding model (MiniLM-L6-v2)
+ */
+let tokenizer = null;
+/**
+ * Initialize the tokenizer with the MiniLM-L6-v2 model
+ * This ensures token counting matches the embedding model exactly
+ */
+async function initializeTokenizer() {
+    if (tokenizer) {
+        return tokenizer;
+    }
+    try {
+        // Ensure DOM polyfills are set up before importing transformers
+        if (typeof globalThis.self === 'undefined') {
+            globalThis.self = globalThis;
+        }
+        // Use the same model as embeddings for consistent token counting using dynamic import
+        const { AutoTokenizer } = await import('@huggingface/transformers');
+        tokenizer = await AutoTokenizer.from_pretrained('sentence-transformers/all-MiniLM-L6-v2');
+        return tokenizer;
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize tokenizer: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Count tokens in a text string using the MiniLM-L6-v2 tokenizer
+ * This ensures token counts match exactly with the embedding model
+ *
+ * @param text - Text to count tokens for
+ * @returns Number of tokens in the text
+ * @throws {Error} If tokenizer fails to initialize or tokenize
+ */
+export async function countTokens(text) {
+    if (!text || typeof text !== 'string') {
+        return 0;
+    }
+    try {
+        const tokenizerInstance = await initializeTokenizer();
+        const tokens = await tokenizerInstance.encode(text);
+        return tokens.length;
+    }
+    catch (error) {
+        throw new Error(`Failed to count tokens: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Get the tokenizer instance (for testing purposes)
+ * @internal
+ */
+export async function getTokenizer() {
+    return await initializeTokenizer();
+}
+/**
+ * Reset the tokenizer instance (for testing purposes)
+ * @internal
+ */
+export function resetTokenizer() {
+    tokenizer = null;
+}
+//# sourceMappingURL=tokenizer.js.map

package/dist/esm/types.d.ts

@@ -0,0 +1,83 @@
+export interface SearchResult {
+    text: string;
+    score: number;
+    document: {
+        id: number;
+        source: string;
+        title: string;
+    };
+}
+export interface SearchOptions {
+    top_k?: number;
+    rerank?: boolean;
+}
+export interface Chunk {
+    text: string;
+    chunk_index: number;
+}
+export interface Document {
+    source: string;
+    title: string;
+    content: string;
+    metadata?: Record<string, any>;
+}
+export interface EmbeddingResult {
+    embedding_id: string;
+    vector: Float32Array;
+    contentType?: string;
+    metadata?: Record<string, any>;
+}
+export interface EnhancedEmbeddingResult extends EmbeddingResult {
+    contentType: string;
+    metadata?: Record<string, any>;
+}
+export interface Preprocessor {
+    appliesTo(language: string): boolean;
+    process(content: string, options: PreprocessorOptions): string;
+}
+export interface PreprocessorOptions {
+    mode: 'strip' | 'keep' | 'placeholder' | 'extract';
+    [key: string]: any;
+}
+export interface PreprocessingConfig {
+    mode: 'strict' | 'balanced' | 'rich';
+    overrides?: {
+        mdx?: 'strip' | 'keep' | 'placeholder';
+        mermaid?: 'strip' | 'extract' | 'placeholder';
+        code?: 'strip' | 'keep' | 'placeholder';
+    };
+}
+export type ModeType = 'text' | 'multimodal';
+export type ModelType = 'sentence-transformer' | 'clip';
+export type { RerankingStrategyType, RerankingConfig } from './core/reranking-config.js';
+import type { RerankingStrategyType, RerankingConfig } from './core/reranking-config.js';
+export interface SystemInfo {
+    mode: ModeType;
+    modelName: string;
+    modelType: ModelType;
+    modelDimensions: number;
+    modelVersion: string;
+    supportedContentTypes: string[];
+    rerankingStrategy: RerankingStrategyType;
+    rerankingModel?: string;
+    rerankingConfig?: RerankingConfig;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface SystemInfoRow {
+    id: number;
+    mode: string;
+    model_name: string;
+    model_type: string;
+    model_dimensions: number;
+    model_version: string;
+    supported_content_types: string;
+    reranking_strategy: string;
+    reranking_model?: string;
+    reranking_config?: string;
+    created_at: string;
+    updated_at: string;
+}
+export type { DatabaseConnection, ContentChunk } from './core/db.js';
+export type { UniversalEmbedder, ModelInfo, ModelCapabilities, ModelRequirements, EmbeddingBatchItem, ModelValidationResult, CreateEmbedderFunction, EmbedderCreationOptions, ContentType } from './core/universal-embedder.js';
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/types.js

@@ -0,0 +1,3 @@
+// Type definitions for rag-lite-ts
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/utils/vector-math.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Vector mathematics utilities for embedding operations
+ */
+/**
+ * Compute cosine similarity between two vectors
+ * @param a - First vector (Float32Array or number array)
+ * @param b - Second vector (Float32Array or number array)
+ * @returns Cosine similarity score between -1 and 1
+ */
+export declare function cosineSimilarity(a: Float32Array | number[], b: Float32Array | number[]): number;
+/**
+ * Compute Euclidean distance between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Euclidean distance
+ */
+export declare function euclideanDistance(a: Float32Array | number[], b: Float32Array | number[]): number;
+/**
+ * Compute dot product between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Dot product
+ */
+export declare function dotProduct(a: Float32Array | number[], b: Float32Array | number[]): number;
+/**
+ * Compute vector magnitude (L2 norm)
+ * @param vector - Input vector
+ * @returns Vector magnitude
+ */
+export declare function magnitude(vector: Float32Array | number[]): number;
+//# sourceMappingURL=vector-math.d.ts.map

package/dist/esm/utils/vector-math.js

@@ -0,0 +1,70 @@
+/**
+ * Vector mathematics utilities for embedding operations
+ */
+/**
+ * Compute cosine similarity between two vectors
+ * @param a - First vector (Float32Array or number array)
+ * @param b - Second vector (Float32Array or number array)
+ * @returns Cosine similarity score between -1 and 1
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    return magnitude === 0 ? 0 : dotProduct / magnitude;
+}
+/**
+ * Compute Euclidean distance between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Euclidean distance
+ */
+export function euclideanDistance(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        const diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+}
+/**
+ * Compute dot product between two vectors
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Dot product
+ */
+export function dotProduct(a, b) {
+    if (a.length !== b.length) {
+        throw new Error('Vectors must have the same length');
+    }
+    let product = 0;
+    for (let i = 0; i < a.length; i++) {
+        product += a[i] * b[i];
+    }
+    return product;
+}
+/**
+ * Compute vector magnitude (L2 norm)
+ * @param vector - Input vector
+ * @returns Vector magnitude
+ */
+export function magnitude(vector) {
+    let sum = 0;
+    for (let i = 0; i < vector.length; i++) {
+        sum += vector[i] * vector[i];
+    }
+    return Math.sqrt(sum);
+}
+//# sourceMappingURL=vector-math.js.map

package/package.json

@@ -1,33 +1,51 @@
 {
   "name": "rag-lite-ts",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Local-first TypeScript retrieval engine with Chameleon Multimodal Architecture for semantic search over text and image content",
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
   "bin": {
-    "raglite": "./dist/cli.js",
-    "raglite-mcp": "./dist/mcp-server.js"
+    "raglite": "./dist/esm/cli.js",
+    "raglite-mcp": "./dist/esm/mcp-server.js"
   },
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "types": "./dist/esm/index.d.ts"
     },
     "./mcp": {
-      "import": "./dist/mcp-server.js",
-      "types": "./dist/mcp-server.d.ts"
+      "import": {
+        "types": "./dist/esm/mcp-server.d.ts",
+        "default": "./dist/esm/mcp-server.js"
+      },
+      "require": {
+        "types": "./dist/cjs/mcp-server.d.ts",
+        "default": "./dist/cjs/mcp-server.js"
+      },
+      "types": "./dist/esm/mcp-server.d.ts"
     }
   },
   "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts",
+    "dist/esm/**/*.js",
+    "dist/cjs/**/*.js",
+    "dist/esm/**/*.d.ts",
+    "dist/cjs/**/*.d.ts",
     "!dist/**/*.map",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
     "build:test": "tsc --project tsconfig.test.json",
     "clean": "rimraf dist",
     "dev": "tsc --watch",