prisma-arktype 2.3.0 → 2.5.0

package/README.md

@@ -132,6 +132,216 @@ const whereResult = UserWhere(whereClause);
 // ...
 ```
 
+## Where Clause Filters
+
+Where clauses support advanced filtering through dedicated filter types. Fields can accept either direct values or filter objects with comparison operators.
+
+### Filter Types
+
+#### String Filters
+
+String fields can use `StringFilter` for advanced text filtering:
+
+```typescript
+import { UserWhere } from "./generated/validators";
+
+// Direct value
+const result1 = UserWhere({ email: "user@example.com" });
+
+// Filter object
+const result2 = UserWhere({
+  email: {
+    contains: "example",      // Contains substring
+    startsWith: "user",       // Starts with prefix
+    endsWith: ".com",         // Ends with suffix
+    equals: "user@example.com", // Exact match
+    not: "admin@example.com", // Not equal to
+    in: ["user1@example.com", "user2@example.com"], // In array
+    notIn: ["banned@example.com"], // Not in array
+    gt: "a",                  // Greater than (lexicographic)
+    gte: "a",                 // Greater than or equal
+    lt: "z",                  // Less than
+    lte: "z"                  // Less than or equal
+  }
+});
+```
+
+**Available operations:** `contains`, `startsWith`, `endsWith`, `equals`, `not`, `in`, `notIn`, `gt`, `gte`, `lt`, `lte`
+
+#### Number Filters
+
+Integer fields (`Int`, `BigInt`) use `IntFilter`, while floating-point fields (`Float`, `Decimal`) use `NumberFilter`:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+// Direct value
+const result1 = PostWhere({ views: 100 });
+
+// Filter object for integers
+const result2 = PostWhere({
+  views: {
+    equals: 100,
+    gt: 50,                   // Greater than
+    gte: 50,                  // Greater than or equal
+    lt: 200,                  // Less than
+    lte: 200,                 // Less than or equal
+    in: [100, 200, 300],      // In array
+    notIn: [0],               // Not in array
+    not: 0                    // Not equal to
+  }
+});
+
+// Filter object for floats/decimals
+const result3 = PostWhere({
+  rating: {
+    gte: 4.5,
+    lte: 5.0
+  }
+});
+```
+
+**Available operations:** `equals`, `gt`, `gte`, `lt`, `lte`, `in`, `notIn`, `not`
+
+#### Boolean Filters
+
+Boolean fields use `BooleanFilter`:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+// Direct value
+const result1 = PostWhere({ published: true });
+
+// Filter object
+const result2 = PostWhere({
+  published: {
+    equals: true,
+    not: false
+  }
+});
+```
+
+**Available operations:** `equals`, `not`
+
+#### Enum Filters
+
+Enum fields use the generic `enumFilter`:
+
+```typescript
+import { PaymentWhere } from "./generated/validators";
+
+// Direct enum value
+const result1 = PaymentWhere({ currency: "USD" });
+
+// Filter object
+const result2 = PaymentWhere({
+  currency: {
+    equals: "USD",
+    in: ["USD", "EUR", "GBP"],
+    notIn: ["JPY"],
+    not: "CAD"
+  }
+});
+```
+
+**Available operations:** `equals`, `in`, `notIn`, `not`
+
+#### DateTime Filters
+
+DateTime fields use `DateTimeFilter`:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+// Direct Date value
+const result1 = PostWhere({ createdAt: new Date("2024-01-01") });
+
+// Filter object
+const result2 = PostWhere({
+  createdAt: {
+    equals: new Date("2024-01-01"),
+    gt: new Date("2024-01-01"),   // After
+    gte: new Date("2024-01-01"),  // On or after
+    lt: new Date("2024-12-31"),   // Before
+    lte: new Date("2024-12-31"),  // On or before
+    in: [new Date("2024-01-01"), new Date("2024-06-01")],
+    notIn: [new Date("2024-07-04")],
+    not: new Date("2024-01-01")
+  }
+});
+```
+
+**Available operations:** `equals`, `gt`, `gte`, `lt`, `lte`, `in`, `notIn`, `not`
+
+#### Array Filters
+
+Array fields use specialized array filters with operations for list matching:
+
+```typescript
+import { TagWhere } from "./generated/validators";
+
+// String arrays
+const result1 = TagWhere({
+  labels: {
+    isEmpty: false,           // Array is empty
+    has: "important",         // Array contains value
+    hasEvery: ["tag1", "tag2"], // Array contains all values
+    hasSome: ["tag1", "tag2"],  // Array contains at least one value
+    equals: ["exact", "match"]  // Array exactly matches
+  }
+});
+
+// Number arrays
+const result2 = ScoresWhere({
+  values: {
+    isEmpty: false,
+    has: 100,
+    hasEvery: [90, 95, 100],
+    hasSome: [100, 200],
+    equals: [90, 95, 100]
+  }
+});
+
+// Enum arrays
+const result3 = PermissionsWhere({
+  roles: {
+    isEmpty: false,
+    has: "ADMIN",
+    hasEvery: ["USER", "ADMIN"],
+    hasSome: ["ADMIN", "MODERATOR"],
+    equals: ["USER"]
+  }
+});
+```
+
+**Available array filter types:**
+- `StringArrayFilter` - for `String[]` fields
+- `NumberArrayFilter` - for `Int[]`, `Float[]`, `Decimal[]` fields
+- `BigIntArrayFilter` - for `BigInt[]` fields
+- `arrayFilter(EnumType)` - for enum array fields
+
+**Available operations:** `isEmpty`, `has`, `hasEvery`, `hasSome`, `equals`
+
+### Combining Filters
+
+You can combine multiple filters in a single where clause:
+
+```typescript
+import { PostWhere } from "./generated/validators";
+
+const complexQuery = PostWhere({
+  title: { contains: "TypeScript" },
+  views: { gte: 100 },
+  published: true,
+  rating: { gte: 4.0 },
+  createdAt: {
+    gte: new Date("2024-01-01"),
+    lt: new Date("2024-12-31")
+  }
+});
+```
+
 ### Generated Code Examples
 
 #### Enum Generation
