@prisma-next/extension-pgvector 0.0.1

package/README.md

@@ -0,0 +1,171 @@
+# @prisma-next/extension-pgvector
+
+PostgreSQL pgvector extension pack for Prisma Next.
+
+## Overview
+
+This extension pack adds support for the `vector` data type and vector similarity operations (e.g., cosine distance) for PostgreSQL databases with the pgvector extension installed.
+
+## Responsibilities
+
+- **Vector Codec**: Provides codec for `pg/vector@1` type ID mapping to `number[]` JavaScript type
+- **Vector Operations**: Registers vector similarity operations (e.g., `cosineDistance`) for use in queries
+- **CLI Integration**: Provides extension descriptor for `prisma-next.config.ts` configuration
+- **Runtime Extension**: Registers codecs and operations at runtime for vector column operations
+
+## Dependencies
+
+- **`@prisma-next/cli`**: CLI config types and extension descriptor interface
+- **`@prisma-next/sql-operations`**: SQL operation signature types
+- **`@prisma-next/sql-relational-core`**: Codec registry and AST types
+- **`arktype`**: Schema validation for manifest structure
+
+## Installation
+
+```bash
+pnpm add @prisma-next/extension-pgvector
+```
+
+## Database Setup
+
+Before using this extension, ensure the pgvector extension is installed in your PostgreSQL database:
+
+```sql
+CREATE EXTENSION IF NOT EXISTS vector;
+```
+
+## Configuration
+
+Add the extension to your `prisma-next.config.ts`:
+
+```typescript
+import { defineConfig } from '@prisma-next/cli/config-types';
+import postgresAdapter from '@prisma-next/adapter-postgres/control';
+import sql from '@prisma-next/family-sql/cli';
+import postgres from '@prisma-next/targets-postgres/control';
+import pgvector from '@prisma-next/extension-pgvector/control';
+
+export default defineConfig({
+  family: sql,
+  target: postgres,
+  adapter: postgresAdapter,
+  extensions: [pgvector],
+});
+```
+
+## Usage
+
+### Contract Definition
+
+Add vector columns to your contract:
+
+```typescript
+import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
+import type { CodecTypes } from '@prisma-next/adapter-postgres/codec-types';
+import type { CodecTypes as PgVectorCodecTypes } from '@prisma-next/extension-pgvector/codec-types';
+
+type AllCodecTypes = CodecTypes & PgVectorCodecTypes;
+
+export const contract = defineContract<AllCodecTypes>()
+  .target('postgres')
+  .table('post', (t) =>
+    t
+      .column('id', { type: 'pg/int4@1', nullable: false })
+      .column('title', { type: 'pg/text@1', nullable: false })
+      .column('embedding', { type: 'pg/vector@1', nullable: true })
+      .primaryKey(['id']),
+  )
+  .build();
+```
+
+### Runtime Setup
+
+Register the extension when creating your runtime context:
+
+```typescript
+import { createRuntimeContext } from '@prisma-next/sql-runtime';
+import { createPostgresAdapter } from '@prisma-next/adapter-postgres/runtime';
+import pgvector from '@prisma-next/extension-pgvector/runtime';
+
+const adapter = createPostgresAdapter();
+const context = createRuntimeContext({
+  contract,
+  adapter,
+  extensions: [pgvector()],
+});
+```
+
+### Query Usage
+
+Use vector similarity operations in your queries:
+
+```typescript
+import { sql, tables } from '../prisma/query';
+import { param } from '@prisma-next/sql-query/param';
+import type { ResultType } from '@prisma-next/sql-query/types';
+
+const queryVector = [0.1, 0.2, 0.3, /* ... */];
+
+const plan = sql
+  .from(tables.post)
+  .select({
+    id: tables.post.columns.id,
+    title: tables.post.columns.title,
+    distance: tables.post.columns.embedding.cosineDistance(param('queryVector')),
+  })
+  .orderBy(tables.post.columns.embedding.cosineDistance(param('queryVector')).asc())
+  .limit(10)
+  .build({ params: { queryVector } });
+
+type Row = ResultType<typeof plan>;
+```
+
+## Types
+
+### Codec Types
+
+The extension provides a `CodecTypes` export mapping the `pg/vector@1` type ID to `number[]`:
+
+```typescript
+import type { CodecTypes } from '@prisma-next/extension-pgvector/codec-types';
+
+// CodecTypes['pg/vector@1']['output'] = number[]
+```
+
+### Operation Types
+
+The extension provides an `OperationTypes` export for vector operations:
+
+```typescript
+import type { OperationTypes } from '@prisma-next/extension-pgvector/operation-types';
+
+// OperationTypes['pg/vector@1']['cosineDistance'] = (rhs: number[] | vector) => number
+```
+
+## Operations
+
+### cosineDistance
+
+Computes the cosine distance between two vectors.
+
+**Signature**: `cosineDistance(rhs: number[] | vector): number`
+
+**SQL**: Uses the pgvector `<=>` operator: `1 - (vector1 <=> vector2)`
+
+**Example**:
+```typescript
+const distance = tables.post.columns.embedding.cosineDistance(param('queryVector'));
+```
+
+## Capabilities
+
+The extension declares the following capabilities:
+
+- `pgvector/cosine`: Indicates support for cosine distance operations
+
+## References
+
+- [pgvector documentation](https://github.com/pgvector/pgvector)
+- [Prisma Next Architecture Overview](../../../docs/Architecture%20Overview.md)
+- [Extension Packs Guide](../../../docs/reference/Extension-Packs-Naming-and-Layout.md)
+

package/dist/exports/codec-types.d.ts

@@ -0,0 +1,12 @@
+import * as _prisma_next_sql_relational_core_ast from '@prisma-next/sql-relational-core/ast';
+
+/**
+ * Vector codec implementation for pgvector extension.
+ *
+ * Provides encoding/decoding for the `vector` PostgreSQL type.
+ * Wire format is a string like `[1,2,3]` (PostgreSQL vector text format).
+ */
+declare const codecs: _prisma_next_sql_relational_core_ast.CodecDefBuilder<{} & Record<"vector", _prisma_next_sql_relational_core_ast.Codec<"pg/vector@1", string, number[]>>>;
+type CodecTypes = typeof codecs.CodecTypes;
+
+export type { CodecTypes };

package/dist/exports/codec-types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=codec-types.js.map

package/dist/exports/codec-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/exports/control.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Specifies how to import TypeScript types from a package.
+ * Used in extension pack manifests to declare codec and operation type imports.
+ */
+interface TypesImportSpec {
+    readonly package: string;
+    readonly named: string;
+    readonly alias: string;
+}
+type ArgSpecManifest = {
+    readonly kind: 'typeId';
+    readonly type: string;
+} | {
+    readonly kind: 'param';
+} | {
+    readonly kind: 'literal';
+};
+type ReturnSpecManifest = {
+    readonly kind: 'typeId';
+    readonly type: string;
+} | {
+    readonly kind: 'builtin';
+    readonly type: 'number' | 'boolean' | 'string';
+};
+interface LoweringSpecManifest {
+    readonly targetFamily: 'sql';
+    readonly strategy: 'infix' | 'function';
+    readonly template: string;
+}
+interface OperationManifest {
+    readonly for: string;
+    readonly method: string;
+    readonly args: ReadonlyArray<ArgSpecManifest>;
+    readonly returns: ReturnSpecManifest;
+    readonly lowering: LoweringSpecManifest;
+    readonly capabilities?: ReadonlyArray<string>;
+}
+interface ExtensionPackManifest {
+    readonly id: string;
+    readonly version: string;
+    readonly targets?: Record<string, {
+        readonly minVersion?: string;
+    }>;
+    readonly capabilities?: Record<string, unknown>;
+    readonly types?: {
+        readonly codecTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly operationTypes?: {
+            readonly import: TypesImportSpec;
+        };
+        readonly storage?: readonly {
+            readonly typeId: string;
+            readonly familyId: string;
+            readonly targetId: string;
+            readonly nativeType?: string;
+        }[];
+    };
+    readonly operations?: ReadonlyArray<OperationManifest>;
+}
+
+/**
+ * Base interface for control-plane extension instances.
+ *
+ * @template TFamilyId - The family ID (e.g., 'sql', 'document')
+ * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
+ */
+interface ControlExtensionInstance<TFamilyId extends string = string, TTargetId extends string = string> {
+    readonly familyId: TFamilyId;
+    readonly targetId: TTargetId;
+}
+/**
+ * Descriptor for a control-plane extension pack (e.g., pgvector).
+ *
+ * @template TFamilyId - The family ID (e.g., 'sql', 'document')
+ * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
+ * @template TExtensionInstance - The extension instance type
+ */
+interface ControlExtensionDescriptor<TFamilyId extends string, TTargetId extends string, TExtensionInstance extends ControlExtensionInstance<TFamilyId, TTargetId> = ControlExtensionInstance<TFamilyId, TTargetId>> {
+    readonly kind: 'extension';
+    readonly id: string;
+    readonly familyId: TFamilyId;
+    readonly targetId: TTargetId;
+    readonly manifest: ExtensionPackManifest;
+    create(): TExtensionInstance;
+}
+
+/**
+ * pgvector extension descriptor for CLI config.
+ */
+declare const pgvectorExtensionDescriptor: ControlExtensionDescriptor<'sql', 'postgres'>;
+
+export { pgvectorExtensionDescriptor as default };

package/dist/exports/control.js

@@ -0,0 +1,54 @@
+// src/exports/control.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { type } from "arktype";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var TypesImportSpecSchema = type({
+  package: "string",
+  named: "string",
+  alias: "string"
+});
+var ExtensionPackManifestSchema = type({
+  id: "string",
+  version: "string",
+  "targets?": type({ "[string]": type({ "minVersion?": "string" }) }),
+  "capabilities?": "Record<string, unknown>",
+  "types?": type({
+    "codecTypes?": type({
+      import: TypesImportSpecSchema
+    }),
+    "operationTypes?": type({
+      import: TypesImportSpecSchema
+    })
+  }),
+  "operations?": "unknown[]"
+});
+function loadExtensionManifest() {
+  const manifestPath = join(__dirname, "../../packs/manifest.json");
+  const manifestJson = JSON.parse(readFileSync(manifestPath, "utf-8"));
+  const result = ExtensionPackManifestSchema(manifestJson);
+  if (result instanceof type.errors) {
+    const messages = result.map((p) => p.message).join("; ");
+    throw new Error(`Invalid extension manifest structure at ${manifestPath}: ${messages}`);
+  }
+  return result;
+}
+var pgvectorExtensionDescriptor = {
+  kind: "extension",
+  familyId: "sql",
+  targetId: "postgres",
+  // pgvector is postgres-specific
+  id: "pgvector",
+  manifest: loadExtensionManifest(),
+  create: () => ({
+    familyId: "sql",
+    targetId: "postgres"
+  })
+};
+var control_default = pgvectorExtensionDescriptor;
+export {
+  control_default as default
+};
+//# sourceMappingURL=control.js.map

