@mastra/chroma 0.1.6-alpha.0 → 0.1.6-alpha.3

package/.turbo/turbo-build.log

@@ -1,18 +1,23 @@
 
-> @mastra/chroma@0.1.6-alpha.0 build /home/runner/work/mastra/mastra/stores/chroma
-> tsup src/index.ts --format esm --experimental-dts --clean --treeshake
+> @mastra/chroma@0.1.6-alpha.3 build /home/runner/work/mastra/mastra/stores/chroma
+> tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.3.6
 TSC Build start
-TSC ⚡️ Build success in 6840ms
+TSC ⚡️ Build success in 9238ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.7.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/chroma/dist/_tsup-dts-rollup.d.ts
-DTS ⚡️ Build success in 5624ms
+Analysis will use the bundled TypeScript version 5.7.3
+Writing package typings: /home/runner/work/mastra/mastra/stores/chroma/dist/_tsup-dts-rollup.d.cts
+DTS ⚡️ Build success in 10295ms
 CLI Cleaning output folder
 ESM Build start
-ESM dist/index.js 6.49 KB
-ESM ⚡️ Build success in 454ms
+CJS Build start
+ESM dist/index.js 7.28 KB
+ESM ⚡️ Build success in 715ms
+CJS dist/index.cjs 7.31 KB
+CJS ⚡️ Build success in 714ms

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @mastra/chroma
 
+## 0.1.6-alpha.3
+
+### Patch Changes
+
+- 0fd78ac: Update vector store functions to use object params
+- fd14a3f: Updating filter location from @mastra/core/filter to @mastra/core/vector/filter
+- 4d4e1e1: Updated vector tests and pinecone
+- bb4f447: Add support for commonjs
+- Updated dependencies [0fd78ac]
+- Updated dependencies [0d25b75]
+- Updated dependencies [fd14a3f]
+- Updated dependencies [3f369a2]
+- Updated dependencies [4d4e1e1]
+- Updated dependencies [bb4f447]
+  - @mastra/core@0.4.3-alpha.3
+
+## 0.1.6-alpha.2
+
+### Patch Changes
+
+- Updated dependencies [2512a93]
+- Updated dependencies [e62de74]
+  - @mastra/core@0.4.3-alpha.2
+
+## 0.1.6-alpha.1
+
+### Patch Changes
+
+- 5f28f44: Updated Chroma Vector to allow for document storage
+- Updated dependencies [0d185b1]
+- Updated dependencies [ed55f1d]
+- Updated dependencies [8d13b14]
+- Updated dependencies [3ee4831]
+- Updated dependencies [108793c]
+- Updated dependencies [5f28f44]
+  - @mastra/core@0.4.3-alpha.1
+
 ## 0.1.6-alpha.0
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @mastra/chroma
 
-Vector store implementation for ChromaDB using the official chromadb client with added dimension validation and collection management.
+Vector store implementation for ChromaDB using the official chromadb client with added dimension validation, collection management, and document storage capabilities.
 
 ## Installation
 
@@ -22,21 +22,28 @@ const vectorStore = new ChromaVector({
 });
 
 // Create a new collection
-await vectorStore.createIndex('my-collection', 1536, 'cosine');
+await vectorStore.createIndex({ indexName: 'my-collection', dimension: 1536, metric: 'cosine' });
 
-// Add vectors
+// Add vectors with documents
 const vectors = [[0.1, 0.2, ...], [0.3, 0.4, ...]];
 const metadata = [{ text: 'doc1' }, { text: 'doc2' }];