@@ -239,6 +449,7 @@ Control schema generation using annotations in your Prisma schema. All annotatio
 | `@prisma-arktype.input.hide` | Field | Hide from Create and Update input schemas |
 | `@prisma-arktype.create.input.hide` | Field | Hide from Create input schema only |
 | `@prisma-arktype.update.input.hide` | Field | Hide from Update input schema only |
+| `@prisma-arktype.schema="<schema>"` | Field | Custom ArkType schema (inline or external) |
 | `@prisma-arktype.typeOverwrite="<type>"` | Field | Override the generated ArkType type |
 
 ### Hide Fields/Models
@@ -301,6 +512,48 @@ model User {
 
 This allows you to use any ArkType type definition, including built-in refinements like `string.email`, `string.url`, `number.integer`, etc.
 
+### Custom Schemas
+
+Bring your own ArkType schemas for any field using `@prisma-arktype.schema`:
+
+```prisma
+model User {
+  id String @id
+
+  /// Inline schema for structured JSON
+  /// @prisma-arktype.schema="{ name: 'string', age: 'number' }"
+  profile Json
+
+  /// External schema from a file (named export)
+  /// @prisma-arktype.schema="../schemas/address:AddressSchema"
+  address Json
+
+  /// External schema (default export)
+  /// @prisma-arktype.schema="../schemas/config"
+  settings Json
+}
+```
+
+**Import Path Rules:**
+- Paths are relative to the generated validators directory
+- Named exports use colon syntax: `"path:ExportName"`
+- Default exports omit the colon: `"path"`
+- Works with ANY field type (not just Json)
+
+**Priority:** `schema` > `typeOverwrite` > default type mapping
+
+**Example external schema file** (`schemas/address.ts`):
+```typescript
+import { type } from "arktype";
+
+export const AddressSchema = type({
+  street: "string",
+  city: "string",
+  zipCode: "string",
+  country: "string",
+});
+```
+
 ## Type Mapping
 
 Prisma types are mapped to ArkType as follows:

package/dist/index.js

@@ -2,7 +2,9 @@
 import { writeFile, access, rm, mkdir } from 'node:fs/promises';
 import generatorHelperPkg from '@prisma/generator-helper';
 import { type, ArkErrors } from 'arktype';
-import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
 
 const configSchema = type({
   output: "string = './prisma/generated/validators'",
@@ -43,6 +45,9 @@ function isHiddenInputUpdate(annotation) {
 function isTypeOverwrite(annotation) {
   return annotation.type === "TYPE_OVERWRITE";
 }
+function isSchema(annotation) {
+  return annotation.type === "SCHEMA";
+}
 const annotationKeys = [
   {
     keys: ["@prisma-arktype.hide", "@prisma-arktype.hidden"],
@@ -66,9 +71,11 @@ const annotationKeys = [
     ],
     type: "HIDDEN_INPUT_UPDATE"
   },
-  { keys: ["@prisma-arktype.typeOverwrite"], type: "TYPE_OVERWRITE" }
+  { keys: ["@prisma-arktype.typeOverwrite"], type: "TYPE_OVERWRITE" },
+  { keys: ["@prisma-arktype.schema"], type: "SCHEMA" }
 ];
 const prismaArktypeTypeOverwriteRegex = /@prisma-arktype\.typeOverwrite=(.+)/;
+const prismaArktypeSchemaRegex = /@prisma-arktype\.schema="([^"]+)"/;
 function extractAnnotations(documentation) {
   const annotations = [];
   const descriptionLines = [];
@@ -78,18 +85,52 @@ function extractAnnotations(documentation) {
       for (const { keys, type } of annotationKeys) {
         for (const key of keys) {
           if (line.includes(key)) {
-            isAnnotation = true;
             if (type === "TYPE_OVERWRITE") {
               const match = line.match(prismaArktypeTypeOverwriteRegex);
               if (match && match[1]) {
+                isAnnotation = true;
                 annotations.push({
                   type: "TYPE_OVERWRITE",
                   value: match[1].trim()
                 });
-              } else {
-                throw new Error(`Invalid TYPE_OVERWRITE annotation: ${line}`);
+              }
+            } else if (type === "SCHEMA") {
+              const match = line.match(prismaArktypeSchemaRegex);
+              if (match && match[1]) {
+                isAnnotation = true;
+                const schemaValue = match[1].trim();
+                const isExternal = schemaValue.includes("/") || !(schemaValue.startsWith("{") || schemaValue.startsWith('"') || schemaValue.startsWith("'")) && schemaValue.includes(":") && // Ensure it's a module:export pattern, not object syntax like { key: value }
+                !schemaValue.includes(" ") && !schemaValue.includes(",");
+                if (isExternal) {
+                  const colonIndex = schemaValue.indexOf(":");
+                  if (colonIndex > 0) {
+                    const path = schemaValue.substring(0, colonIndex).trim();
+                    const exportName = schemaValue.substring(colonIndex + 1).trim();
+                    annotations.push({
+                      type: "SCHEMA",
+                      value: schemaValue,
+                      isExternal: true,
+                      importPath: path,
+                      exportName
+                    });
+                  } else {
+                    annotations.push({
+                      type: "SCHEMA",
+                      value: schemaValue,
+                      isExternal: true,
+                      importPath: schemaValue
+                    });
+                  }
+                } else {
+                  annotations.push({
+                    type: "SCHEMA",
+                    value: schemaValue,
+                    isExternal: false
+                  });
+                }
               }
             } else {
+              isAnnotation = true;
               annotations.push({ type });
             }
             break;
@@ -112,6 +153,21 @@ function extractAnnotations(documentation) {
   };
 }
 
+const require = createRequire(import.meta.url);
+function isPrismaV7OrHigher() {
+  try {
+    const prismaClientPath = require.resolve("@prisma/client");
+    const clientDir = dirname(prismaClientPath);
+    const packageJsonPath = join(clientDir, "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const version = packageJson.version;
+    const majorVersion = Number.parseInt(version.split(".")[0], 10);
+    return majorVersion >= 7;
+  } catch {
+    return false;
+  }
+}
+const IS_PRISMA_V7_OR_HIGHER = isPrismaV7OrHigher();
 const primitiveTypes = [
   "Int",
   "BigInt",
@@ -143,7 +199,10 @@ function stringifyPrimitiveType(type, annotations) {
     case "Boolean":
       return `"boolean"`;
     case "Bytes":
-      return `"instanceof Buffer"`;
+      if (IS_PRISMA_V7_OR_HIGHER) {
+        return "Uint8ArrayInstance";
+      }
+      return "BufferInstance";
     default:
       throw new Error(`Unsupported primitive type: ${type}`);
   }
@@ -179,6 +238,7 @@ function stringifyEnum(enumData) {
 }
 
 const processedPlain = [];
+const extRegex$1 = /\.(ts|js)$/;
 function processPlain(models) {
   for (const model of models) {
     const result = stringifyPlain(model);
@@ -186,7 +246,9 @@ function processPlain(models) {
       processedPlain.push({
         name: model.name,
         stringified: result.stringified,
-        enumDependencies: result.enumDependencies
+        enumDependencies: result.enumDependencies,
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
   }
@@ -194,14 +256,19 @@ function processPlain(models) {
 }
 function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
   const config = getConfig();
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
   const fields = [];
   const enumDependencies = [];
+  const externalSchemaDependencies = [];
+  const runtimeDependencies = [];
+  function generateUniqueAlias(path, exportName, fieldName) {
+    const baseName = exportName || path.split("/").pop()?.replace(extRegex$1, "") || "Schema";
+    const suffix = fieldName ? `_${fieldName}` : "";
+    return `${baseName}${suffix}`;
+  }
   for (const field of model.fields) {
     const {
       annotations: fieldAnnotations,
@@ -218,10 +285,36 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
       if (config.ignoredKeysOnInputModels.includes(field.name)) continue;
       if (field.name.endsWith("Id") && field.relationName) continue;
     }
+    const schemaAnnotation = fieldAnnotations.find(isSchema);
     const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
     let fieldType;
     let fieldName = field.name;
-    if (typeOverwrite) {
+    if (schemaAnnotation) {
+      if (schemaAnnotation.isExternal) {
+        const alias = generateUniqueAlias(
+          schemaAnnotation.importPath,
+          schemaAnnotation.exportName,
+          field.name
+        );
+        if (!externalSchemaDependencies.some((d) => d.localAlias === alias)) {
+          const dependency = {
+            importPath: schemaAnnotation.importPath,
+            localAlias: alias
+          };
+          if (schemaAnnotation.exportName) {
+            dependency.exportName = schemaAnnotation.exportName;
+          }
+          externalSchemaDependencies.push(dependency);
+        }
+        fieldType = alias;
+      } else {
+        if (schemaAnnotation.value.trim().startsWith("{")) {
+          fieldType = schemaAnnotation.value;
+        } else {
+          fieldType = `"${schemaAnnotation.value}"`;
+        }
+      }
+    } else if (typeOverwrite) {
       fieldType = typeOverwrite.value;
     } else if (isPrimitivePrismaFieldType(field.type)) {
       fieldType = stringifyPrimitiveType(field.type);
@@ -235,16 +328,24 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     } else {
       continue;
     }
-    const isEnumType = field.kind === "enum" && !typeOverwrite;
+    const isEnumType = field.kind === "enum" && !typeOverwrite && !schemaAnnotation;
+    const isExternalSchema = schemaAnnotation?.isExternal === true;
+    const isBytesField = field.type === "Bytes" && !typeOverwrite && !schemaAnnotation;
+    if (isBytesField) {
+      const runtimeDep = fieldType;
+      if (!runtimeDependencies.includes(runtimeDep)) {
+        runtimeDependencies.push(runtimeDep);
+      }
+    }
     if (field.isList) {
-      if (isEnumType) {
+      if (isExternalSchema || isEnumType || isBytesField) {
         fieldType = `${fieldType}.array()`;
       } else {
         fieldType = `"${wrapPrimitiveWithArray(fieldType.slice(1, -1))}"`;
       }
     }
     if (!field.isRequired) {
-      if (isEnumType) {
+      if (isExternalSchema || isEnumType || isBytesField) {
         fieldType = `${fieldType}.or("null")`;
       } else {
         const inner = fieldType.slice(1, -1);
@@ -263,7 +364,9 @@ function stringifyPlain(model, isInputCreate = false, isInputUpdate = false) {
     stringified: `{
   ${fields.join(",\n  ")}
 }`,
-    enumDependencies
+    enumDependencies,
+    externalSchemaDependencies,
+    runtimeDependencies
   };
 }
 function stringifyPlainInputCreate(model) {
@@ -283,7 +386,9 @@ function processCreate(models) {
       processedCreate.push({
         name: model.name,
         stringified: result.stringified,
-        enumDependencies: result.enumDependencies
+        enumDependencies: result.enumDependencies,
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
   }
@@ -376,9 +481,7 @@ function processRelations(models) {
   Object.freeze(processedRelations);
 }
 function stringifyRelations(model) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -425,9 +528,7 @@ function processRelationsCreate(models) {
   Object.freeze(processedRelationsCreate);
 }
 function stringifyRelationsInputCreate(model, allModels) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -472,9 +573,7 @@ function processRelationsUpdate(models) {
   Object.freeze(processedRelationsUpdate);
 }
 function stringifyRelationsInputUpdate(model, allModels) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -532,9 +631,7 @@ function processSelect(models) {
   Object.freeze(processedSelect);
 }
 function stringifySelect(model) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
@@ -560,7 +657,9 @@ function processUpdate(models) {
       processedUpdate.push({
         name: model.name,
         stringified: result.stringified,
-        enumDependencies: result.enumDependencies
+        enumDependencies: result.enumDependencies,
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
   }
@@ -569,6 +668,7 @@ function processUpdate(models) {
 
 const processedWhere = [];
 const processedWhereUnique = [];
+const extRegex = /\.(ts|js)$/;
 function processWhere(models) {
   for (const model of models) {
     const result = stringifyWhere(model);
@@ -576,7 +676,9 @@ function processWhere(models) {
       processedWhere.push({
         name: model.name,
         stringified: result.stringified,
-        enumDependencies: result.enumDependencies
+        enumDependencies: result.enumDependencies,
+        externalSchemaDependencies: result.externalSchemaDependencies,
+        runtimeDependencies: result.runtimeDependencies
       });
     }
     const uniqueResult = stringifyWhereUnique(model);
@@ -584,7 +686,9 @@ function processWhere(models) {
       processedWhereUnique.push({
         name: model.name,
         stringified: uniqueResult.stringified,
-        enumDependencies: uniqueResult.enumDependencies
+        enumDependencies: uniqueResult.enumDependencies,
+        externalSchemaDependencies: uniqueResult.externalSchemaDependencies,
+        runtimeDependencies: uniqueResult.runtimeDependencies
       });
     }
   }
@@ -592,21 +696,52 @@ function processWhere(models) {
   Object.freeze(processedWhereUnique);
 }
 function stringifyWhere(model) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
   const fields = [];
   const enumDependencies = [];
+  const externalSchemaDependencies = [];
+  const runtimeDependencies = [];
+  function generateUniqueAlias(path, exportName, fieldName) {
+    const baseName = exportName || path.split("/").pop()?.replace(extRegex, "") || "Schema";
+    const suffix = fieldName ? `_${fieldName}` : "";
+    return `${baseName}${suffix}`;
+  }
   for (const field of model.fields) {
     const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
     if (field.kind === "object") continue;
+    const schemaAnnotation = fieldAnnotations.find(isSchema);
     const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
     let fieldType;
-    if (typeOverwrite) {
+    if (schemaAnnotation) {
+      if (schemaAnnotation.isExternal) {
+        const alias = generateUniqueAlias(
+          schemaAnnotation.importPath,
+          schemaAnnotation.exportName,
+          field.name
+        );
+        if (!externalSchemaDependencies.some((d) => d.localAlias === alias)) {
+          const dependency = {
+            importPath: schemaAnnotation.importPath,
+            localAlias: alias
+          };
+          if (schemaAnnotation.exportName) {
+            dependency.exportName = schemaAnnotation.exportName;
+          }
+          externalSchemaDependencies.push(dependency);
+        }
+        fieldType = alias;
+      } else {
+        if (schemaAnnotation.value.trim().startsWith("{")) {
+          fieldType = schemaAnnotation.value;
+        } else {
+          fieldType = `"${schemaAnnotation.value}"`;
+        }
+      }
+    } else if (typeOverwrite) {
       fieldType = typeOverwrite.value;
     } else if (isPrimitivePrismaFieldType(field.type)) {
       fieldType = stringifyPrimitiveType(field.type);
@@ -620,41 +755,143 @@ function stringifyWhere(model) {
     } else {
       continue;
     }
-    const isEnumType = field.kind === "enum" && !typeOverwrite;
+    const isEnumType = field.kind === "enum" && !typeOverwrite && !schemaAnnotation;
+    const isExternalSchema = schemaAnnotation?.isExternal === true;
+    const isDateTimeField = field.type === "DateTime" && !typeOverwrite && !schemaAnnotation;
+    const isStringField = field.type === "String" && !typeOverwrite && !schemaAnnotation;
+    const isIntField = (field.type === "Int" || field.type === "BigInt") && !typeOverwrite && !schemaAnnotation;
+    const isFloatField = (field.type === "Float" || field.type === "Decimal") && !typeOverwrite && !schemaAnnotation;
+    const isBooleanField = field.type === "Boolean" && !typeOverwrite && !schemaAnnotation;
+    const isBytesField = field.type === "Bytes" && !typeOverwrite && !schemaAnnotation;
+    if (isBytesField) {
+      const runtimeDep = fieldType;
+      if (!runtimeDependencies.includes(runtimeDep)) {
+        runtimeDependencies.push(runtimeDep);
+      }
+    }
     if (field.isList) {
       if (isEnumType) {
+        fieldType = `arrayFilter(${fieldType})`;
+        if (!runtimeDependencies.includes("arrayFilter")) {
+          runtimeDependencies.push("arrayFilter");
+        }
+      } else if (field.type === "String" && !typeOverwrite && !schemaAnnotation) {
+        fieldType = "StringArrayFilter";
+        if (!runtimeDependencies.includes("StringArrayFilter")) {
+          runtimeDependencies.push("StringArrayFilter");
+        }
+      } else if ((field.type === "Int" || field.type === "Float" || field.type === "Decimal") && !typeOverwrite && !schemaAnnotation) {
+        fieldType = "NumberArrayFilter";
+        if (!runtimeDependencies.includes("NumberArrayFilter")) {
+          runtimeDependencies.push("NumberArrayFilter");
+        }
+      } else if (field.type === "BigInt" && !typeOverwrite && !schemaAnnotation) {
+        fieldType = "BigIntArrayFilter";
+        if (!runtimeDependencies.includes("BigIntArrayFilter")) {
+          runtimeDependencies.push("BigIntArrayFilter");
+        }
+      } else if (isExternalSchema || isBytesField) {
         fieldType = `${fieldType}.array()`;
       } else {
         const inner = fieldType.slice(1, -1);
         fieldType = `"${wrapPrimitiveWithArray(inner)}"`;
       }
     }
+    if (isDateTimeField && !field.isList) {
+      fieldType = `type("Date").or(DateTimeFilter)`;
+      if (!runtimeDependencies.includes("DateTimeFilter")) {
+        runtimeDependencies.push("DateTimeFilter");
+      }
+    }
+    if (isStringField && !field.isList) {
+      fieldType = `type("string").or(StringFilter)`;
+      if (!runtimeDependencies.includes("StringFilter")) {
+        runtimeDependencies.push("StringFilter");
+      }
+    }
+    if (isIntField && !field.isList) {
+      fieldType = `type("number.integer").or(IntFilter)`;
+      if (!runtimeDependencies.includes("IntFilter")) {
+        runtimeDependencies.push("IntFilter");
+      }
+    }
+    if (isFloatField && !field.isList) {
+      fieldType = `type("number").or(NumberFilter)`;
+      if (!runtimeDependencies.includes("NumberFilter")) {
+        runtimeDependencies.push("NumberFilter");
+      }
+    }
+    if (isEnumType && !field.isList) {
+      fieldType = `type(${fieldType}).or(enumFilter(${fieldType}))`;
+      if (!runtimeDependencies.includes("enumFilter")) {
+        runtimeDependencies.push("enumFilter");
+      }
+    }
+    if (isBooleanField && !field.isList) {
+      fieldType = `type("boolean").or(BooleanFilter)`;
+      if (!runtimeDependencies.includes("BooleanFilter")) {
+        runtimeDependencies.push("BooleanFilter");
+      }
+    }
     fields.push(`"${field.name}?": ${fieldType}`);
   }
   return {
     stringified: `{
   ${fields.join(",\n  ")}
 }`,
-    enumDependencies
+    enumDependencies,
+    externalSchemaDependencies,
+    runtimeDependencies
   };
 }
 function stringifyWhereUnique(model) {
-  const { hidden } = extractAnnotations(
-    model.documentation
-  );
+  const { hidden } = extractAnnotations(model.documentation);
   if (hidden) {
     return;
   }
   const fields = [];
   const enumDependencies = [];
+  const externalSchemaDependencies = [];
+  const runtimeDependencies = [];
+  function generateUniqueAlias(path, exportName, fieldName) {
+    const baseName = exportName || path.split("/").pop()?.replace(extRegex, "") || "Schema";
+    const suffix = fieldName ? `_${fieldName}` : "";
+    return `${baseName}${suffix}`;
+  }
   for (const field of model.fields) {
     const { annotations: fieldAnnotations, hidden: fieldHidden } = extractAnnotations(field.documentation);
     if (fieldHidden) continue;
     if (field.kind === "object") continue;
     if (!(field.isId || field.isUnique)) continue;
+    const schemaAnnotation = fieldAnnotations.find(isSchema);
     const typeOverwrite = fieldAnnotations.find(isTypeOverwrite);
     let fieldType;
-    if (typeOverwrite) {
+    if (schemaAnnotation) {
+      if (schemaAnnotation.isExternal) {
+        const alias = generateUniqueAlias(
+          schemaAnnotation.importPath,
+          schemaAnnotation.exportName,
+          field.name
+        );
+        if (!externalSchemaDependencies.some((d) => d.localAlias === alias)) {
+          const dependency = {
+            importPath: schemaAnnotation.importPath,
+            localAlias: alias
+          };
+          if (schemaAnnotation.exportName) {
+            dependency.exportName = schemaAnnotation.exportName;
+          }
+          externalSchemaDependencies.push(dependency);
+        }
+        fieldType = alias;
+      } else {
+        if (schemaAnnotation.value.trim().startsWith("{")) {
+          fieldType = schemaAnnotation.value;
+        } else {
+          fieldType = `"${schemaAnnotation.value}"`;
+        }
+      }
+    } else if (typeOverwrite) {
       fieldType = typeOverwrite.value;
     } else if (isPrimitivePrismaFieldType(field.type)) {
       fieldType = stringifyPrimitiveType(field.type);
@@ -668,6 +905,20 @@ function stringifyWhereUnique(model) {
     } else {
       continue;
     }
+    const isDateTimeField = field.type === "DateTime" && !typeOverwrite && !schemaAnnotation;
+    const isBytesField = field.type === "Bytes" && !typeOverwrite && !schemaAnnotation;
+    if (isBytesField) {
+      const runtimeDep = fieldType;
+      if (!runtimeDependencies.includes(runtimeDep)) {
+        runtimeDependencies.push(runtimeDep);
+      }
+    }
+    if (isDateTimeField) {
+      fieldType = `type("Date").or(DateTimeFilter)`;
+      if (!runtimeDependencies.includes("DateTimeFilter")) {
+        runtimeDependencies.push("DateTimeFilter");
+      }
+    }
     fields.push(`"${field.name}?": ${fieldType}`);
   }
   if (fields.length === 0) {
@@ -677,7 +928,9 @@ function stringifyWhereUnique(model) {
     stringified: `{
   ${fields.join(",\n  ")}
 }`,
-    enumDependencies
+    enumDependencies,
+    externalSchemaDependencies,
+    runtimeDependencies
   };
 }
 
@@ -700,6 +953,50 @@ function generateModelImports(modelDependencies) {
   ).join("\n")}
 `;
 }
+function generateExternalSchemaImports(externalSchemaDependencies) {
+  if (!externalSchemaDependencies || externalSchemaDependencies.length === 0) {
+    return "";
+  }
+  return `${externalSchemaDependencies.map((dep) => {
+    if (dep.exportName) {
+      return `import { ${dep.exportName} as ${dep.localAlias} } from "${dep.importPath}";`;
+    }
+    return `import ${dep.localAlias} from "${dep.importPath}";`;
+  }).join("\n")}
+`;
+}
+const RUNTIME_DEPENDENCY_IMPORTS = {
+  DateTimeFilter: `import { DateTimeFilter } from "prisma-arktype/runtime/filters";
+`,
+  StringFilter: `import { StringFilter } from "prisma-arktype/runtime/stringFilter";
+`,
+  NumberFilter: `import { NumberFilter } from "prisma-arktype/runtime/numberFilter";
+`,
+  IntFilter: `import { IntFilter } from "prisma-arktype/runtime/numberFilter";
+`,
+  BooleanFilter: `import { BooleanFilter } from "prisma-arktype/runtime/booleanFilter";
+`,
+  enumFilter: `import { enumFilter } from "prisma-arktype/runtime/enumFilter";
+`,
+  BufferInstance: `import { BufferInstance } from "prisma-arktype/runtime/buffer";
+`,
+  Uint8ArrayInstance: `import { Uint8ArrayInstance } from "prisma-arktype/runtime/uint8array";
+`,
+  arrayFilter: `import { arrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`,
+  StringArrayFilter: `import { StringArrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`,
+  NumberArrayFilter: `import { NumberArrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`,
+  BigIntArrayFilter: `import { BigIntArrayFilter } from "prisma-arktype/runtime/arrayFilters";
+`
+};
+function generateRuntimeDependencyImports(runtimeDependencies) {
+  if (!runtimeDependencies || runtimeDependencies.length === 0) {
+    return "";
+  }
+  return runtimeDependencies.map((dep) => RUNTIME_DEPENDENCY_IMPORTS[dep]).join("");
+}
 function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations, processedWhere, processedWhereUnique, processedCreate, processedUpdate, processedRelationsCreate, processedRelationsUpdate, processedSelect, processedInclude, processedOrderBy) {
   const config = getConfig();
   const modelMap = /* @__PURE__ */ new Map();
@@ -713,7 +1010,13 @@ function mapAllModelsForWrite(processedEnums, processedPlain, processedRelations
   }
   for (const model of processedPlain) {
     const enumImports = generateEnumImports(model.enumDependencies);
-    const content = `${arktypeImport}${enumImports}export const ${model.name}Plain = type(${model.stringified});
+    const externalSchemaImports = generateExternalSchemaImports(
+      model.externalSchemaDependencies
+    );
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Plain = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Plain`, content);
   }
@@ -742,25 +1045,49 @@ export const ${plain.name} = ${plain.name}Plain;
   }
   for (const model of processedWhere) {
     const enumImports = generateEnumImports(model.enumDependencies);
-    const content = `${arktypeImport}${enumImports}export const ${model.name}Where = type(${model.stringified});
+    const externalSchemaImports = generateExternalSchemaImports(
+      model.externalSchemaDependencies
+    );
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Where = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Where`, content);
   }
   for (const model of processedWhereUnique) {
     const enumImports = generateEnumImports(model.enumDependencies);
-    const content = `${arktypeImport}${enumImports}export const ${model.name}WhereUnique = type(${model.stringified});
+    const externalSchemaImports = generateExternalSchemaImports(
+      model.externalSchemaDependencies
+    );
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}WhereUnique = type(${model.stringified});
 `;
     modelMap.set(`${model.name}WhereUnique`, content);
   }
   for (const model of processedCreate) {
     const enumImports = generateEnumImports(model.enumDependencies);
-    const content = `${arktypeImport}${enumImports}export const ${model.name}Create = type(${model.stringified});
+    const externalSchemaImports = generateExternalSchemaImports(
+      model.externalSchemaDependencies
+    );
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Create = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Create`, content);
   }
   for (const model of processedUpdate) {
     const enumImports = generateEnumImports(model.enumDependencies);
-    const content = `${arktypeImport}${enumImports}export const ${model.name}Update = type(${model.stringified});
+    const externalSchemaImports = generateExternalSchemaImports(
+      model.externalSchemaDependencies
+    );
+    const runtimeImports = generateRuntimeDependencyImports(
+      model.runtimeDependencies
+    );
+    const content = `${arktypeImport}${enumImports}${externalSchemaImports}${runtimeImports}export const ${model.name}Update = type(${model.stringified});
 `;
     modelMap.set(`${model.name}Update`, content);
   }

package/dist/runtime/arrayFilters.d.ts

@@ -0,0 +1,46 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+import * as arktype from 'arktype';
+
+/**
+ * @description Generic array filter for Prisma where clauses
+ * Supports: isEmpty, has, hasEvery, hasSome, equals
+ */
+declare const arrayFilter: arktype.Generic<[["t", unknown]], {
+    readonly "isEmpty?": "boolean";
+    readonly "has?": "t";
+    readonly "hasEvery?": "t[]";
+    readonly "hasSome?": "t[]";
+    readonly "equals?": "t[]";
+}, {}, {}>;
+/**
+ * @description String array filter for Prisma where clauses
+ */
+declare const StringArrayFilter: arktype_internal_variants_object_ts.ObjectType<{
+    isEmpty?: boolean;
+    has?: string;
+    hasEvery?: string[];
+    hasSome?: string[];
+    equals?: string[];
+}, {}>;
+/**
+ * @description Number array filter for Prisma where clauses
+ */
+declare const NumberArrayFilter: arktype_internal_variants_object_ts.ObjectType<{
+    isEmpty?: boolean;
+    has?: number;
+    hasEvery?: number[];
+    hasSome?: number[];
+    equals?: number[];
+}, {}>;
+/**
+ * @description BigInt array filter for Prisma where clauses
+ */
+declare const BigIntArrayFilter: arktype_internal_variants_object_ts.ObjectType<{
+    isEmpty?: boolean;
+    has?: number;
+    hasEvery?: number[];
+    hasSome?: number[];
+    equals?: number[];
+}, {}>;
+
+export { BigIntArrayFilter, NumberArrayFilter, StringArrayFilter, arrayFilter };

package/dist/runtime/arrayFilters.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+
+const arrayFilter = type("<t>", {
+  "isEmpty?": "boolean",
+  "has?": "t",
+  "hasEvery?": "t[]",
+  "hasSome?": "t[]",
+  "equals?": "t[]"
+});
+const StringArrayFilter = arrayFilter("string");
+const NumberArrayFilter = arrayFilter("number");
+const BigIntArrayFilter = arrayFilter("number.integer");
+
+export { BigIntArrayFilter, NumberArrayFilter, StringArrayFilter, arrayFilter };

package/dist/runtime/booleanFilter.d.ts

@@ -0,0 +1,12 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Boolean filter for Prisma where clauses
+ * Supports: equals, not
+ */
+declare const BooleanFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: boolean;
+    not?: boolean;
+}, {}>;
+
+export { BooleanFilter };

package/dist/runtime/booleanFilter.js

@@ -0,0 +1,8 @@
+import { type } from 'arktype';
+
+const BooleanFilter = type({
+  "equals?": "boolean",
+  "not?": "boolean"
+});
+
+export { BooleanFilter };

package/dist/runtime/buffer.d.ts

@@ -0,0 +1,8 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Buffer instance type
+ */
+declare const BufferInstance: arktype_internal_variants_object_ts.ObjectType<Buffer<ArrayBufferLike>, {}>;
+
+export { BufferInstance };

package/dist/runtime/buffer.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+
+const BufferInstance = type("unknown").narrow(
+  (value, ctx) => {
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+      return true;
+    } else if (typeof Buffer === "undefined") {
+      ctx.errors.add(ctx.error("Buffer is not defined in this environment"));
+    }
+    return ctx.mustBe("an instance of Buffer");
+  }
+);
+
+export { BufferInstance };

package/dist/runtime/enumFilter.d.ts

@@ -0,0 +1,14 @@
+import * as arktype from 'arktype';
+
+/**
+ * @description Generic enum filter for Prisma where clauses
+ * Supports: equals, in, not, notIn
+ */
+declare const enumFilter: arktype.Generic<[["t", unknown]], {
+    readonly "equals?": "t";
+    readonly "in?": "t[]";
+    readonly "not?": "t";
+    readonly "notIn?": "t[]";
+}, {}, {}>;
+
+export { enumFilter };

package/dist/runtime/enumFilter.js

@@ -0,0 +1,10 @@
+import { type } from 'arktype';
+
+const enumFilter = type("<t>", {
+  "equals?": "t",
+  "in?": "t[]",
+  "not?": "t",
+  "notIn?": "t[]"
+});
+
+export { enumFilter };

package/dist/runtime/filters.d.ts

@@ -0,0 +1,19 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * DateTimeFilter allows querying DateTime fields with comparison operators.
+ * Can be used instead of a direct Date value in where clauses.
+ */
+declare const DateTimeFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: Date;
+    in?: Date[];
+    notIn?: Date[];
+    lt?: Date;
+    lte?: Date;
+    gt?: Date;
+    gte?: Date;
+    not?: Date;
+}, {}>;
+type DateTimeFilter = typeof DateTimeFilter.infer;
+
+export { DateTimeFilter };

package/dist/runtime/filters.js

@@ -0,0 +1,14 @@
+import { type } from 'arktype';
+
+const DateTimeFilter = type({
+  "equals?": "Date",
+  "in?": "Date[]",
+  "notIn?": "Date[]",
+  "lt?": "Date",
+  "lte?": "Date",
+  "gt?": "Date",
+  "gte?": "Date",
+  "not?": "Date"
+});
+
+export { DateTimeFilter };

package/dist/runtime/numberFilter.d.ts

@@ -0,0 +1,32 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Number filter for Prisma where clauses
+ * Supports: equals, gt, gte, in, lt, lte, not, notIn
+ */
+declare const NumberFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: number;
+    gt?: number;
+    gte?: number;
+    in?: number[];
+    lt?: number;
+    lte?: number;
+    not?: number;
+    notIn?: number[];
+}, {}>;
+/**
+ * @description Integer filter for Prisma where clauses (Int, BigInt)
+ * Supports: equals, gt, gte, in, lt, lte, not, notIn
+ */
+declare const IntFilter: arktype_internal_variants_object_ts.ObjectType<{
+    equals?: number;
+    gt?: number;
+    gte?: number;
+    in?: number[];
+    lt?: number;
+    lte?: number;
+    not?: number;
+    notIn?: number[];
+}, {}>;
+
+export { IntFilter, NumberFilter };

package/dist/runtime/numberFilter.js

@@ -0,0 +1,24 @@
+import { type } from 'arktype';
+
+const NumberFilter = type({
+  "equals?": "number",
+  "gt?": "number",
+  "gte?": "number",
+  "in?": "number[]",
+  "lt?": "number",
+  "lte?": "number",
+  "not?": "number",
+  "notIn?": "number[]"
+});
+const IntFilter = type({
+  "equals?": "number.integer",
+  "gt?": "number.integer",
+  "gte?": "number.integer",
+  "in?": "number.integer[]",
+  "lt?": "number.integer",
+  "lte?": "number.integer",
+  "not?": "number.integer",
+  "notIn?": "number.integer[]"
+});
+
+export { IntFilter, NumberFilter };

package/dist/runtime/stringFilter.d.ts

@@ -0,0 +1,21 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description String filter for Prisma where clauses
+ * Supports: contains, endsWith, equals, gt, gte, in, lt, lte, not, notIn, startsWith
+ */
+declare const StringFilter: arktype_internal_variants_object_ts.ObjectType<{
+    contains?: string;
+    endsWith?: string;
+    equals?: string;
+    gt?: string;
+    gte?: string;
+    in?: string[];
+    lt?: string;
+    lte?: string;
+    not?: string;
+    notIn?: string[];
+    startsWith?: string;
+}, {}>;
+
+export { StringFilter };

package/dist/runtime/stringFilter.js

@@ -0,0 +1,17 @@
+import { type } from 'arktype';
+
+const StringFilter = type({
+  "contains?": "string",
+  "endsWith?": "string",
+  "equals?": "string",
+  "gt?": "string",
+  "gte?": "string",
+  "in?": "string[]",
+  "lt?": "string",
+  "lte?": "string",
+  "not?": "string",
+  "notIn?": "string[]",
+  "startsWith?": "string"
+});
+
+export { StringFilter };

package/dist/runtime/uint8array.d.ts

@@ -0,0 +1,9 @@
+import * as arktype_internal_variants_object_ts from 'arktype/internal/variants/object.ts';
+
+/**
+ * @description Uint8Array instance type for Prisma v7+
+ * In Prisma v7+, Bytes fields return as Uint8Array instead of Buffer
+ */
+declare const Uint8ArrayInstance: arktype_internal_variants_object_ts.ObjectType<Uint8Array<ArrayBufferLike>, {}>;
+
+export { Uint8ArrayInstance };

package/dist/runtime/uint8array.js

@@ -0,0 +1,12 @@
+import { type } from 'arktype';
+
+const Uint8ArrayInstance = type("unknown").narrow(
+  (value, ctx) => {
+    if (value instanceof Uint8Array) {
+      return true;
+    }
+    return ctx.mustBe("an instance of Uint8Array");
+  }
+);
+
+export { Uint8ArrayInstance };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-arktype",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Generate ArkType schemas from your Prisma schema",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,6 +9,38 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./runtime/filters": {
+      "import": "./dist/runtime/filters.js",
+      "types": "./dist/runtime/filters.d.ts"
+    },
+    "./runtime/buffer": {
+      "import": "./dist/runtime/buffer.js",
+      "types": "./dist/runtime/buffer.d.ts"
+    },
+    "./runtime/uint8array": {
+      "import": "./dist/runtime/uint8array.js",
+      "types": "./dist/runtime/uint8array.d.ts"
+    },
+    "./runtime/arrayFilters": {
+      "import": "./dist/runtime/arrayFilters.js",
+      "types": "./dist/runtime/arrayFilters.d.ts"
+    },
+    "./runtime/stringFilter": {
+      "import": "./dist/runtime/stringFilter.js",
+      "types": "./dist/runtime/stringFilter.d.ts"
+    },
+    "./runtime/numberFilter": {
+      "import": "./dist/runtime/numberFilter.js",
+      "types": "./dist/runtime/numberFilter.d.ts"
+    },
+    "./runtime/enumFilter": {
+      "import": "./dist/runtime/enumFilter.js",
+      "types": "./dist/runtime/enumFilter.d.ts"
+    },
+    "./runtime/booleanFilter": {
+      "import": "./dist/runtime/booleanFilter.js",
+      "types": "./dist/runtime/booleanFilter.d.ts"
     }
   },
   "bin": {
@@ -39,12 +71,16 @@
     "@prisma/generator-helper": "^6.18.0",
     "arktype": "^2.1.25"
   },
+  "peerDependencies": {
+    "@prisma/client": ">=6"
+  },
   "devDependencies": {
     "@biomejs/biome": "2.3.11",
     "@changesets/cli": "2.29.8",
     "@commitlint/cli": "^20.1.0",
     "@commitlint/config-conventional": "^20.0.0",
-    "@prisma/client": "^6.18.0",
+    "@prisma/client": "7.2.0",
+    "@prisma/internals": "7.2.0",
     "@tilli-pro/biome": "0.9.0",
     "@types/node": "^24.10.0",
     "lefthook": "^2.0.2",
@@ -55,17 +91,27 @@
     "vitest": "^4.0.16"
   },
   "scripts": {
-    "build": "pkgroll",
+    "build": "pkgroll && prisma generate",
     "dev": "pkgroll --watch",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:e2e": "pnpm build && prisma generate && vitest run",
+    "test:e2e": "pnpm build && vitest run",
     "pretest": "pnpm build",
     "postinstall": "lefthook install",
     "lint": "biome check",
     "lint:fix": "biome check --write",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "pnpm build && changeset publish"
+    "release": "pnpm build && changeset publish",
+    "bench": "vitest bench --config vitest.bench.config.ts",
+    "bench:ui": "vitest bench --ui --config vitest.bench.config.ts",
+    "bench:generation": "vitest bench __benchmarks__/suites/generation.bench.ts --config vitest.bench.config.ts",
+    "bench:processors": "vitest bench __benchmarks__/suites/processors.bench.ts --config vitest.bench.config.ts",
+    "bench:annotations": "vitest bench __benchmarks__/suites/annotations.bench.ts --config vitest.bench.config.ts",
+    "bench:memory": "node --expose-gc node_modules/.bin/vitest bench __benchmarks__/suites/memory.bench.ts --config vitest.bench.config.ts",
+    "bench:compare": "tsx __benchmarks__/scripts/compare.ts",
+    "bench:update-baseline": "tsx __benchmarks__/scripts/update-baseline.ts",
+    "bench:profile": "node --cpu-prof --expose-gc node_modules/.bin/vitest bench --config vitest.bench.config.ts",
+    "bench:ci": "tsx __benchmarks__/scripts/run-and-save.ts"
   }
 }