@prisma-next/extension-pgvector 0.3.0-dev.32 → 0.3.0-dev.33

package/README.md

@@ -8,7 +8,7 @@ This extension pack adds support for the `vector` data type and vector similarit
 
 ## Responsibilities
 
-- **Vector Codec**: Provides codec for `pg/vector@1` type ID mapping to `number[]` JavaScript type
+- **Vector Codec**: Provides codec for `pg/vector@1` mapping to `number[]` at runtime, and a `Vector<N>` type for dimensioned typing in `contract.d.ts`
 - **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
@@ -135,12 +135,16 @@ type Row = ResultType<typeof plan>;
 
 ### Codec Types
 
-The extension provides a `CodecTypes` export mapping the `pg/vector@1` type ID to `number[]`:
+The extension provides:
+
+- `CodecTypes` mapping the `pg/vector@1` type ID to `number[]` (runtime representation)
+- `Vector<N>` type for dimensioned vector typing in emitted `contract.d.ts` and schema result types when the contract includes dimension metadata
 
 ```typescript
-import type { CodecTypes } from '@prisma-next/extension-pgvector/codec-types';
+import type { CodecTypes, Vector } from '@prisma-next/extension-pgvector/codec-types';
 
 // CodecTypes['pg/vector@1']['output'] = number[]
+// Vector<1536> is a branded number[] type used for dimensioned typing
 ```
 
 ### Operation Types

package/dist/{chunk-OI5XEHIN.js → chunk-DSJTFXJR.js}

@@ -29,10 +29,16 @@ var pgvectorPackMeta = {
         named: "CodecTypes",
         alias: "PgVectorTypes"
       },
+      typeImports: [
+        {
+          package: "@prisma-next/extension-pgvector/codec-types",
+          named: "Vector",
+          alias: "Vector"
+        }
+      ],
       // Parameterized codec renderers for type emission.
       // The renderer template produces precise TypeScript types like Vector<1536>
       // when columns have typeParams with a `length` property.
-      // Note: The Vector<N> type import is deferred to Phase 6.
       parameterized: {
         [pgvectorTypeId]: "Vector<{{length}}>"
       }
@@ -64,4 +70,4 @@ export {
   pgvectorPackMeta,
   pgvectorRuntimeOperation
 };
-//# sourceMappingURL=chunk-OI5XEHIN.js.map
+//# sourceMappingURL=chunk-DSJTFXJR.js.map

package/dist/chunk-DSJTFXJR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { ExtensionPackRef } from '@prisma-next/contract/framework-components';\nimport type { SqlOperationSignature } from '@prisma-next/sql-operations';\n\nconst pgvectorTypeId = 'pg/vector@1' as const;\n\nconst cosineLowering = {\n  targetFamily: 'sql',\n  strategy: 'function',\n  template: '1 - ({{self}} <=> {{arg0}})',\n} as const;\n\n/**\n * Shared operation definition used by both pack metadata and runtime descriptor.\n * Frozen to prevent accidental mutation.\n */\nconst cosineDistanceOperation = Object.freeze({\n  method: 'cosineDistance',\n  args: [{ kind: 'param' }],\n  returns: { kind: 'builtin', type: 'number' },\n  lowering: cosineLowering,\n} as const);\n\nexport const pgvectorPackMeta = {\n  kind: 'extension',\n  id: 'pgvector',\n  familyId: 'sql',\n  targetId: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      'pgvector/cosine': true,\n    },\n  },\n  types: {\n    codecTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/codec-types',\n        named: 'CodecTypes',\n        alias: 'PgVectorTypes',\n      },\n      typeImports: [\n        {\n          package: '@prisma-next/extension-pgvector/codec-types',\n          named: 'Vector',\n          alias: 'Vector',\n        },\n      ],\n      // Parameterized codec renderers for type emission.\n      // The renderer template produces precise TypeScript types like Vector<1536>\n      // when columns have typeParams with a `length` property.\n      parameterized: {\n        [pgvectorTypeId]: 'Vector<{{length}}>',\n      },\n    },\n    operationTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/operation-types',\n        named: 'OperationTypes',\n        alias: 'PgVectorOperationTypes',\n      },\n    },\n    storage: [\n      { typeId: pgvectorTypeId, familyId: 'sql', targetId: 'postgres', nativeType: 'vector' },\n    ],\n  },\n  operations: [\n    {\n      for: pgvectorTypeId,\n      ...cosineDistanceOperation,\n    },\n  ],\n} as const satisfies ExtensionPackRef<'sql', 'postgres'>;\n\nexport const pgvectorRuntimeOperation: SqlOperationSignature = {\n  forTypeId: pgvectorTypeId,\n  ...cosineDistanceOperation,\n};\n"],"mappings":";AAGA,IAAM,iBAAiB;AAEvB,IAAM,iBAAiB;AAAA,EACrB,cAAc;AAAA,EACd,UAAU;AAAA,EACV,UAAU;AACZ;AAMA,IAAM,0BAA0B,OAAO,OAAO;AAAA,EAC5C,QAAQ;AAAA,EACR,MAAM,CAAC,EAAE,MAAM,QAAQ,CAAC;AAAA,EACxB,SAAS,EAAE,MAAM,WAAW,MAAM,SAAS;AAAA,EAC3C,UAAU;AACZ,CAAU;AAEH,IAAM,mBAAmB;AAAA,EAC9B,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAS;AAAA,EACT,cAAc;AAAA,IACZ,UAAU;AAAA,MACR,mBAAmB;AAAA,IACrB;AAAA,EACF;AAAA,EACA,OAAO;AAAA,IACL,YAAY;AAAA,MACV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,QACP,OAAO;AAAA,MACT;AAAA,MACA,aAAa;AAAA,QACX;AAAA,UACE,SAAS;AAAA,UACT,OAAO;AAAA,UACP,OAAO;AAAA,QACT;AAAA,MACF;AAAA;AAAA;AAAA;AAAA,MAIA,eAAe;AAAA,QACb,CAAC,cAAc,GAAG;AAAA,MACpB;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA,MACd,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,QACP,OAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,EAAE,QAAQ,gBAAgB,UAAU,OAAO,UAAU,YAAY,YAAY,SAAS;AAAA,IACxF;AAAA,EACF;AAAA,EACA,YAAY;AAAA,IACV;AAAA,MACE,KAAK;AAAA,MACL,GAAG;AAAA,IACL;AAAA,EACF;AACF;AAEO,IAAM,2BAAkD;AAAA,EAC7D,WAAW;AAAA,EACX,GAAG;AACL;","names":[]}