package/dist/exports/control.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/control.ts"],"sourcesContent":["import { readFileSync } from 'node:fs';\nimport { dirname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport type { ExtensionPackManifest } from '@prisma-next/contract/pack-manifest-types';\nimport type { ControlExtensionDescriptor } from '@prisma-next/core-control-plane/types';\nimport { type } from 'arktype';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\n\nconst TypesImportSpecSchema = type({\n  package: 'string',\n  named: 'string',\n  alias: 'string',\n});\n\nconst ExtensionPackManifestSchema = type({\n  id: 'string',\n  version: 'string',\n  'targets?': type({ '[string]': type({ 'minVersion?': 'string' }) }),\n  'capabilities?': 'Record<string, unknown>',\n  'types?': type({\n    'codecTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n    'operationTypes?': type({\n      import: TypesImportSpecSchema,\n    }),\n  }),\n  'operations?': 'unknown[]',\n});\n\n/**\n * Loads the extension pack manifest from packs/manifest.json.\n */\nfunction loadExtensionManifest(): ExtensionPackManifest {\n  const manifestPath = join(__dirname, '../../packs/manifest.json');\n  const manifestJson = JSON.parse(readFileSync(manifestPath, 'utf-8'));\n\n  const result = ExtensionPackManifestSchema(manifestJson);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid extension manifest structure at ${manifestPath}: ${messages}`);\n  }\n\n  return result as ExtensionPackManifest;\n}\n\n/**\n * pgvector extension descriptor for CLI config.\n */\nconst pgvectorExtensionDescriptor: ControlExtensionDescriptor<'sql', 'postgres'> = {\n  kind: 'extension',\n  familyId: 'sql',\n  targetId: 'postgres', // pgvector is postgres-specific\n  id: 'pgvector',\n  manifest: loadExtensionManifest(),\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n};\n\nexport default pgvectorExtensionDescriptor;\n"],"mappings":";AAAA,SAAS,oBAAoB;AAC7B,SAAS,SAAS,YAAY;AAC9B,SAAS,qBAAqB;AAG9B,SAAS,YAAY;AAErB,IAAM,aAAa,cAAc,YAAY,GAAG;AAChD,IAAM,YAAY,QAAQ,UAAU;AAEpC,IAAM,wBAAwB,KAAK;AAAA,EACjC,SAAS;AAAA,EACT,OAAO;AAAA,EACP,OAAO;AACT,CAAC;AAED,IAAM,8BAA8B,KAAK;AAAA,EACvC,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,YAAY,KAAK,EAAE,YAAY,KAAK,EAAE,eAAe,SAAS,CAAC,EAAE,CAAC;AAAA,EAClE,iBAAiB;AAAA,EACjB,UAAU,KAAK;AAAA,IACb,eAAe,KAAK;AAAA,MAClB,QAAQ;AAAA,IACV,CAAC;AAAA,IACD,mBAAmB,KAAK;AAAA,MACtB,QAAQ;AAAA,IACV,CAAC;AAAA,EACH,CAAC;AAAA,EACD,eAAe;AACjB,CAAC;AAKD,SAAS,wBAA+C;AACtD,QAAM,eAAe,KAAK,WAAW,2BAA2B;AAChE,QAAM,eAAe,KAAK,MAAM,aAAa,cAAc,OAAO,CAAC;AAEnE,QAAM,SAAS,4BAA4B,YAAY;AACvD,MAAI,kBAAkB,KAAK,QAAQ;AACjC,UAAM,WAAW,OAAO,IAAI,CAAC,MAA2B,EAAE,OAAO,EAAE,KAAK,IAAI;AAC5E,UAAM,IAAI,MAAM,2CAA2C,YAAY,KAAK,QAAQ,EAAE;AAAA,EACxF;AAEA,SAAO;AACT;AAKA,IAAM,8BAA6E;AAAA,EACjF,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AAAA;AAAA,EACV,IAAI;AAAA,EACJ,UAAU,sBAAsB;AAAA,EAChC,QAAQ,OAAO;AAAA,IACb,UAAU;AAAA,IACV,UAAU;AAAA,EACZ;AACF;AAEA,IAAO,kBAAQ;","names":[]}

package/dist/exports/operation-types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Operation type definitions for pgvector extension.
+ *
+ * This file exports type-only definitions for operation method signatures.
+ * These types are imported by contract.d.ts files for compile-time type inference.
+ */
+/**
+ * Operation types for pgvector extension.
+ * Maps typeId to operation methods.
+ */
+type OperationTypes = {
+    readonly 'pg/vector@1': {
+        readonly cosineDistance: {
+            readonly args: readonly [
+                {
+                    readonly kind: 'param';
+                }
+            ];
+            readonly returns: {
+                readonly kind: 'builtin';
+                readonly type: 'number';
+            };
+            readonly lowering: {
+                readonly targetFamily: 'sql';
+                readonly strategy: 'function';
+                readonly template: string;
+            };
+        };
+    };
+};
+
+export type { OperationTypes };

package/dist/exports/operation-types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=operation-types.js.map

package/dist/exports/operation-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/exports/runtime.d.ts

@@ -0,0 +1,15 @@
+import { SqlOperationSignature } from '@prisma-next/sql-operations';
+import { CodecRegistry } from '@prisma-next/sql-relational-core/ast';
+
+interface Extension {
+    codecs?(): CodecRegistry;
+    operations?(): ReadonlyArray<SqlOperationSignature>;
+}
+
+/**
+ * Creates a pgvector extension instance for runtime registration.
+ * Provides codecs and operations for vector data type and similarity operations.
+ */
+declare function pgvector(): Extension;
+
+export { pgvector as default };

package/dist/exports/runtime.js

@@ -0,0 +1,82 @@
+// src/exports/runtime.ts
+import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+
+// src/core/codecs.ts
+import { codec, defineCodecs } from "@prisma-next/sql-relational-core/ast";
+var pgVectorCodec = codec({
+  typeId: "pg/vector@1",
+  targetTypes: ["vector"],
+  encode: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error("Vector value must be an array of numbers");
+    }
+    if (!value.every((v) => typeof v === "number")) {
+      throw new Error("Vector value must contain only numbers");
+    }
+    return `[${value.join(",")}]`;
+  },
+  decode: (wire) => {
+    if (typeof wire !== "string") {
+      throw new Error("Vector wire value must be a string");
+    }
+    if (!wire.startsWith("[") || !wire.endsWith("]")) {
+      throw new Error(`Invalid vector format: expected "[...]", got "${wire}"`);
+    }
+    const content = wire.slice(1, -1).trim();
+    if (content === "") {
+      return [];
+    }
+    const values = content.split(",").map((v) => {
+      const num = Number.parseFloat(v.trim());
+      if (Number.isNaN(num)) {
+        throw new Error(`Invalid vector value: "${v}" is not a number`);
+      }
+      return num;
+    });
+    return values;
+  },
+  meta: {
+    db: {
+      sql: {
+        postgres: {
+          nativeType: "vector"
+        }
+      }
+    }
+  }
+});
+var codecs = defineCodecs().add("vector", pgVectorCodec);
+var codecDefinitions = codecs.codecDefinitions;
+var dataTypes = codecs.dataTypes;
+
+// src/exports/runtime.ts
+function pgvector() {
+  return {
+    codecs() {
+      const registry = createCodecRegistry();
+      for (const def of Object.values(codecDefinitions)) {
+        registry.register(def.codec);
+      }
+      return registry;
+    },
+    operations() {
+      return [
+        {
+          forTypeId: "pg/vector@1",
+          method: "cosineDistance",
+          args: [{ kind: "param" }],
+          returns: { kind: "builtin", type: "number" },
+          lowering: {
+            targetFamily: "sql",
+            strategy: "function",
+            template: "1 - ({{self}} <=> {{arg0}})"
+          }
+        }
+      ];
+    }
+  };
+}
+export {
+  pgvector as default
+};
+//# sourceMappingURL=runtime.js.map

package/dist/exports/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/runtime.ts","../../src/core/codecs.ts"],"sourcesContent":["import type { SqlOperationSignature } from '@prisma-next/sql-operations';\nimport type { CodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { Extension } from '@prisma-next/sql-runtime';\nimport { codecDefinitions } from '../core/codecs';\n\n/**\n * Creates a pgvector extension instance for runtime registration.\n * Provides codecs and operations for vector data type and similarity operations.\n */\nexport default function pgvector(): Extension {\n  return {\n    codecs(): CodecRegistry {\n      const registry = createCodecRegistry();\n      // Register all codecs from codecDefinitions\n      for (const def of Object.values(codecDefinitions)) {\n        registry.register(def.codec);\n      }\n      return registry;\n    },\n    operations(): ReadonlyArray<SqlOperationSignature> {\n      return [\n        {\n          forTypeId: 'pg/vector@1',\n          method: 'cosineDistance',\n          args: [{ kind: 'param' }],\n          returns: { kind: 'builtin', type: 'number' },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '1 - ({{self}} <=> {{arg0}})',\n          },\n        },\n      ];\n    },\n  };\n}\n","/**\n * Vector codec implementation for pgvector extension.\n *\n * Provides encoding/decoding for the `vector` PostgreSQL type.\n * Wire format is a string like `[1,2,3]` (PostgreSQL vector text format).\n */\n\nimport { codec, defineCodecs } from '@prisma-next/sql-relational-core/ast';\n\nconst pgVectorCodec = codec<'pg/vector@1', string, number[]>({\n  typeId: 'pg/vector@1',\n  targetTypes: ['vector'],\n  encode: (value: number[]): string => {\n    // Validate that value is an array of numbers\n    if (!Array.isArray(value)) {\n      throw new Error('Vector value must be an array of numbers');\n    }\n    if (!value.every((v) => typeof v === 'number')) {\n      throw new Error('Vector value must contain only numbers');\n    }\n    // Format as PostgreSQL vector text format: [1,2,3]\n    // PostgreSQL's pg library requires the vector format string\n    return `[${value.join(',')}]`;\n  },\n  decode: (wire: string): number[] => {\n    // Handle string format from PostgreSQL: [1,2,3]\n    if (typeof wire !== 'string') {\n      throw new Error('Vector wire value must be a string');\n    }\n    // Parse PostgreSQL vector format: [1,2,3]\n    if (!wire.startsWith('[') || !wire.endsWith(']')) {\n      throw new Error(`Invalid vector format: expected \"[...]\", got \"${wire}\"`);\n    }\n    const content = wire.slice(1, -1).trim();\n    if (content === '') {\n      return [];\n    }\n    const values = content.split(',').map((v) => {\n      const num = Number.parseFloat(v.trim());\n      if (Number.isNaN(num)) {\n        throw new Error(`Invalid vector value: \"${v}\" is not a number`);\n      }\n      return num;\n    });\n    return values;\n  },\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'vector',\n        },\n      },\n    },\n  },\n});\n\n// Build codec definitions using the builder DSL\nconst codecs = defineCodecs().add('vector', pgVectorCodec);\n\n// Export derived structures directly from codecs builder\nexport const codecDefinitions = codecs.codecDefinitions;\nexport const dataTypes = codecs.dataTypes;\n\n// Export types derived from codecs builder\nexport type CodecTypes = typeof codecs.CodecTypes;\n"],"mappings":";AAEA,SAAS,2BAA2B;;;ACKpC,SAAS,OAAO,oBAAoB;AAEpC,IAAM,gBAAgB,MAAuC;AAAA,EAC3D,QAAQ;AAAA,EACR,aAAa,CAAC,QAAQ;AAAA,EACtB,QAAQ,CAAC,UAA4B;AAEnC,QAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,YAAM,IAAI,MAAM,0CAA0C;AAAA,IAC5D;AACA,QAAI,CAAC,MAAM,MAAM,CAAC,MAAM,OAAO,MAAM,QAAQ,GAAG;AAC9C,YAAM,IAAI,MAAM,wCAAwC;AAAA,IAC1D;AAGA,WAAO,IAAI,MAAM,KAAK,GAAG,CAAC;AAAA,EAC5B;AAAA,EACA,QAAQ,CAAC,SAA2B;AAElC,QAAI,OAAO,SAAS,UAAU;AAC5B,YAAM,IAAI,MAAM,oCAAoC;AAAA,IACtD;AAEA,QAAI,CAAC,KAAK,WAAW,GAAG,KAAK,CAAC,KAAK,SAAS,GAAG,GAAG;AAChD,YAAM,IAAI,MAAM,iDAAiD,IAAI,GAAG;AAAA,IAC1E;AACA,UAAM,UAAU,KAAK,MAAM,GAAG,EAAE,EAAE,KAAK;AACvC,QAAI,YAAY,IAAI;AAClB,aAAO,CAAC;AAAA,IACV;AACA,UAAM,SAAS,QAAQ,MAAM,GAAG,EAAE,IAAI,CAAC,MAAM;AAC3C,YAAM,MAAM,OAAO,WAAW,EAAE,KAAK,CAAC;AACtC,UAAI,OAAO,MAAM,GAAG,GAAG;AACrB,cAAM,IAAI,MAAM,0BAA0B,CAAC,mBAAmB;AAAA,MAChE;AACA,aAAO;AAAA,IACT,CAAC;AACD,WAAO;AAAA,EACT;AAAA,EACA,MAAM;AAAA,IACJ,IAAI;AAAA,MACF,KAAK;AAAA,QACH,UAAU;AAAA,UACR,YAAY;AAAA,QACd;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF,CAAC;AAGD,IAAM,SAAS,aAAa,EAAE,IAAI,UAAU,aAAa;AAGlD,IAAM,mBAAmB,OAAO;AAChC,IAAM,YAAY,OAAO;;;ADpDjB,SAAR,WAAuC;AAC5C,SAAO;AAAA,IACL,SAAwB;AACtB,YAAM,WAAW,oBAAoB;AAErC,iBAAW,OAAO,OAAO,OAAO,gBAAgB,GAAG;AACjD,iBAAS,SAAS,IAAI,KAAK;AAAA,MAC7B;AACA,aAAO;AAAA,IACT;AAAA,IACA,aAAmD;AACjD,aAAO;AAAA,QACL;AAAA,UACE,WAAW;AAAA,UACX,QAAQ;AAAA,UACR,MAAM,CAAC,EAAE,MAAM,QAAQ,CAAC;AAAA,UACxB,SAAS,EAAE,MAAM,WAAW,MAAM,SAAS;AAAA,UAC3C,UAAU;AAAA,YACR,cAAc;AAAA,YACd,UAAU;AAAA,YACV,UAAU;AAAA,UACZ;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","names":[]}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@prisma-next/extension-pgvector",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "dependencies": {
+    "arktype": "^2.0.0",
+    "@prisma-next/cli": "0.0.1",
+    "@prisma-next/sql-operations": "0.0.1",
+    "@prisma-next/sql-relational-core": "0.0.1"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.9.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^2.1.1",
+    "@prisma-next/test-utils": "0.0.1"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./control": {
+      "types": "./dist/exports/control.d.ts",
+      "import": "./dist/exports/control.js"
+    },
+    "./runtime": {
+      "types": "./dist/exports/runtime.d.ts",
+      "import": "./dist/exports/runtime.js"
+    },
+    "./codec-types": {
+      "types": "./dist/exports/codec-types.d.ts",
+      "import": "./dist/exports/codec-types.js"
+    },
+    "./operation-types": {
+      "types": "./dist/exports/operation-types.d.ts",
+      "import": "./dist/exports/operation-types.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "lint": "biome check . --config-path ../../../biome.json --error-on-warnings",
+    "clean": "node ../../../scripts/clean.mjs"
+  }
+}