-const ids = await vectorStore.upsert('my-collection', vectors, metadata);
-
-// Query vectors
-const results = await vectorStore.query(
-  'my-collection',
-  [0.1, 0.2, ...],
-  10, // topK
-  { text: { $eq: 'doc1' } }, // optional filter
-  false // includeVector
-);
+const documents = ['full text 1', 'full text 2'];
+const ids = await vectorStore.upsert({
+  indexName: 'my-collection',
+  vectors,
+  metadata,
+  documents, // store original text
+});
+
+// Query vectors with document filtering
+const results = await vectorStore.query({
+  indexName: 'my-collection',
+  queryVector: [0.1, 0.2, ...],
+  topK: 10, // topK
+  filter: { text: { $eq: 'doc1' } }, // metadata filter
+  includeVector: false, // includeVector
+  documentFilter: { $contains: 'specific text' } // document content filter
+});
 ```
 
 ## Configuration
@@ -54,6 +61,8 @@ Optional:
 ## Features
 
 - Vector similarity search with cosine, euclidean, and dot product metrics
+- Document storage and retrieval
+- Document content filtering
 - Strict vector dimension validation
 - Collection-based organization
 - Metadata filtering support
@@ -64,9 +73,9 @@ Optional:
 
 ## Methods
 
-- `createIndex(indexName, dimension, metric?)`: Create a new collection
-- `upsert(indexName, vectors, metadata?, ids?)`: Add or update vectors
-- `query(indexName, queryVector, topK?, filter?, includeVector?)`: Search for similar vectors
+- `createIndex({ indexName, dimension, metric? })`: Create a new collection
+- `upsert({ indexName, vectors, metadata?, ids?, documents? })`: Add or update vectors with optional document storage
+- `query({ indexName, queryVector, topK?, filter?, includeVector?, documentFilter? })`: Search for similar vectors with optional document filtering
 - `listIndexes()`: List all collections
 - `describeIndex(indexName)`: Get collection statistics
 - `deleteIndex(indexName)`: Delete a collection
@@ -78,6 +87,7 @@ Query results include:
 - `id`: Vector ID
 - `score`: Distance/similarity score
 - `metadata`: Associated metadata
+- `document`: Original document text (if stored)
 - `vector`: Original vector (if includeVector is true)
 
 ## Related Links

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,56 @@
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
+import type { IndexStats } from '@mastra/core/vector';
+import { MastraVector } from '@mastra/core/vector';
+import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { ParamsToArgs } from '@mastra/core/vector';
+import type { QueryResult } from '@mastra/core/vector';
+import type { QueryVectorParams } from '@mastra/core/vector';
+import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFilter } from '@mastra/core/vector/filter';
+
+/**
+ * Translator for Chroma filter queries.
+ * Maintains MongoDB-compatible syntax while ensuring proper validation
+ * and normalization of values.
+ */
+export declare class ChromaFilterTranslator extends BaseFilterTranslator {
+    protected getSupportedOperators(): OperatorSupport;
+    translate(filter?: VectorFilter): VectorFilter;
+    private translateNode;
+    private translateOperator;
+}
+
+declare interface ChromaQueryVectorParams extends QueryVectorParams {
+    documentFilter?: VectorFilter;
+}
+
+declare interface ChromaUpsertVectorParams extends UpsertVectorParams {
+    documents?: string[];
+}
+
+declare class ChromaVector extends MastraVector {
+    private client;
+    private collections;
+    constructor({ path, auth, }: {
+        path: string;
+        auth?: {
+            provider: string;
+            credentials: string;
+        };
+    });
+    getCollection(indexName: string, throwIfNotExists?: boolean): Promise<any>;
+    private validateVectorDimensions;
+    upsert(...args: ParamsToArgs<ChromaUpsertVectorParams>): Promise<string[]>;
+    private HnswSpaceMap;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<ChromaQueryVectorParams>): Promise<QueryResult[]>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    deleteIndex(indexName: string): Promise<void>;
+}
+export { ChromaVector }
+export { ChromaVector as ChromaVector_alias_1 }
+
+export { }

package/dist/_tsup-dts-rollup.d.ts

@@ -1,9 +1,13 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
-import { Filter } from '@mastra/core/filter';
-import { IndexStats } from '@mastra/core/vector';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { CreateIndexParams } from '@mastra/core/vector';
+import type { IndexStats } from '@mastra/core/vector';
 import { MastraVector } from '@mastra/core/vector';
-import { OperatorSupport } from '@mastra/core/filter';
-import { QueryResult } from '@mastra/core/vector';
+import type { OperatorSupport } from '@mastra/core/vector/filter';
+import type { ParamsToArgs } from '@mastra/core/vector';
+import type { QueryResult } from '@mastra/core/vector';
+import type { QueryVectorParams } from '@mastra/core/vector';
+import type { UpsertVectorParams } from '@mastra/core/vector';
+import type { VectorFilter } from '@mastra/core/vector/filter';
 
 /**
  * Translator for Chroma filter queries.
@@ -12,11 +16,19 @@ import { QueryResult } from '@mastra/core/vector';
  */
 export declare class ChromaFilterTranslator extends BaseFilterTranslator {
     protected getSupportedOperators(): OperatorSupport;
-    translate(filter?: Filter): Filter | undefined;
+    translate(filter?: VectorFilter): VectorFilter;
     private translateNode;
     private translateOperator;
 }
 
+declare interface ChromaQueryVectorParams extends QueryVectorParams {
+    documentFilter?: VectorFilter;
+}
+
+declare interface ChromaUpsertVectorParams extends UpsertVectorParams {
+    documents?: string[];
+}
+
 declare class ChromaVector extends MastraVector {
     private client;
     private collections;
@@ -27,12 +39,13 @@ declare class ChromaVector extends MastraVector {
             credentials: string;
         };
     });
-    private getCollection;
+    getCollection(indexName: string, throwIfNotExists?: boolean): Promise<any>;
     private validateVectorDimensions;
-    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
-    createIndex(indexName: string, dimension: number, metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
-    transformFilter(filter?: Filter): Filter | undefined;
-    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean): Promise<QueryResult[]>;
+    upsert(...args: ParamsToArgs<ChromaUpsertVectorParams>): Promise<string[]>;
+    private HnswSpaceMap;
+    createIndex(...args: ParamsToArgs<CreateIndexParams>): Promise<void>;
+    transformFilter(filter?: VectorFilter): VectorFilter;
+    query(...args: ParamsToArgs<ChromaQueryVectorParams>): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
     describeIndex(indexName: string): Promise<IndexStats>;
     deleteIndex(indexName: string): Promise<void>;

package/dist/index.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+var vector = require('@mastra/core/vector');
+var chromadb = require('chromadb');
+var filter = require('@mastra/core/vector/filter');
+
+// src/vector/index.ts
+var ChromaFilterTranslator = class extends filter.BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+      logical: ["$and", "$or"],
+      array: ["$in", "$nin"],
+      element: [],
+      regex: [],
+      custom: []
+    };
+  }
+  translate(filter) {
+    if (this.isEmpty(filter)) return filter;
+    this.validateFilter(filter);
+    return this.translateNode(filter);
+  }
+  translateNode(node, currentPath = "") {
+    if (this.isRegex(node)) {
+      throw new Error("Regex is not supported in Chroma");
+    }
+    if (this.isPrimitive(node)) return this.normalizeComparisonValue(node);
+    if (Array.isArray(node)) return { $in: this.normalizeArrayValues(node) };
+    const entries = Object.entries(node);
+    const firstEntry = entries[0];
+    if (entries.length === 1 && firstEntry && this.isOperator(firstEntry[0])) {
+      const [operator, value] = firstEntry;
+      const translated = this.translateOperator(operator, value);
+      return this.isLogicalOperator(operator) ? { [operator]: translated } : translated;
+    }
+    const result = {};
+    const multiOperatorConditions = [];
+    for (const [key, value] of entries) {
+      const newPath = currentPath ? `${currentPath}.${key}` : key;
+      if (this.isOperator(key)) {
+        result[key] = this.translateOperator(key, value);
+        continue;
+      }
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        const valueEntries = Object.entries(value);
+        if (valueEntries.every(([op]) => this.isOperator(op)) && valueEntries.length > 1) {
+          valueEntries.forEach(([op, opValue]) => {
+            multiOperatorConditions.push({
+              [newPath]: { [op]: this.normalizeComparisonValue(opValue) }
+            });
+          });
+          continue;
+        }
+        if (Object.keys(value).length === 0) {
+          result[newPath] = this.translateNode(value);
+        } else {
+          const hasOperators = Object.keys(value).some((k) => this.isOperator(k));
+          if (hasOperators) {
+            const normalizedValue = {};
+            for (const [op, opValue] of Object.entries(value)) {
+              normalizedValue[op] = this.isOperator(op) ? this.translateOperator(op, opValue) : opValue;
+            }
+            result[newPath] = normalizedValue;
+          } else {
+            Object.assign(result, this.translateNode(value, newPath));
+          }
+        }
+      } else {
+        result[newPath] = this.translateNode(value);
+      }
+    }
+    if (multiOperatorConditions.length > 0) {
+      return { $and: multiOperatorConditions };
+    }
+    if (Object.keys(result).length > 1 && !currentPath) {
+      return {
+        $and: Object.entries(result).map(([key, value]) => ({ [key]: value }))
+      };
+    }
+    return result;
+  }
+  translateOperator(operator, value) {
+    if (this.isLogicalOperator(operator)) {
+      return Array.isArray(value) ? value.map((item) => this.translateNode(item)) : this.translateNode(value);
+    }
+    return this.normalizeComparisonValue(value);
+  }
+};
+
+// src/vector/index.ts
+var ChromaVector = class extends vector.MastraVector {
+  client;
+  collections;
+  constructor({
+    path,
+    auth
+  }) {
+    super();
+    this.client = new chromadb.ChromaClient({
+      path,
+      auth
+    });
+    this.collections = /* @__PURE__ */ new Map();
+  }
+  async getCollection(indexName, throwIfNotExists = true) {
+    try {
+      const collection = await this.client.getCollection({ name: indexName, embeddingFunction: void 0 });
+      this.collections.set(indexName, collection);
+    } catch {
+      if (throwIfNotExists) {
+        throw new Error(`Index ${indexName} does not exist`);
+      }
+      return null;
+    }
+    return this.collections.get(indexName);
+  }
+  validateVectorDimensions(vectors, dimension) {
+    for (let i = 0; i < vectors.length; i++) {
+      if (vectors?.[i]?.length !== dimension) {
+        throw new Error(
+          `Vector at index ${i} has invalid dimension ${vectors?.[i]?.length}. Expected ${dimension} dimensions.`
+        );
+      }
+    }
+  }
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args, ["documents"]);
+    const { indexName, vectors, metadata, ids, documents } = params;
+    const collection = await this.getCollection(indexName);
+    const stats = await this.describeIndex(indexName);
+    this.validateVectorDimensions(vectors, stats.dimension);
+    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
+    const normalizedMetadata = metadata || vectors.map(() => ({}));
+    await collection.upsert({
+      ids: generatedIds,
+      embeddings: vectors,
+      metadatas: normalizedMetadata,
+      documents
+    });
+    return generatedIds;
+  }
+  HnswSpaceMap = {
+    cosine: "cosine",
+    euclidean: "l2",
+    dotproduct: "ip",
+    l2: "euclidean",
+    ip: "dotproduct"
+  };
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
+    if (!Number.isInteger(dimension) || dimension <= 0) {
+      throw new Error("Dimension must be a positive integer");
+    }
+    const hnswSpace = this.HnswSpaceMap[metric];
+    if (!["cosine", "l2", "ip"].includes(hnswSpace)) {
+      throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+    }
+    await this.client.createCollection({
+      name: indexName,
+      metadata: {
+        dimension,
+        "hnsw:space": this.HnswSpaceMap[metric]
+      }
+    });
+  }
+  transformFilter(filter) {
+    const translator = new ChromaFilterTranslator();
+    return translator.translate(filter);
+  }
+  async query(...args) {
+    const params = this.normalizeArgs("query", args, ["documentFilter"]);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter } = params;
+    const collection = await this.getCollection(indexName, true);
+    const defaultInclude = ["documents", "metadatas", "distances"];
+    const translatedFilter = this.transformFilter(filter);
+    const results = await collection.query({
+      queryEmbeddings: [queryVector],
+      nResults: topK,
+      where: translatedFilter,
+      whereDocument: documentFilter,
+      include: includeVector ? [...defaultInclude, "embeddings"] : defaultInclude
+    });
+    return (results.ids[0] || []).map((id, index) => ({
+      id,
+      score: results.distances?.[0]?.[index] || 0,
+      metadata: results.metadatas?.[0]?.[index] || {},
+      document: results.documents?.[0]?.[index],
+      ...includeVector && { vector: results.embeddings?.[0]?.[index] || [] }
+    }));
+  }
+  async listIndexes() {
+    const collections = await this.client.listCollections();
+    return collections.map((collection) => collection);
+  }
+  async describeIndex(indexName) {
+    const collection = await this.getCollection(indexName);
+    const count = await collection.count();
+    const metadata = collection.metadata;
+    const hnswSpace = metadata?.["hnsw:space"];
+    return {
+      dimension: metadata?.dimension || 0,
+      count,
+      metric: this.HnswSpaceMap[hnswSpace]
+    };
+  }
+  async deleteIndex(indexName) {
+    await this.client.deleteCollection({ name: indexName });
+    this.collections.delete(indexName);
+  }
+};
+
+exports.ChromaVector = ChromaVector;

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { ChromaVector } from './_tsup-dts-rollup.cjs';

package/dist/index.js

@@ -1,6 +1,6 @@
-import { BaseFilterTranslator } from '@mastra/core/filter';
 import { MastraVector } from '@mastra/core/vector';
 import { ChromaClient } from 'chromadb';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/vector/index.ts
 var ChromaFilterTranslator = class extends BaseFilterTranslator {
@@ -105,7 +105,7 @@ var ChromaVector = class extends MastraVector {
     try {
       const collection = await this.client.getCollection({ name: indexName, embeddingFunction: void 0 });
       this.collections.set(indexName, collection);
-    } catch (error) {
+    } catch {
       if (throwIfNotExists) {
         throw new Error(`Index ${indexName} does not exist`);
       }
@@ -122,7 +122,9 @@ var ChromaVector = class extends MastraVector {
       }
     }
   }
-  async upsert(indexName, vectors, metadata, ids) {
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args, ["documents"]);
+    const { indexName, vectors, metadata, ids, documents } = params;
     const collection = await this.getCollection(indexName);
     const stats = await this.describeIndex(indexName);
     this.validateVectorDimensions(vectors, stats.dimension);
@@ -131,28 +133,43 @@ var ChromaVector = class extends MastraVector {
     await collection.upsert({
       ids: generatedIds,
       embeddings: vectors,
-      metadatas: normalizedMetadata
+      metadatas: normalizedMetadata,
+      documents
     });
     return generatedIds;
   }
-  async createIndex(indexName, dimension, metric = "cosine") {
+  HnswSpaceMap = {
+    cosine: "cosine",
+    euclidean: "l2",
+    dotproduct: "ip",
+    l2: "euclidean",
+    ip: "dotproduct"
+  };
+  async createIndex(...args) {
+    const params = this.normalizeArgs("createIndex", args);
+    const { indexName, dimension, metric = "cosine" } = params;
     if (!Number.isInteger(dimension) || dimension <= 0) {
       throw new Error("Dimension must be a positive integer");
     }
+    const hnswSpace = this.HnswSpaceMap[metric];
+    if (!["cosine", "l2", "ip"].includes(hnswSpace)) {
+      throw new Error(`Invalid metric: "${metric}". Must be one of: cosine, euclidean, dotproduct`);
+    }
     await this.client.createCollection({
       name: indexName,
       metadata: {
         dimension,
-        metric
+        "hnsw:space": this.HnswSpaceMap[metric]
       }
     });
   }
   transformFilter(filter) {
-    const chromaFilter = new ChromaFilterTranslator();
-    const translatedFilter = chromaFilter.translate(filter);
-    return translatedFilter;
+    const translator = new ChromaFilterTranslator();
+    return translator.translate(filter);
   }
-  async query(indexName, queryVector, topK = 10, filter, includeVector = false) {
+  async query(...args) {
+    const params = this.normalizeArgs("query", args, ["documentFilter"]);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false, documentFilter } = params;
     const collection = await this.getCollection(indexName, true);
     const defaultInclude = ["documents", "metadatas", "distances"];
     const translatedFilter = this.transformFilter(filter);
@@ -160,12 +177,14 @@ var ChromaVector = class extends MastraVector {
       queryEmbeddings: [queryVector],
       nResults: topK,
       where: translatedFilter,
+      whereDocument: documentFilter,
       include: includeVector ? [...defaultInclude, "embeddings"] : defaultInclude
     });
     return (results.ids[0] || []).map((id, index) => ({
       id,
       score: results.distances?.[0]?.[index] || 0,
       metadata: results.metadatas?.[0]?.[index] || {},
+      document: results.documents?.[0]?.[index],
       ...includeVector && { vector: results.embeddings?.[0]?.[index] || [] }
     }));
   }
@@ -177,10 +196,11 @@ var ChromaVector = class extends MastraVector {
     const collection = await this.getCollection(indexName);
     const count = await collection.count();
     const metadata = collection.metadata;
+    const hnswSpace = metadata?.["hnsw:space"];
     return {
       dimension: metadata?.dimension || 0,
       count,
-      metric: metadata?.metric
+      metric: this.HnswSpaceMap[hnswSpace]
     };
   }
   async deleteIndex(indexName) {

package/docker-compose.yaml

@@ -0,0 +1,7 @@
+services:
+  chroma:
+    image: chromadb/chroma
+    ports:
+      - 8000:8000
+volumes:
+  pgdata:

package/eslint.config.js

@@ -0,0 +1,6 @@
+import { createConfig } from '@internal/lint/eslint';
+
+const config = await createConfig();
+
+/** @type {import("eslint").Linter.Config[]} */
+export default [...config];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/chroma",
-  "version": "0.1.6-alpha.0",
+  "version": "0.1.6-alpha.3",
   "description": "Chroma vector store provider for Mastra",
   "type": "module",
   "main": "dist/index.js",
@@ -10,24 +10,31 @@
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
     "chromadb": "^1.9.4",
-    "@mastra/core": "^0.4.3-alpha.0"
+    "@mastra/core": "^0.4.3-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
     "@types/node": "^22.13.1",
     "tsup": "^8.0.1",
     "typescript": "^5.7.3",
-    "vitest": "^3.0.4"
+    "vitest": "^3.0.4",
+    "eslint": "^9.20.1",
+    "@internal/lint": "0.0.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake",
     "build:watch": "pnpm build --watch",
-    "test": "vitest run"
+    "test": "vitest run",
+    "lint": "eslint ."
   }
 }