package/dist/chunk-MUHUVAQX.js

@@ -0,0 +1,9 @@
+// src/core/constants.ts
+var VECTOR_CODEC_ID = "pg/vector@1";
+var VECTOR_MAX_DIM = 16e3;
+
+export {
+  VECTOR_CODEC_ID,
+  VECTOR_MAX_DIM
+};
+//# sourceMappingURL=chunk-MUHUVAQX.js.map

package/dist/chunk-MUHUVAQX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/constants.ts"],"sourcesContent":["/**\n * Codec ID for pgvector's vector type.\n */\nexport const VECTOR_CODEC_ID = 'pg/vector@1' as const;\n\n/**\n * Maximum dimension for pgvector vectors (VECTOR_MAX_DIM from pgvector).\n */\nexport const VECTOR_MAX_DIM = 16000;\n"],"mappings":";AAGO,IAAM,kBAAkB;AAKxB,IAAM,iBAAiB;","names":[]}

package/dist/core/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Codec ID for pgvector's vector type.
+ */
+export declare const VECTOR_CODEC_ID: "pg/vector@1";
+/**
+ * Maximum dimension for pgvector vectors (VECTOR_MAX_DIM from pgvector).
+ */
+export declare const VECTOR_MAX_DIM = 16000;
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/core/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,eAAe,EAAG,aAAsB,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,cAAc,QAAQ,CAAC"}

package/dist/core/descriptor-meta.d.ts

@@ -17,6 +17,11 @@ export declare const pgvectorPackMeta: {
                 readonly named: "CodecTypes";
                 readonly alias: "PgVectorTypes";
             };
+            readonly typeImports: readonly [{
+                readonly package: "@prisma-next/extension-pgvector/codec-types";
+                readonly named: "Vector";
+                readonly alias: "Vector";
+            }];
             readonly parameterized: {
                 readonly "pg/vector@1": "Vector<{{length}}>";
             };

