@meaningfully/core 0.1.0

package/src/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeProjectName(projectName: string): string;
+export declare function capitalizeFirstLetter(val: string): string;

package/src/utils.ts

@@ -0,0 +1,6 @@
+export function sanitizeProjectName(projectName: string) {
+  return projectName.replace(/[^a-zA-Z0-9]/g, "_");
+}
+export function capitalizeFirstLetter(val: string) {
+  return String(val).charAt(0).toUpperCase() + String(val).slice(1);
+}

package/tests/MetadataManager.test.ts

@@ -0,0 +1,120 @@
+import { MetadataManager } from '../src/MetadataManager.js';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+describe('MetadataManager', () => {
+  let metadataManager: MetadataManager;
+
+  beforeEach(() => {
+    metadataManager = new (class extends MetadataManager {
+      protected async runQuery<T>(query: string, params?: any[]): Promise<T[]> {
+        return [] as T[];
+      }
+      protected async runQuerySingle<T>(query: string, params?: any[]): Promise<T | null> {
+        return null;
+      }
+      protected async initializeDatabase(): Promise<void> {}
+      protected close(): void {}
+    })();
+  });
+
+  it('should add a document set and return its ID', async () => {
+    vi.spyOn(metadataManager, 'runQuerySingle').mockResolvedValueOnce({ set_id: 1 });
+
+    const documentSetId = await metadataManager.addDocumentSet({
+      name: 'Test Set',
+      uploadDate: new Date(),
+      parameters: {},
+      totalDocuments: 10,
+    });
+
+    expect(documentSetId).toBe(1);
+  });
+
+  it('should retrieve a document set by ID', async () => {
+    vi.spyOn(metadataManager, 'runQuerySingle').mockResolvedValueOnce({
+      set_id: 1,
+      name: 'Test Set',
+      upload_date: new Date().toISOString(),
+      parameters: '{}',
+      total_documents: 10,
+    });
+
+    const documentSet = await metadataManager.getDocumentSet(1);
+
+    expect(documentSet).toEqual({
+      documentSetId: 1,
+      name: 'Test Set',
+      uploadDate: expect.any(Date),
+      parameters: {},
+      totalDocuments: 10,
+    });
+  });
+
+  it('should update the document count for a document set', async () => {
+    const runQuerySpy = vi.spyOn(metadataManager, 'runQuery').mockResolvedValueOnce([]);
+
+    await metadataManager.updateDocumentCount(1, 5);
+
+    expect(runQuerySpy).toHaveBeenCalledWith(metadataManager.queries.updateDocumentCount, [5, 1]);
+  });
+
+  it('should delete a document set by ID', async () => {
+    const runQuerySpy = vi.spyOn(metadataManager, 'runQuery').mockResolvedValueOnce([]);
+
+    await metadataManager.deleteDocumentSet(1);
+
+    expect(runQuerySpy).toHaveBeenCalledWith(metadataManager.queries.deleteDocumentSet, [1]);
+  });
+
+  it('should retrieve default settings if none exist', async () => {
+    vi.spyOn(metadataManager, 'runQuerySingle').mockResolvedValueOnce(null);
+
+    const settings = await metadataManager.getSettings();
+
+    expect(settings).toEqual({
+      openAIKey: null,
+      oLlamaBaseURL: null,
+      azureOpenAIKey: null,
+      azureOpenAIEndpoint: null,
+      azureOpenAIApiVersion: '2024-02-01',
+      mistralApiKey: null,
+      geminiApiKey: null,
+    });
+  });
+
+  it('should update settings', async () => {
+    const runQuerySpy = vi.spyOn(metadataManager, 'runQuery').mockResolvedValueOnce([]);
+
+    const result = await metadataManager.setSettings({
+      openAIKey: 'test-key',
+      oLlamaBaseURL: 'http://localhost',
+      azureOpenAIKey: 'azure-key',
+      azureOpenAIEndpoint: 'http://azure.endpoint',
+      azureOpenAIApiVersion: '2024-02-01',
+      mistralApiKey: 'mistral-key',
+      geminiApiKey: 'gemini-key',
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(runQuerySpy).toHaveBeenCalledWith(metadataManager.queries.upsertSettings, [
+      JSON.stringify({
+        openAIKey: 'test-key',
+        oLlamaBaseURL: 'http://localhost',
+        azureOpenAIKey: 'azure-key',
+        azureOpenAIEndpoint: 'http://azure.endpoint',
+        azureOpenAIApiVersion: '2024-02-01',
+        mistralApiKey: 'mistral-key',
+        geminiApiKey: 'gemini-key',
+      }),
+      JSON.stringify({
+        openAIKey: 'test-key',
+        oLlamaBaseURL: 'http://localhost',
+        azureOpenAIKey: 'azure-key',
+        azureOpenAIEndpoint: 'http://azure.endpoint',
+        azureOpenAIApiVersion: '2024-02-01',
+        mistralApiKey: 'mistral-key',
+        geminiApiKey: 'gemini-key',
+      }),
+    ]);
+  });
+});

package/tests/csvLoader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/tests/csvLoader.test.ts

@@ -0,0 +1,88 @@
+//@ts-nocheck
+import { describe, it, expect, vi } from 'vitest';
+import { readFileSync } from 'fs';
+import { loadDocumentsFromCsv } from '../src/services/csvLoader.js';
+import { Document } from 'llamaindex';
+import Papa from 'papaparse';
+
+
+vi.mock('fs');
+vi.mock('papaparse');
+
+describe('csvLoader.ts', () => {
+  describe('loadDocumentsFromCsv', () => {
+    it('should load documents from CSV and return Document instances', async () => {
+      const mockFileContent = 'text,metadata1,metadata2\ncontent1,meta1,meta2\ncontent2,meta3,meta4';
+      const mockParsedData = {
+        data: [
+          { text: 'content1', metadata1: 'meta1', metadata2: 'meta2' },
+          { text: 'content2', metadata1: 'meta3', metadata2: 'meta4' }
+        ]
+      };
+      readFileSync.mockReturnValue(mockFileContent);
+      Papa.parse.mockReturnValue(mockParsedData);
+
+      const result = await loadDocumentsFromCsv('path/to/csv', 'text');
+
+      expect(remove_id(result)).toEqual(remove_id([
+        new Document({ text: 'content1', metadata: { metadata1: 'meta1', metadata2: 'meta2' } }),
+        new Document({ text: 'content2', metadata: { metadata1: 'meta3', metadata2: 'meta4' } })
+      ]));
+    });
+
+    it('should handle empty CSV file', async () => {
+      const mockFileContent = '';
+      const mockParsedData = { data: [] };
+      readFileSync.mockReturnValue(mockFileContent);
+      Papa.parse.mockReturnValue(mockParsedData);
+
+      const result = await loadDocumentsFromCsv('path/to/csv', 'text');
+
+      expect(result).toEqual([]);
+    });
+
+    it('should handle missing text column', async () => {
+      const mockFileContent = 'metadata1,metadata2\nmeta1,meta2\nmeta3,meta4';
+      const mockParsedData = {
+        data: [
+          { metadata1: 'meta1', metadata2: 'meta2' },
+          { metadata1: 'meta3', metadata2: 'meta4' }
+        ]
+      };
+      readFileSync.mockReturnValue(mockFileContent);
+      Papa.parse.mockReturnValue(mockParsedData);
+
+      const result = await loadDocumentsFromCsv('path/to/csv', 'text');
+
+      expect(remove_id(result)).toEqual(remove_id([
+        new Document({ text: undefined, metadata: { metadata1: 'meta1', metadata2: 'meta2' } }),
+        new Document({ text: undefined, metadata: { metadata1: 'meta3', metadata2: 'meta4' } })
+      ]));
+    });
+
+    it('should handle null values in metadata', async () => {
+        const mockFileContent = 'text,metadata1,metadata2\ncontent1,,meta2\ncontent2,meta3,';
+        const mockParsedData = {
+            data: [
+            { text: 'content1', metadata1: null, metadata2: 'meta2' },
+            { text: 'content2', metadata1: 'meta3', metadata2: null }
+            ]
+        };
+        readFileSync.mockReturnValue(mockFileContent);
+        Papa.parse.mockReturnValue(mockParsedData);
+    
+        const result = await loadDocumentsFromCsv('path/to/csv', 'text');
+        expect(remove_id(result)).toEqual(remove_id([
+            new Document({ text: 'content1', metadata: { metadata1: '', metadata2: 'meta2' } }),
+            new Document({ text: 'content2', metadata: { metadata1: 'meta3', metadata2: '' } })
+        ]));
+        });
+    });
+});
+
+function remove_id(list_of_documents): Document[] {
+  return list_of_documents.map((doc) => {
+    const { id_, ...doc_without_id } = doc;
+    return doc_without_id;
+});
+}

package/tests/embedding.test.d.ts

@@ -0,0 +1 @@
+export {};

package/tests/embedding.test.ts

@@ -0,0 +1,425 @@
+//@ts-nocheck
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createEmbeddings, previewResults, getDocStore, getIndex, search } from '../src/api/embedding.js';
+import { loadDocumentsFromCsv } from '../src/services/csvLoader.js';
+import { transformDocumentsToNodes, estimateCost, searchDocuments, getExistingVectorStoreIndex, persistNodes, getExistingDocStore } from '../src/services/embeddings.js';
+import { MetadataMode } from 'llamaindex';
+
+// filepath: /Users/jeremybmerrill/code/meaningfully/src/main/api/embedding.test.ts
+
+
+vi.mock('../src/services/csvLoader');
+vi.mock('../src/services/embeddings');
+
+describe('embedding.ts', () => {
+    describe('createEmbeddings', () => {
+        it('should create embeddings and return success', async () => {
+            const mockDocuments = [{ text: 'doc1' }, { text: 'doc2' }];
+            const mockNodes = [{ node: 'node1' }, { node: 'node2' }];
+            const mockIndex = 'index1';
+            loadDocumentsFromCsv.mockResolvedValue(mockDocuments);
+            transformDocumentsToNodes.mockResolvedValue(mockNodes);
+            persistNodes.mockResolvedValue(mockIndex);
+
+            const result = await createEmbeddings('path/to/csv', 'text', {}, {});
+
+            expect(result).toEqual({ success: true, index: mockIndex });
+        });
+
+        it('should return error on failure', async () => {
+            loadDocumentsFromCsv.mockRejectedValue(new Error('Failed to load documents'));
+
+            const result = await createEmbeddings('path/to/csv', 'text', {}, {});
+
+            expect(result).toEqual({ success: false, error: 'Failed to load documents' });
+        });
+
+        it('should handle empty documents', async () => {
+            loadDocumentsFromCsv.mockResolvedValue([]);
+
+            const result = await createEmbeddings('path/to/csv', 'text', {}, {});
+
+            expect(result).toEqual({ success: false, error: 'That CSV does not appear to contain any documents. Please check the file and try again.' });
+        });
+    });
+
+    describe('previewResults', () => {
+        it('should return preview results and estimated cost', async () => {
+            const mockDocuments = Array(20).fill({ text: 'doc' });
+            const mockNodes = [{ text: 'node1', metadata: {} }, { text: 'node2', metadata: {} }];
+            const mockPreviewNodes = [{ text: 'node1', metadata: {} }, { text: 'node2', metadata: {} }];
+            const mockEstimate = { estimatedPrice: 10, tokenCount: 100, pricePer1M: 0.01 };
+            loadDocumentsFromCsv.mockResolvedValue(mockDocuments);
+            transformDocumentsToNodes.mockResolvedValue(mockNodes);
+            estimateCost.mockReturnValue(mockEstimate);
+
+            const result = await previewResults('path/to/csv', 'text', {});
+
+            expect(result).toEqual({
+                success: true,
+                nodes: mockPreviewNodes,
+                ...mockEstimate
+            });
+        });
+
+        it('should return error on failure', async () => {
+            loadDocumentsFromCsv.mockRejectedValue(new Error('Failed to load documents'));
+
+            const result = await previewResults('path/to/csv', 'text', {});
+
+            expect(result).toEqual({ success: false, error: 'Failed to load documents' });
+        });
+
+        it('should handle empty documents', async () => {
+            loadDocumentsFromCsv.mockResolvedValue([]);
+
+            const result = await previewResults('path/to/csv', 'text', {});
+
+            expect(result).toEqual({ success: false, error: 'That CSV does not appear to contain any documents. Please check the file and try again.' });
+        });
+    });
+
+    describe('getDocStore', () => {
+        it('should return existing doc store', async () => {
+            const mockDocStore = 'docStore';
+            getExistingDocStore.mockResolvedValue(mockDocStore);
+
+            const result = await getDocStore({});
+
+            expect(result).toBe(mockDocStore);
+        });
+    });
+
+    describe('getIndex', () => {
+        it('should return existing vector store index', async () => {
+            const mockIndex = 'index';
+            getExistingVectorStoreIndex.mockResolvedValue(mockIndex);
+
+            const result = await getIndex({}, {});
+
+            expect(result).toBe(mockIndex);
+        });
+    });
+
+    describe('search', () => {
+        it('should return search results', async () => {
+            const mockResults = [
+                { node: { getContent: () => 'content1', metadata: {} }, score: 1 },
+                { node: { getContent: () => 'content2', metadata: {} }, score: 2 }
+            ];
+            searchDocuments.mockResolvedValue(mockResults);
+
+            const result = await search('index', 'query');
+
+            expect(result).toEqual([
+                { text: 'content1', score: 1, metadata: {} },
+                { text: 'content2', score: 2, metadata: {} }
+            ]);
+        });
+
+        it('should handle no search results', async () => {
+            searchDocuments.mockResolvedValue([]);
+
+            const result = await search('index', 'query');
+
+            expect(result).toEqual([]);
+        });
+
+        it('should handle search results with null scores', async () => {
+            const mockResults = [
+                { node: { getContent: () => 'content1', metadata: {} }, score: null },
+                { node: { getContent: () => 'content2', metadata: {} }, score: null }
+            ];
+            searchDocuments.mockResolvedValue(mockResults);
+
+            const result = await search('index', 'query');
+
+            expect(result).toEqual([
+                { text: 'content1', score: 0, metadata: {} },
+                { text: 'content2', score: 0, metadata: {} }
+            ]);
+        });
+    });
+});
+
+  describe('previewResults', () => {
+    it('should return preview results and estimated cost', async () => {
+      const mockDocuments = Array(20).fill({ text: 'doc' });
+      const mockNodes = [{ text: 'node1', metadata: {} }, { text: 'node2', metadata: {} }];
+      const mockPreviewNodes = [{ text: 'node1', metadata: {} }, { text: 'node2', metadata: {} }];
+      const mockEstimate = { estimatedPrice: 10, tokenCount: 100, pricePer1M: 0.01 };
+      loadDocumentsFromCsv.mockResolvedValue(mockDocuments);
+      transformDocumentsToNodes.mockResolvedValue(mockNodes);
+      estimateCost.mockReturnValue(mockEstimate);
+
+      const result = await previewResults('path/to/csv', 'text', {});
+
+      expect(result).toEqual({
+        success: true,
+        nodes: mockPreviewNodes,
+        ...mockEstimate
+      });
+    });
+
+    it('should return error on failure', async () => {
+      loadDocumentsFromCsv.mockRejectedValue(new Error('Failed to load documents'));
+
+      const result = await previewResults('path/to/csv', 'text', {});
+
+      expect(result).toEqual({ success: false, error: 'Failed to load documents' });
+    });
+  });
+
+  describe('getDocStore', () => {
+    it('should return existing doc store', async () => {
+      const mockDocStore = 'docStore';
+      getExistingDocStore.mockResolvedValue(mockDocStore);
+
+      const result = await getDocStore({});
+
+      expect(result).toBe(mockDocStore);
+    });
+  });
+
+  describe('getIndex', () => {
+    it('should return existing vector store index', async () => {
+      const mockIndex = 'index';
+      getExistingVectorStoreIndex.mockResolvedValue(mockIndex);
+
+      const result = await getIndex({}, {});
+
+      expect(result).toBe(mockIndex);
+    });
+  });
+    describe('search', () => {
+        it('should return search results', async () => {
+        const mockResults = [
+            { node: { getContent: () => 'content1', metadata: {} }, score: 1 },
+            { node: { getContent: () => 'content2', metadata: {} }, score: 2 }
+        ];
+        searchDocuments.mockResolvedValue(mockResults);
+    
+        const result = await search('index', 'query');
+    
+        expect(result).toEqual([
+            { text: 'content1', score: 1, metadata: {} },
+            { text: 'content2', score: 2, metadata: {} }
+        ]);
+        });
+    
+        it('should handle no search results', async () => {
+        searchDocuments.mockResolvedValue([]);
+    
+        const result = await search('index', 'query');
+    
+        expect(result).toEqual([]);
+        });
+    
+        it('should handle search results with null scores', async () => {
+        const mockResults = [
+            { node: { getContent: () => 'content1', metadata: {} }, score: null },
+            { node: { getContent: () => 'content2', metadata: {} }, score: null }
+        ];
+        searchDocuments.mockResolvedValue(mockResults);
+    
+        const result = await search('index', 'query');
+    
+        expect(result).toEqual([
+            { text: 'content1', score: 0, metadata: {} },
+            { text: 'content2', score: 0, metadata: {} }
+        ]);
+        });
+    });
+    describe('createEmbeddings with progress tracking', () => {
+      beforeEach(() => {
+        vi.clearAllMocks();
+      });
+
+      it('should pass progress callback to persistNodes', async () => {
+        // Setup mocks
+        const mockDocuments = [{ text: 'doc1' }, { text: 'doc2' }];
+        const mockNodes = [{ text: 'node1', metadata: {} }, { text: 'node2', metadata: {} }];
+        const mockIndex = 'index1';
+        loadDocumentsFromCsv.mockResolvedValue(mockDocuments);
+        transformDocumentsToNodes.mockResolvedValue(mockNodes);
+        persistNodes.mockImplementation((nodes, config, settings, clients, callback) => {
+          // Call the callback with sample progress
+          if (callback) {
+            callback(1, 2);  // 50% progress
+            callback(2, 2);  // 100% progress
+          }
+          return Promise.resolve(mockIndex);
+        });
+
+        // Execute
+        const result = await createEmbeddings('path/to/csv', 'text', { modelName: 'test-model' }, {}, {});
+
+        // Verify
+        expect(persistNodes).toHaveBeenCalledTimes(1);
+        expect(persistNodes.mock.calls[0][4]).toBeInstanceOf(Function); // Verify callback was passed
+        expect(result).toEqual({ success: true, index: mockIndex });
+      });
+
+      it('should correctly track progress through ProgressManager', async () => {
+        // Setup
+        vi.mock('../src/services/progressManager', () => {
+          const mockInstance = {
+            startOperation: vi.fn(),
+            updateProgress: vi.fn(),
+            completeOperation: vi.fn(),
+            clearOperation: vi.fn()
+          };
+          
+          return {
+            ProgressManager: {
+              getInstance: () => mockInstance
+            }
+          };
+        });
+        
+        // Re-import to use mocked version
+        const { createEmbeddings } = await import('../src/api/embedding.js');
+        const { ProgressManager } = await import('../src/services/progressManager.js');
+        
+        const mockDocuments = [{ text: 'doc1' }, { text: 'doc2' }];
+        const mockNodes = [{ text: 'node1', metadata: {} }];
+        const mockIndex = 'testIndex';
+        
+        loadDocumentsFromCsv.mockResolvedValue(mockDocuments);
+        transformDocumentsToNodes.mockResolvedValue(mockNodes);
+        persistNodes.mockImplementation((nodes, config, settings, clients, callback) => {
+          if (callback) callback(1, 2); // Call with 50% progress
+          return Promise.resolve(mockIndex);
+        });
+        
+        // Execute
+        await createEmbeddings('path/to/csv', 'text', {}, {}, {});
+        
+        // Verify
+        const progressManager = ProgressManager.getInstance();
+        expect(progressManager.startOperation).toHaveBeenCalledWith(expect.stringMatching(/^embed-\d+$/), 100);
+        expect(progressManager.updateProgress).toHaveBeenCalledWith(expect.any(String), 5);
+        expect(progressManager.updateProgress).toHaveBeenCalledWith(expect.any(String), expect.any(Number));
+        expect(progressManager.completeOperation).toHaveBeenCalledWith(expect.any(String));
+      });
+
+      it('should properly calculate percentage in progress callback', async () => {
+        // Setup mocks with spy on updateProgress
+        vi.mock('../src/services/progressManager', () => {
+          const mockInstance = {
+            startOperation: vi.fn(),
+            updateProgress: vi.fn(),
+            completeOperation: vi.fn(),
+            clearOperation: vi.fn()
+          };
+          
+          return {
+            ProgressManager: {
+              getInstance: () => mockInstance
+            }
+          };
+        });
+        
+        // Re-import to use mocked version
+        const { createEmbeddings } = await import('../src/api/embedding.js');
+        const { ProgressManager } = await import('../src/services/progressManager.js');
+
+        const mockDocuments = [{ text: 'doc1' }];
+        const mockNodes = [{ text: 'node1', metadata: {} }];
+        loadDocumentsFromCsv.mockResolvedValue(mockDocuments);
+        transformDocumentsToNodes.mockResolvedValue(mockNodes);
+        
+        // Simulate persistNodes calling the callback with various progress values
+        persistNodes.mockImplementation((nodes, config, settings, clients, callback) => {
+          if (callback) {
+            callback(0, 10);  // 0% progress
+            callback(5, 10);  // 50% progress
+            callback(10, 10); // 100% progress
+          }
+          return Promise.resolve('mockIndex');
+        });
+        
+        // Execute
+        await createEmbeddings('path/to/csv', 'text', {}, {}, {});
+        
+        // Verify percentage calculations
+        // Initial update at 5%
+        const progressManager = ProgressManager.getInstance();
+        expect(progressManager.updateProgress).toHaveBeenCalledWith(expect.any(String), 5);
+        
+        // Progress updates: 0%, 50%, 100% mapped to 5-95% range
+        expect(progressManager.updateProgress).toHaveBeenCalledWith(expect.any(String), 5);   // 0% -> 5%
+        expect(progressManager.updateProgress).toHaveBeenCalledWith(expect.any(String), 50);  // 50% -> 50%
+        expect(progressManager.updateProgress).toHaveBeenCalledWith(expect.any(String), 95);  // 100% -> 95%
+      });
+
+      it('should clear operation on empty documents', async () => {
+        // Setup
+        vi.mock('../src/services/progressManager', () => {
+          const mockInstance = {
+            startOperation: vi.fn(),
+            updateProgress: vi.fn(),
+            completeOperation: vi.fn(),
+            clearOperation: vi.fn()
+          };
+          
+          return {
+            ProgressManager: {
+              getInstance: () => mockInstance
+            }
+          };
+        });
+        
+        // Re-import to use mocked version
+        const { createEmbeddings } = await import('../src/api/embedding.js');
+        const { ProgressManager } = await import('../src/services/progressManager.js');
+
+        loadDocumentsFromCsv.mockResolvedValue([]);
+        
+        // Execute
+        const result = await createEmbeddings('path/to/csv', 'text', {}, {}, {});
+        
+        // Verify
+        const progressManager = ProgressManager.getInstance();
+        expect(progressManager.clearOperation).toHaveBeenCalled();
+        expect(result).toEqual({
+          success: false, 
+          error: "That CSV does not appear to contain any documents. Please check the file and try again."
+        });
+      });
+
+      it('shoulde complete operation on successful embedding', async () => {
+        // Setup
+        vi.mock('../src/services/progressManager', () => {
+          const mockInstance = {
+            startOperation: vi.fn(),
+            updateProgress: vi.fn(),
+            completeOperation: vi.fn(),
+            clearOperation: vi.fn()
+          };
+          
+          return {
+            ProgressManager: {
+              getInstance: () => mockInstance
+            }
+          };
+        });
+        
+        // Re-import to use mocked version
+        const { createEmbeddings } = await import('../src/api/embedding.js');
+        const { ProgressManager } = await import('../src/services/progressManager.js');
+
+        const mockDocuments = [{ text: 'doc1' }];
+        const mockNodes = [{ text: 'node1', metadata: {} }];
+        loadDocumentsFromCsv.mockResolvedValue(mockDocuments);
+        transformDocumentsToNodes.mockResolvedValue(mockNodes);
+        persistNodes.mockResolvedValue('mockIndex');
+        
+        // Execute
+        await createEmbeddings('path/to/csv', 'text', {}, {}, {});
+        
+        // Verify
+        const progressManager = ProgressManager.getInstance();
+        expect(progressManager.completeOperation).toHaveBeenCalled();
+      });
+    });

package/tests/embeddings.test.d.ts

@@ -0,0 +1 @@
+export {};