package/dist/core/descriptor-meta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"descriptor-meta.d.ts","sourceRoot":"","sources":["../../src/core/descriptor-meta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAqBzE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2C2B,CAAC;AAEzD,eAAO,MAAM,wBAAwB,EAAE,qBAGtC,CAAC"}
+{"version":3,"file":"descriptor-meta.d.ts","sourceRoot":"","sources":["../../src/core/descriptor-meta.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAqBzE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD2B,CAAC;AAEzD,eAAO,MAAM,wBAAwB,EAAE,qBAGtC,CAAC"}

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

@@ -3,5 +3,5 @@
  *
  * Re-export from types module for public API.
  */
-export type { CodecTypes } from '../types/codec-types';
+export type { CodecTypes, Vector } from '../types/codec-types';
 //# sourceMappingURL=codec-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"codec-types.d.ts","sourceRoot":"","sources":["../../src/exports/codec-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"codec-types.d.ts","sourceRoot":"","sources":["../../src/exports/codec-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC"}

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

@@ -4,8 +4,31 @@
  * These descriptors provide both codecId and nativeType for use in contract authoring.
  * They are derived from the same source of truth as codec definitions and manifests.
  */
+import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+/**
+ * Static vector column descriptor without dimension.
+ * Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
+ */
 export declare const vectorColumn: {
     readonly codecId: "pg/vector@1";
     readonly nativeType: "vector";
 };
+/**
+ * Factory for creating dimensioned vector column descriptors.
+ *
+ * @example
+ * ```typescript
+ * .column('embedding', { type: vector(1536), nullable: false })
+ * // Produces: nativeType: 'vector(1536)', typeParams: { length: 1536 }
+ * ```
+ *
+ * @param length - The dimension of the vector (e.g., 1536 for OpenAI embeddings)
+ * @returns A column type descriptor with `typeParams.length` set
+ * @throws {RangeError} If length is not an integer in the range [1, VECTOR_MAX_DIM]
+ */
+export declare function vector<N extends number>(length: N): ColumnTypeDescriptor & {
+    readonly typeParams: {
+        readonly length: N;
+    };
+};
 //# sourceMappingURL=column-types.d.ts.map

package/dist/exports/column-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"column-types.d.ts","sourceRoot":"","sources":["../../src/exports/column-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,eAAO,MAAM,YAAY;;;CAGgB,CAAC"}
+{"version":3,"file":"column-types.d.ts","sourceRoot":"","sources":["../../src/exports/column-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAG5E;;;GAGG;AACH,eAAO,MAAM,YAAY;;;CAGgB,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EACrC,MAAM,EAAE,CAAC,GACR,oBAAoB,GAAG;IAAE,QAAQ,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;KAAE,CAAA;CAAE,CAWxE"}

package/dist/exports/column-types.js

@@ -1,9 +1,27 @@
+import {
+  VECTOR_CODEC_ID,
+  VECTOR_MAX_DIM
+} from "../chunk-MUHUVAQX.js";
+
 // src/exports/column-types.ts
 var vectorColumn = {
-  codecId: "pg/vector@1",
+  codecId: VECTOR_CODEC_ID,
   nativeType: "vector"
 };
+function vector(length) {
+  if (!Number.isInteger(length) || length < 1 || length > VECTOR_MAX_DIM) {
+    throw new RangeError(
+      `pgvector: dimension must be an integer in [1, ${VECTOR_MAX_DIM}], got ${length}`
+    );
+  }
+  return {
+    codecId: VECTOR_CODEC_ID,
+    nativeType: `vector(${length})`,
+    typeParams: { length }
+  };
+}
 export {
+  vector,
   vectorColumn
 };
 //# sourceMappingURL=column-types.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../src/exports/column-types.ts"],"sourcesContent":["/**\n * Column type descriptors for pgvector extension.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\n\nexport const vectorColumn = {\n  codecId: 'pg/vector@1',\n  nativeType: 'vector',\n} as const satisfies ColumnTypeDescriptor;\n"],"mappings":";AASO,IAAM,eAAe;AAAA,EAC1B,SAAS;AAAA,EACT,YAAY;AACd;","names":[]}
+{"version":3,"sources":["../../src/exports/column-types.ts"],"sourcesContent":["/**\n * Column type descriptors for pgvector extension.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';\n\n/**\n * Static vector column descriptor without dimension.\n * Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.\n */\nexport const vectorColumn = {\n  codecId: VECTOR_CODEC_ID,\n  nativeType: 'vector',\n} as const satisfies ColumnTypeDescriptor;\n\n/**\n * Factory for creating dimensioned vector column descriptors.\n *\n * @example\n * ```typescript\n * .column('embedding', { type: vector(1536), nullable: false })\n * // Produces: nativeType: 'vector(1536)', typeParams: { length: 1536 }\n * ```\n *\n * @param length - The dimension of the vector (e.g., 1536 for OpenAI embeddings)\n * @returns A column type descriptor with `typeParams.length` set\n * @throws {RangeError} If length is not an integer in the range [1, VECTOR_MAX_DIM]\n */\nexport function vector<N extends number>(\n  length: N,\n): ColumnTypeDescriptor & { readonly typeParams: { readonly length: N } } {\n  if (!Number.isInteger(length) || length < 1 || length > VECTOR_MAX_DIM) {\n    throw new RangeError(\n      `pgvector: dimension must be an integer in [1, ${VECTOR_MAX_DIM}], got ${length}`,\n    );\n  }\n  return {\n    codecId: VECTOR_CODEC_ID,\n    nativeType: `vector(${length})`,\n    typeParams: { length },\n  } as const;\n}\n"],"mappings":";;;;;;AAcO,IAAM,eAAe;AAAA,EAC1B,SAAS;AAAA,EACT,YAAY;AACd;AAeO,SAAS,OACd,QACwE;AACxE,MAAI,CAAC,OAAO,UAAU,MAAM,KAAK,SAAS,KAAK,SAAS,gBAAgB;AACtE,UAAM,IAAI;AAAA,MACR,iDAAiD,cAAc,UAAU,MAAM;AAAA,IACjF;AAAA,EACF;AACA,SAAO;AAAA,IACL,SAAS;AAAA,IACT,YAAY,UAAU,MAAM;AAAA,IAC5B,YAAY,EAAE,OAAO;AAAA,EACvB;AACF;","names":[]}

package/dist/exports/control.js

@@ -1,6 +1,6 @@
 import {
   pgvectorPackMeta
-} from "../chunk-OI5XEHIN.js";
+} from "../chunk-DSJTFXJR.js";
 
 // src/exports/control.ts
 function verifyVectorExtensionInstalled(schema) {

package/dist/exports/pack.d.ts

@@ -16,6 +16,11 @@ declare const pgvectorPack: {
                 readonly named: "CodecTypes";
                 readonly alias: "PgVectorTypes";
             };
+            readonly typeImports: readonly [{
+                readonly package: "@prisma-next/extension-pgvector/codec-types";
+                readonly named: "Vector";
+                readonly alias: "Vector";
+            }];
             readonly parameterized: {
                 readonly "pg/vector@1": "Vector<{{length}}>";
             };

package/dist/exports/pack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../../src/exports/pack.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmB,CAAC;AAEtC,eAAe,YAAY,CAAC"}
+{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../../src/exports/pack.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAmB,CAAC;AAEtC,eAAe,YAAY,CAAC"}

package/dist/exports/pack.js

@@ -1,6 +1,6 @@
 import {
   pgvectorPackMeta
-} from "../chunk-OI5XEHIN.js";
+} from "../chunk-DSJTFXJR.js";
 
 // src/exports/pack.ts
 var pgvectorPack = pgvectorPackMeta;

package/dist/exports/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/exports/runtime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,6BAA6B,EAE9B,MAAM,0BAA0B,CAAC;AA0BlC;;;GAGG;AACH,QAAA,MAAM,yBAAyB,EAAE,6BAA6B,CAAC,UAAU,CASxE,CAAC;AAEF,eAAe,yBAAyB,CAAC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/exports/runtime.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,6BAA6B,EAE9B,MAAM,0BAA0B,CAAC;AA2DlC;;;GAGG;AACH,QAAA,MAAM,yBAAyB,EAAE,6BAA6B,CAAC,UAAU,CASxE,CAAC;AAEF,eAAe,yBAAyB,CAAC"}

package/dist/exports/runtime.js

@@ -1,10 +1,15 @@
+import {
+  VECTOR_CODEC_ID,
+  VECTOR_MAX_DIM
+} from "../chunk-MUHUVAQX.js";
 import {
   pgvectorPackMeta,
   pgvectorRuntimeOperation
-} from "../chunk-OI5XEHIN.js";
+} from "../chunk-DSJTFXJR.js";
 
 // src/exports/runtime.ts
 import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { type as arktype } from "arktype";
 
 // src/core/codecs.ts
 import { codec, defineCodecs } from "@prisma-next/sql-relational-core/ast";
@@ -55,6 +60,24 @@ var codecDefinitions = codecs.codecDefinitions;
 var dataTypes = codecs.dataTypes;
 
 // src/exports/runtime.ts
+var vectorParamsSchema = arktype({
+  length: "number"
+}).narrow((params, ctx) => {
+  const { length } = params;
+  if (!Number.isInteger(length)) {
+    return ctx.mustBe("an integer");
+  }
+  if (length < 1 || length > VECTOR_MAX_DIM) {
+    return ctx.mustBe(`in the range [1, ${VECTOR_MAX_DIM}]`);
+  }
+  return true;
+});
+var parameterizedCodecDescriptors = [
+  {
+    codecId: VECTOR_CODEC_ID,
+    paramsSchema: vectorParamsSchema
+  }
+];
 var PgVectorRuntimeExtensionInstance = class {
   familyId = "sql";
   targetId = "postgres";
@@ -68,6 +91,9 @@ var PgVectorRuntimeExtensionInstance = class {
   operations() {
     return [pgvectorRuntimeOperation];
   }
+  parameterizedCodecs() {
+    return parameterizedCodecDescriptors;
+  }
 };
 var pgvectorRuntimeDescriptor = {
   kind: "extension",

package/dist/exports/runtime.js.map

@@ -1 +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 {\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeExtensionInstance,\n} from '@prisma-next/sql-runtime';\nimport { codecDefinitions } from '../core/codecs';\nimport { pgvectorPackMeta, pgvectorRuntimeOperation } from '../core/descriptor-meta';\n\n/**\n * pgvector SQL runtime extension instance.\n * Provides codecs and operations for vector data type and similarity operations.\n */\nclass PgVectorRuntimeExtensionInstance implements SqlRuntimeExtensionInstance<'postgres'> {\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\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\n  operations(): ReadonlyArray<SqlOperationSignature> {\n    return [pgvectorRuntimeOperation];\n  }\n}\n\n/**\n * pgvector SQL runtime extension descriptor.\n * Provides metadata and factory for creating runtime extension instances.\n */\nconst pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {\n  kind: 'extension' as const,\n  id: pgvectorPackMeta.id,\n  version: pgvectorPackMeta.version,\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  create(): SqlRuntimeExtensionInstance<'postgres'> {\n    return new PgVectorRuntimeExtensionInstance();\n  },\n};\n\nexport default pgvectorRuntimeDescriptor;\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;;;ADhDhC,IAAM,mCAAN,MAA0F;AAAA,EAC/E,WAAW;AAAA,EACX,WAAW;AAAA,EAEpB,SAAwB;AACtB,UAAM,WAAW,oBAAoB;AAErC,eAAW,OAAO,OAAO,OAAO,gBAAgB,GAAG;AACjD,eAAS,SAAS,IAAI,KAAK;AAAA,IAC7B;AACA,WAAO;AAAA,EACT;AAAA,EAEA,aAAmD;AACjD,WAAO,CAAC,wBAAwB;AAAA,EAClC;AACF;AAMA,IAAM,4BAAuE;AAAA,EAC3E,MAAM;AAAA,EACN,IAAI,iBAAiB;AAAA,EACrB,SAAS,iBAAiB;AAAA,EAC1B,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAkD;AAChD,WAAO,IAAI,iCAAiC;AAAA,EAC9C;AACF;AAEA,IAAO,kBAAQ;","names":[]}
+{"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 {\n  RuntimeParameterizedCodecDescriptor,\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeExtensionInstance,\n} from '@prisma-next/sql-runtime';\nimport { type as arktype } from 'arktype';\nimport { codecDefinitions } from '../core/codecs';\nimport { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';\nimport { pgvectorPackMeta, pgvectorRuntimeOperation } from '../core/descriptor-meta';\n\nconst vectorParamsSchema = arktype({\n  length: 'number',\n}).narrow((params, ctx) => {\n  const { length } = params;\n  if (!Number.isInteger(length)) {\n    return ctx.mustBe('an integer');\n  }\n  if (length < 1 || length > VECTOR_MAX_DIM) {\n    return ctx.mustBe(`in the range [1, ${VECTOR_MAX_DIM}]`);\n  }\n  return true;\n});\n\n/**\n * Pre-allocated parameterized codec descriptors to avoid per-call allocations.\n */\nconst parameterizedCodecDescriptors = [\n  {\n    codecId: VECTOR_CODEC_ID,\n    paramsSchema: vectorParamsSchema,\n  },\n] as const satisfies ReadonlyArray<\n  RuntimeParameterizedCodecDescriptor<{ readonly length: number }>\n>;\n\n/**\n * pgvector SQL runtime extension instance.\n * Provides codecs and operations for vector data type and similarity operations.\n */\nclass PgVectorRuntimeExtensionInstance implements SqlRuntimeExtensionInstance<'postgres'> {\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\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\n  operations(): ReadonlyArray<SqlOperationSignature> {\n    return [pgvectorRuntimeOperation];\n  }\n\n  parameterizedCodecs(): ReadonlyArray<\n    RuntimeParameterizedCodecDescriptor<{ readonly length: number }>\n  > {\n    return parameterizedCodecDescriptors;\n  }\n}\n\n/**\n * pgvector SQL runtime extension descriptor.\n * Provides metadata and factory for creating runtime extension instances.\n */\nconst pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {\n  kind: 'extension' as const,\n  id: pgvectorPackMeta.id,\n  version: pgvectorPackMeta.version,\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  create(): SqlRuntimeExtensionInstance<'postgres'> {\n    return new PgVectorRuntimeExtensionInstance();\n  },\n};\n\nexport default pgvectorRuntimeDescriptor;\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;AAMpC,SAAS,QAAQ,eAAe;;;ACDhC,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;;;ADjDhC,IAAM,qBAAqB,QAAQ;AAAA,EACjC,QAAQ;AACV,CAAC,EAAE,OAAO,CAAC,QAAQ,QAAQ;AACzB,QAAM,EAAE,OAAO,IAAI;AACnB,MAAI,CAAC,OAAO,UAAU,MAAM,GAAG;AAC7B,WAAO,IAAI,OAAO,YAAY;AAAA,EAChC;AACA,MAAI,SAAS,KAAK,SAAS,gBAAgB;AACzC,WAAO,IAAI,OAAO,oBAAoB,cAAc,GAAG;AAAA,EACzD;AACA,SAAO;AACT,CAAC;AAKD,IAAM,gCAAgC;AAAA,EACpC;AAAA,IACE,SAAS;AAAA,IACT,cAAc;AAAA,EAChB;AACF;AAQA,IAAM,mCAAN,MAA0F;AAAA,EAC/E,WAAW;AAAA,EACX,WAAW;AAAA,EAEpB,SAAwB;AACtB,UAAM,WAAW,oBAAoB;AAErC,eAAW,OAAO,OAAO,OAAO,gBAAgB,GAAG;AACjD,eAAS,SAAS,IAAI,KAAK;AAAA,IAC7B;AACA,WAAO;AAAA,EACT;AAAA,EAEA,aAAmD;AACjD,WAAO,CAAC,wBAAwB;AAAA,EAClC;AAAA,EAEA,sBAEE;AACA,WAAO;AAAA,EACT;AACF;AAMA,IAAM,4BAAuE;AAAA,EAC3E,MAAM;AAAA,EACN,IAAI,iBAAiB;AAAA,EACrB,SAAS,iBAAiB;AAAA,EAC1B,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAkD;AAChD,WAAO,IAAI,iCAAiC;AAAA,EAC9C;AACF;AAEA,IAAO,kBAAQ;","names":[]}

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

@@ -6,5 +6,29 @@
  *
  * Runtime codec implementations are provided by the extension's codec registry.
  */
-export type { CodecTypes } from '../core/codecs';
+import type { CodecTypes as CoreCodecTypes } from '../core/codecs';
+/**
+ * Type-level branded vector.
+ *
+ * The runtime values are plain number arrays, but parameterized column typing can
+ * carry the dimension at the type level (e.g. Vector<1536>).
+ */
+export type Vector<N extends number = number> = number[] & {
+    readonly __vectorLength?: N;
+};
+/**
+ * Codec types for pgvector.
+ *
+ * - Scalar output remains `number[]` (runtime representation).
+ * - `parameterizedOutput` enables lane typing to compute `Vector<N>` from column `typeParams`.
+ */
+export type CodecTypes = CoreCodecTypes & {
+    readonly 'pg/vector@1': CoreCodecTypes['pg/vector@1'] & {
+        readonly parameterizedOutput: <P extends {
+            readonly length: number;
+        }>(params: P) => P extends {
+            readonly length: infer N extends number;
+        } ? Vector<N> : Vector<number>;
+    };
+};
 //# sourceMappingURL=codec-types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"codec-types.d.ts","sourceRoot":"","sources":["../../src/types/codec-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,YAAY,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"codec-types.d.ts","sourceRoot":"","sources":["../../src/types/codec-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM,EAAE,GAAG;IAAE,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC;AAE3F;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,cAAc,GAAG;IACxC,QAAQ,CAAC,aAAa,EAAE,cAAc,CAAC,aAAa,CAAC,GAAG;QACtD,QAAQ,CAAC,mBAAmB,EAAE,CAAC,CAAC,SAAS;YAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;SAAE,EAClE,MAAM,EAAE,CAAC,KACN,CAAC,SAAS;YAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,SAAS,MAAM,CAAA;SAAE,GAAG,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;KACzF,CAAC;CACH,CAAC"}

package/package.json

@@ -1,29 +1,29 @@
 {
   "name": "@prisma-next/extension-pgvector",
-  "version": "0.3.0-dev.32",
+  "version": "0.3.0-dev.33",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/cli": "0.3.0-dev.32",
-    "@prisma-next/contract": "0.3.0-dev.32",
-    "@prisma-next/contract-authoring": "0.3.0-dev.32",
-    "@prisma-next/core-control-plane": "0.3.0-dev.32",
-    "@prisma-next/family-sql": "0.3.0-dev.32",
-    "@prisma-next/sql-relational-core": "0.3.0-dev.32",
-    "@prisma-next/sql-operations": "0.3.0-dev.32",
-    "@prisma-next/sql-runtime": "0.3.0-dev.32",
-    "@prisma-next/sql-schema-ir": "0.3.0-dev.32"
+    "@prisma-next/cli": "0.3.0-dev.33",
+    "@prisma-next/contract": "0.3.0-dev.33",
+    "@prisma-next/contract-authoring": "0.3.0-dev.33",
+    "@prisma-next/core-control-plane": "0.3.0-dev.33",
+    "@prisma-next/sql-operations": "0.3.0-dev.33",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.33",
+    "@prisma-next/sql-runtime": "0.3.0-dev.33",
+    "@prisma-next/sql-schema-ir": "0.3.0-dev.33",
+    "@prisma-next/family-sql": "0.3.0-dev.33"
   },
   "devDependencies": {
     "tsup": "8.5.1",
     "typescript": "5.9.3",
     "vitest": "4.0.16",
-    "@prisma-next/adapter-postgres": "0.3.0-dev.32",
-    "@prisma-next/operations": "0.3.0-dev.32",
-    "@prisma-next/sql-contract": "0.3.0-dev.32",
-    "@prisma-next/sql-contract-ts": "0.3.0-dev.32",
-    "@prisma-next/sql-lane": "0.3.0-dev.32",
+    "@prisma-next/adapter-postgres": "0.3.0-dev.33",
+    "@prisma-next/operations": "0.3.0-dev.33",
+    "@prisma-next/sql-contract": "0.3.0-dev.33",
+    "@prisma-next/sql-contract-ts": "0.3.0-dev.33",
+    "@prisma-next/sql-lane": "0.3.0-dev.33",
     "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0"
   },

package/src/core/constants.ts

@@ -0,0 +1,9 @@
+/**
+ * Codec ID for pgvector's vector type.
+ */
+export const VECTOR_CODEC_ID = 'pg/vector@1' as const;
+
+/**
+ * Maximum dimension for pgvector vectors (VECTOR_MAX_DIM from pgvector).
+ */
+export const VECTOR_MAX_DIM = 16000;

package/src/core/descriptor-meta.ts

@@ -38,10 +38,16 @@ export const pgvectorPackMeta = {
         named: 'CodecTypes',
         alias: 'PgVectorTypes',
       },
+      typeImports: [
+        {
+          package: '@prisma-next/extension-pgvector/codec-types',
+          named: 'Vector',
+          alias: 'Vector',
+        },
+      ],
       // Parameterized codec renderers for type emission.
       // The renderer template produces precise TypeScript types like Vector<1536>
       // when columns have typeParams with a `length` property.
-      // Note: The Vector<N> type import is deferred to Phase 6.
       parameterized: {
         [pgvectorTypeId]: 'Vector<{{length}}>',
       },

package/src/exports/codec-types.ts

@@ -4,4 +4,4 @@
  * Re-export from types module for public API.
  */
 
-export type { CodecTypes } from '../types/codec-types';
+export type { CodecTypes, Vector } from '../types/codec-types';

package/src/exports/column-types.ts

@@ -6,8 +6,41 @@
  */
 
 import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+import { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';
 
+/**
+ * Static vector column descriptor without dimension.
+ * Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
+ */
 export const vectorColumn = {
-  codecId: 'pg/vector@1',
+  codecId: VECTOR_CODEC_ID,
   nativeType: 'vector',
 } as const satisfies ColumnTypeDescriptor;
+
+/**
+ * Factory for creating dimensioned vector column descriptors.
+ *
+ * @example
+ * ```typescript
+ * .column('embedding', { type: vector(1536), nullable: false })
+ * // Produces: nativeType: 'vector(1536)', typeParams: { length: 1536 }
+ * ```
+ *
+ * @param length - The dimension of the vector (e.g., 1536 for OpenAI embeddings)
+ * @returns A column type descriptor with `typeParams.length` set
+ * @throws {RangeError} If length is not an integer in the range [1, VECTOR_MAX_DIM]
+ */
+export function vector<N extends number>(
+  length: N,
+): ColumnTypeDescriptor & { readonly typeParams: { readonly length: N } } {
+  if (!Number.isInteger(length) || length < 1 || length > VECTOR_MAX_DIM) {
+    throw new RangeError(
+      `pgvector: dimension must be an integer in [1, ${VECTOR_MAX_DIM}], got ${length}`,
+    );
+  }
+  return {
+    codecId: VECTOR_CODEC_ID,
+    nativeType: `vector(${length})`,
+    typeParams: { length },
+  } as const;
+}

package/src/exports/runtime.ts

@@ -2,12 +2,40 @@ import type { SqlOperationSignature } from '@prisma-next/sql-operations';
 import type { CodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import type {
+  RuntimeParameterizedCodecDescriptor,
   SqlRuntimeExtensionDescriptor,
   SqlRuntimeExtensionInstance,
 } from '@prisma-next/sql-runtime';
+import { type as arktype } from 'arktype';
 import { codecDefinitions } from '../core/codecs';
+import { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';
 import { pgvectorPackMeta, pgvectorRuntimeOperation } from '../core/descriptor-meta';
 
+const vectorParamsSchema = arktype({
+  length: 'number',
+}).narrow((params, ctx) => {
+  const { length } = params;
+  if (!Number.isInteger(length)) {
+    return ctx.mustBe('an integer');
+  }
+  if (length < 1 || length > VECTOR_MAX_DIM) {
+    return ctx.mustBe(`in the range [1, ${VECTOR_MAX_DIM}]`);
+  }
+  return true;
+});
+
+/**
+ * Pre-allocated parameterized codec descriptors to avoid per-call allocations.
+ */
+const parameterizedCodecDescriptors = [
+  {
+    codecId: VECTOR_CODEC_ID,
+    paramsSchema: vectorParamsSchema,
+  },
+] as const satisfies ReadonlyArray<
+  RuntimeParameterizedCodecDescriptor<{ readonly length: number }>
+>;
+
 /**
  * pgvector SQL runtime extension instance.
  * Provides codecs and operations for vector data type and similarity operations.
@@ -28,6 +56,12 @@ class PgVectorRuntimeExtensionInstance implements SqlRuntimeExtensionInstance<'p
   operations(): ReadonlyArray<SqlOperationSignature> {
     return [pgvectorRuntimeOperation];
   }
+
+  parameterizedCodecs(): ReadonlyArray<
+    RuntimeParameterizedCodecDescriptor<{ readonly length: number }>
+  > {
+    return parameterizedCodecDescriptors;
+  }
 }
 
 /**

package/src/types/codec-types.ts

@@ -7,4 +7,26 @@
  * Runtime codec implementations are provided by the extension's codec registry.
  */
 
-export type { CodecTypes } from '../core/codecs';
+import type { CodecTypes as CoreCodecTypes } from '../core/codecs';
+
+/**
+ * Type-level branded vector.
+ *
+ * The runtime values are plain number arrays, but parameterized column typing can
+ * carry the dimension at the type level (e.g. Vector<1536>).
+ */
+export type Vector<N extends number = number> = number[] & { readonly __vectorLength?: N };
+
+/**
+ * Codec types for pgvector.
+ *
+ * - Scalar output remains `number[]` (runtime representation).
+ * - `parameterizedOutput` enables lane typing to compute `Vector<N>` from column `typeParams`.
+ */
+export type CodecTypes = CoreCodecTypes & {
+  readonly 'pg/vector@1': CoreCodecTypes['pg/vector@1'] & {
+    readonly parameterizedOutput: <P extends { readonly length: number }>(
+      params: P,
+    ) => P extends { readonly length: infer N extends number } ? Vector<N> : Vector<number>;
+  };
+};

package/dist/chunk-OI5XEHIN.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { ExtensionPackRef } from '@prisma-next/contract/framework-components';\nimport type { SqlOperationSignature } from '@prisma-next/sql-operations';\n\nconst pgvectorTypeId = 'pg/vector@1' as const;\n\nconst cosineLowering = {\n  targetFamily: 'sql',\n  strategy: 'function',\n  template: '1 - ({{self}} <=> {{arg0}})',\n} as const;\n\n/**\n * Shared operation definition used by both pack metadata and runtime descriptor.\n * Frozen to prevent accidental mutation.\n */\nconst cosineDistanceOperation = Object.freeze({\n  method: 'cosineDistance',\n  args: [{ kind: 'param' }],\n  returns: { kind: 'builtin', type: 'number' },\n  lowering: cosineLowering,\n} as const);\n\nexport const pgvectorPackMeta = {\n  kind: 'extension',\n  id: 'pgvector',\n  familyId: 'sql',\n  targetId: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      'pgvector/cosine': true,\n    },\n  },\n  types: {\n    codecTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/codec-types',\n        named: 'CodecTypes',\n        alias: 'PgVectorTypes',\n      },\n      // Parameterized codec renderers for type emission.\n      // The renderer template produces precise TypeScript types like Vector<1536>\n      // when columns have typeParams with a `length` property.\n      // Note: The Vector<N> type import is deferred to Phase 6.\n      parameterized: {\n        [pgvectorTypeId]: 'Vector<{{length}}>',\n      },\n    },\n    operationTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/operation-types',\n        named: 'OperationTypes',\n        alias: 'PgVectorOperationTypes',\n      },\n    },\n    storage: [\n      { typeId: pgvectorTypeId, familyId: 'sql', targetId: 'postgres', nativeType: 'vector' },\n    ],\n  },\n  operations: [\n    {\n      for: pgvectorTypeId,\n      ...cosineDistanceOperation,\n    },\n  ],\n} as const satisfies ExtensionPackRef<'sql', 'postgres'>;\n\nexport const pgvectorRuntimeOperation: SqlOperationSignature = {\n  forTypeId: pgvectorTypeId,\n  ...cosineDistanceOperation,\n};\n"],"mappings":";AAGA,IAAM,iBAAiB;AAEvB,IAAM,iBAAiB;AAAA,EACrB,cAAc;AAAA,EACd,UAAU;AAAA,EACV,UAAU;AACZ;AAMA,IAAM,0BAA0B,OAAO,OAAO;AAAA,EAC5C,QAAQ;AAAA,EACR,MAAM,CAAC,EAAE,MAAM,QAAQ,CAAC;AAAA,EACxB,SAAS,EAAE,MAAM,WAAW,MAAM,SAAS;AAAA,EAC3C,UAAU;AACZ,CAAU;AAEH,IAAM,mBAAmB;AAAA,EAC9B,MAAM;AAAA,EACN,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAS;AAAA,EACT,cAAc;AAAA,IACZ,UAAU;AAAA,MACR,mBAAmB;AAAA,IACrB;AAAA,EACF;AAAA,EACA,OAAO;AAAA,IACL,YAAY;AAAA,MACV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,QACP,OAAO;AAAA,MACT;AAAA;AAAA;AAAA;AAAA;AAAA,MAKA,eAAe;AAAA,QACb,CAAC,cAAc,GAAG;AAAA,MACpB;AAAA,IACF;AAAA,IACA,gBAAgB;AAAA,MACd,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,QACP,OAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,EAAE,QAAQ,gBAAgB,UAAU,OAAO,UAAU,YAAY,YAAY,SAAS;AAAA,IACxF;AAAA,EACF;AAAA,EACA,YAAY;AAAA,IACV;AAAA,MACE,KAAK;AAAA,MACL,GAAG;AAAA,IACL;AAAA,EACF;AACF;AAEO,IAAM,2BAAkD;AAAA,EAC7D,WAAW;AAAA,EACX,GAAG;AACL;","names":[]}