@prisma-next/extension-pgvector 0.5.0-dev.60 → 0.5.0-dev.62

package/dist/codec-types-BFZqW_TL.d.mts

@@ -0,0 +1,64 @@
+import { AnyCodecDescriptor, CodecCallContext, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
+import { JsonValue } from "@prisma-next/contract/types";
+import { ExtractCodecTypes } from "@prisma-next/sql-relational-core/ast";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/core/constants.d.ts
+/**
+ * Codec ID for pgvector's vector type.
+ */
+declare const VECTOR_CODEC_ID: "pg/vector@1";
+//#endregion
+//#region src/core/codecs.d.ts
+
+type VectorParams = {
+  readonly length: number;
+};
+declare class PgVectorCodec extends CodecImpl<typeof VECTOR_CODEC_ID, readonly ['equality'], string, number[]> {
+  readonly length: number | undefined;
+  constructor(descriptor: AnyCodecDescriptor, length: number | undefined);
+  assertVector(value: unknown): asserts value is number[];
+  encode(value: number[], _ctx: CodecCallContext): Promise<string>;
+  decode(wire: string, _ctx: CodecCallContext): Promise<number[]>;
+  encodeJson(value: number[]): JsonValue;
+  decodeJson(json: JsonValue): number[];
+}
+declare class PgVectorDescriptor extends CodecDescriptorImpl<VectorParams> {
+  readonly codecId: "pg/vector@1";
+  readonly traits: readonly ["equality"];
+  readonly targetTypes: readonly ["vector"];
+  readonly meta: {
+    readonly db: {
+      readonly sql: {
+        readonly postgres: {
+          readonly nativeType: "vector";
+        };
+      };
+    };
+  };
+  readonly paramsSchema: StandardSchemaV1<VectorParams>;
+  renderOutputType(params: VectorParams): string;
+  /**
+   * The runtime calls `factory(undefined)(ctx)` to materialize a representative codec for parameterized descriptors that ship a no-params column variant (here, `vectorColumn` vs `vector(N)`). The runtime cast widens `params` to `unknown`, so guarding with an optional read keeps the typed call site (`factory({ length })`) strict while still producing a length-agnostic codec for representative use. Encode/decode for an undimensioned column run through this representative; the wire format `[v1,v2,...]` is dimension-independent.
+   */
+  factory(params: VectorParams): (ctx: CodecInstanceContext) => PgVectorCodec;
+}
+declare const codecDescriptorMap: {
+  readonly vector: PgVectorDescriptor;
+};
+type CodecTypes$1 = ExtractCodecTypes<typeof codecDescriptorMap>;
+//#endregion
+//#region src/types/codec-types.d.ts
+/**
+ * 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>).
+ */
+type Vector<N extends number = number> = number[] & {
+  readonly __vectorLength?: N;
+};
+type CodecTypes = CodecTypes$1;
+//#endregion
+export { Vector as n, CodecTypes as t };
+//# sourceMappingURL=codec-types-BFZqW_TL.d.mts.map

package/dist/codec-types-BFZqW_TL.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-BFZqW_TL.d.mts","names":[],"sources":["../src/core/constants.ts","../src/core/codecs.ts","../src/types/codec-types.ts"],"sourcesContent":[],"mappings":";;;;;;;;;cAGa;;;;KCyBR,YAAA,GA+C8B;EAAmB,SAAA,MAAA,EAAA,MAAA;CAsBvB;AAKZ,cAzDN,aAAA,SAAsB,SAyDhB,CAAA,OAxDV,eAwDU,EAAA,SAAA,CAAA,UAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,CAAA,CAAA;EAzDgB,SAAA,MAAA,EAAA,MAAA,GAAA,SAAA;EAAS,WAAA,CAAA,UAAA,EAQlB,kBARkB,EAAA,MAAA,EAAA,MAAA,GAAA,SAAA;EA+D/B,YAAA,CAAA,KAAA,EAAA,OAAmB,CAAA,EAAA,QAAA,KAAA,IAAA,MAAA,EAAA;EAA4B,MAAA,CAAA,KAAA,EAAA,MAAA,EAAA,EAAA,IAAA,EAtCtB,gBAsCsB,CAAA,EAtCH,OAsCG,CAAA,MAAA,CAAA;EAKT,MAAA,CAAA,IAAA,EAAA,MAAA,EAAA,IAAA,EAtChB,gBAsCgB,CAAA,EAtCG,OAsCH,CAAA,MAAA,EAAA,CAAA;EAAjB,UAAA,CAAA,KAAA,EAAA,MAAA,EAAA,CAAA,EAhBH,SAgBG;EACE,UAAA,CAAA,IAAA,EAZjB,SAYiB,CAAA,EAAA,MAAA,EAAA;;AAMY,cAZnC,kBAAA,SAA2B,mBAYQ,CAZY,YAYZ,CAAA,CAAA;EAAyB,SAAA,OAAA,EAAA,aAAA;EAZjC,SAAA,MAAA,EAAA,SAAA,CAAA,UAAA,CAAA;EAAmB,SAAA,WAAA,EAAA,SAAA,CAAA,QAAA,CAAA;EA8BrD,SAAA,IAAA,EAAA;IAIM,SAAA,EAAU,EAAA;;;;QC7HJ,CAAA;MAEN,CAAA;;;yBD8FsB,iBAAiB;2BACf;;;;kBAMT,qBAAqB,yBAAyB;;cAkBnE;mBAEI;;KAEE,YAAA,GAAa,yBAAyB;;;;AApHY;AAmB9D;;;;AAyByD,KCrD7C,MDqD6C,CAAA,UAAA,MAAA,GAAA,MAAA,CAAA,GAAA,MAAA,EAAA,GAAA;EAKtB,SAAA,cAAA,CAAA,EC1DoD,CD0DpD;CAAmB;AAsBvB,KC9EnB,UAAA,GAAa,YD8EM"}

package/dist/codec-types.d.mts

@@ -1,2 +1,2 @@
-import { n as Vector, t as CodecTypes } from "./codec-types-BifaP625.mjs";
+import { n as Vector, t as CodecTypes } from "./codec-types-BFZqW_TL.mjs";
 export { type CodecTypes, type Vector };

package/dist/column-types.d.mts

@@ -1,10 +1,9 @@
-import { ColumnTypeDescriptor } from "@prisma-next/contract-authoring";
+import { ColumnTypeDescriptor } from "@prisma-next/framework-components/codec";
 
 //#region src/exports/column-types.d.ts
 
 /**
- * Static vector column descriptor without dimension.
- * Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
+ * Static vector column descriptor without dimension. Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
  */
 declare const vectorColumn: {
   readonly codecId: "pg/vector@1";
@@ -18,7 +17,6 @@ declare const vectorColumn: {
  * .column('embedding', { type: vector(1536), nullable: false })
  * // Produces: nativeType: 'vector', 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]

package/dist/column-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/exports/column-types.ts"],"sourcesContent":[],"mappings":";;;;;;;;cAca;;;;;;;;;;;;;;;;;iBAkBG,iCACN,IACP;;qBAAiE"}
+{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/exports/column-types.ts"],"sourcesContent":[],"mappings":";;;;;;;cAYa;;;;;;;;;;;;;;;;iBAiBG,iCACN,IACP;;qBAAiE"}

package/dist/column-types.mjs

@@ -2,8 +2,7 @@ import { n as VECTOR_MAX_DIM, t as VECTOR_CODEC_ID } from "./constants-Co5golCK.
 
 //#region src/exports/column-types.ts
 /**
-* Static vector column descriptor without dimension.
-* Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
+* Static vector column descriptor without dimension. Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
 */
 const vectorColumn = {
 	codecId: VECTOR_CODEC_ID,
@@ -17,7 +16,6 @@ const vectorColumn = {
 * .column('embedding', { type: vector(1536), nullable: false })
 * // Produces: nativeType: 'vector', 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]

package/dist/column-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"column-types.mjs","names":[],"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', 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',\n    typeParams: { length },\n  } as const;\n}\n"],"mappings":";;;;;;;AAcA,MAAa,eAAe;CAC1B,SAAS;CACT,YAAY;CACb;;;;;;;;;;;;;;AAeD,SAAgB,OACd,QACwE;AACxE,KAAI,CAAC,OAAO,UAAU,OAAO,IAAI,SAAS,KAAK,SAAS,eACtD,OAAM,IAAI,WACR,iDAAiD,eAAe,SAAS,SAC1E;AAEH,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB"}
+{"version":3,"file":"column-types.mjs","names":[],"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. They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';\nimport { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';\n\n/**\n * Static vector column descriptor without dimension. 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', typeParams: { length: 1536 }\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',\n    typeParams: { length },\n  } as const;\n}\n"],"mappings":";;;;;;AAYA,MAAa,eAAe;CAC1B,SAAS;CACT,YAAY;CACb;;;;;;;;;;;;;AAcD,SAAgB,OACd,QACwE;AACxE,KAAI,CAAC,OAAO,UAAU,OAAO,IAAI,SAAS,KAAK,SAAS,eACtD,OAAM,IAAI,WACR,iDAAiD,eAAe,SAAS,SAC1E;AAEH,QAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB"}

package/dist/control.mjs

@@ -1,4 +1,4 @@
-import { n as pgvectorQueryOperations, t as pgvectorPackMeta } from "./descriptor-meta-DTopW_37.mjs";
+import { n as pgvectorQueryOperations, t as pgvectorPackMeta } from "./descriptor-meta-BaV3A8tJ.mjs";
 
 //#region src/exports/control.ts
 const PGVECTOR_CODEC_ID = "pg/vector@1";

package/dist/descriptor-meta-BaV3A8tJ.mjs

@@ -0,0 +1,189 @@
+import { n as VECTOR_MAX_DIM, t as VECTOR_CODEC_ID } from "./constants-Co5golCK.mjs";
+import { buildOperation, refsOf, toExpr } from "@prisma-next/sql-relational-core/expression";
+import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
+import { CodecDescriptorImpl, CodecImpl } from "@prisma-next/framework-components/codec";
+import { type } from "arktype";
+
+//#region src/core/authoring.ts
+const pgvectorAuthoringTypes = { pgvector: { Vector: {
+	kind: "typeConstructor",
+	args: [{
+		kind: "number",
+		name: "length",
+		integer: true,
+		minimum: 1,
+		maximum: VECTOR_MAX_DIM
+	}],
+	output: {
+		codecId: "pg/vector@1",
+		nativeType: "vector",
+		typeParams: { length: {
+			kind: "arg",
+			index: 0
+		} }
+	}
+} } };
+
+//#endregion
+//#region src/core/codecs.ts
+const vectorParamsSchema = type({ 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;
+});
+const PG_VECTOR_META = { db: { sql: { postgres: { nativeType: "vector" } } } };
+var PgVectorCodec = class extends CodecImpl {
+	length;
+	constructor(descriptor, length) {
+		super(descriptor);
+		this.length = length;
+	}
+	assertVector(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");
+		if (this.length !== void 0 && value.length !== this.length) throw new Error(`Vector length mismatch: expected ${this.length}, got ${value.length}`);
+	}
+	async encode(value, _ctx) {
+		this.assertVector(value);
+		return `[${value.join(",")}]`;
+	}
+	async decode(wire, _ctx) {
+		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();
+		const parsed = content === "" ? [] : 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;
+		});
+		this.assertVector(parsed);
+		return parsed;
+	}
+	encodeJson(value) {
+		this.assertVector(value);
+		return value;
+	}
+	decodeJson(json) {
+		this.assertVector(json);
+		return json;
+	}
+};
+var PgVectorDescriptor = class extends CodecDescriptorImpl {
+	codecId = VECTOR_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = ["vector"];
+	meta = PG_VECTOR_META;
+	paramsSchema = vectorParamsSchema;
+	renderOutputType(params) {
+		return `Vector<${params.length}>`;
+	}
+	/**
+	* The runtime calls `factory(undefined)(ctx)` to materialize a representative codec for parameterized descriptors that ship a no-params column variant (here, `vectorColumn` vs `vector(N)`). The runtime cast widens `params` to `unknown`, so guarding with an optional read keeps the typed call site (`factory({ length })`) strict while still producing a length-agnostic codec for representative use. Encode/decode for an undimensioned column run through this representative; the wire format `[v1,v2,...]` is dimension-independent.
+	*/
+	factory(params) {
+		return () => new PgVectorCodec(this, params?.length);
+	}
+};
+const pgVectorDescriptor = new PgVectorDescriptor();
+const codecDescriptorMap = { vector: pgVectorDescriptor };
+const codecDescriptors = Object.values(codecDescriptorMap);
+
+//#endregion
+//#region src/core/registry.ts
+/**
+* Registry of every codec descriptor shipped by `@prisma-next/extension-pgvector`.
+*
+* Public consumer surface for the pgvector codec set. Currently a single entry (`pg/vector@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.
+*/
+const pgvectorCodecRegistry = buildCodecDescriptorRegistry(codecDescriptors);
+
+//#endregion
+//#region src/core/descriptor-meta.ts
+const pgvectorTypeId = "pg/vector@1";
+function pgvectorQueryOperations() {
+	return [{
+		method: "cosineDistance",
+		self: { codecId: pgvectorTypeId },
+		impl: (self, other) => {
+			const selfRefs = refsOf(self);
+			return buildOperation({
+				method: "cosineDistance",
+				args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
+				returns: {
+					codecId: "pg/float8@1",
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} <=> {{arg0}}"
+				}
+			});
+		}
+	}, {
+		method: "cosineSimilarity",
+		self: { codecId: pgvectorTypeId },
+		impl: (self, other) => {
+			const selfRefs = refsOf(self);
+			return buildOperation({
+				method: "cosineSimilarity",
+				args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
+				returns: {
+					codecId: "pg/float8@1",
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "1 - ({{self}} <=> {{arg0}})"
+				}
+			});
+		}
+	}];
+}
+const pgvectorPackMetaBase = {
+	kind: "extension",
+	id: "pgvector",
+	familyId: "sql",
+	targetId: "postgres",
+	version: "0.0.1",
+	capabilities: { postgres: { "pgvector.cosine": true } },
+	authoring: { type: pgvectorAuthoringTypes },
+	types: {
+		codecTypes: {
+			codecDescriptors: Array.from(pgvectorCodecRegistry.values()),
+			import: {
+				package: "@prisma-next/extension-pgvector/codec-types",
+				named: "CodecTypes",
+				alias: "PgVectorTypes"
+			},
+			typeImports: [{
+				package: "@prisma-next/extension-pgvector/codec-types",
+				named: "Vector",
+				alias: "Vector"
+			}]
+		},
+		operationTypes: { import: {
+			package: "@prisma-next/extension-pgvector/operation-types",
+			named: "OperationTypes",
+			alias: "PgVectorOperationTypes"
+		} },
+		queryOperationTypes: { import: {
+			package: "@prisma-next/extension-pgvector/operation-types",
+			named: "QueryOperationTypes",
+			alias: "PgVectorQueryOperationTypes"
+		} },
+		storage: [{
+			typeId: pgvectorTypeId,
+			familyId: "sql",
+			targetId: "postgres",
+			nativeType: "vector"
+		}]
+	}
+};
+const pgvectorPackMeta = pgvectorPackMetaBase;
+
+//#endregion
+export { pgvectorQueryOperations as n, pgvectorCodecRegistry as r, pgvectorPackMeta as t };
+//# sourceMappingURL=descriptor-meta-BaV3A8tJ.mjs.map

package/dist/descriptor-meta-BaV3A8tJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-BaV3A8tJ.mjs","names":["arktype","codecDescriptors: readonly AnyCodecDescriptor[]","pgvectorCodecRegistry: CodecDescriptorRegistry","pgvectorPackMeta: typeof pgvectorPackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n}"],"sources":["../src/core/authoring.ts","../src/core/codecs.ts","../src/core/registry.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';\nimport { VECTOR_MAX_DIM } from './constants';\n\nexport const pgvectorAuthoringTypes = {\n  pgvector: {\n    Vector: {\n      kind: 'typeConstructor',\n      args: [\n        { kind: 'number', name: 'length', integer: true, minimum: 1, maximum: VECTOR_MAX_DIM },\n      ],\n      output: {\n        codecId: 'pg/vector@1',\n        nativeType: 'vector',\n        typeParams: {\n          length: { kind: 'arg', index: 0 },\n        },\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\n","/**\n * pgvector extension codec.\n *\n * Mirrors the patterns in `postgres/codecs-class.ts` and `sqlite/codecs-class.ts` for the single `pg/vector@1` codec. Three artifacts:\n *\n * 1. `PgVectorCodec` extends {@link CodecImpl} with the runtime encode/decode/encodeJson/decodeJson conversions inline. Conversions are simple enough (PostgreSQL `[1,2,3]` text format) that no shared helper module is warranted; the class body is the source of truth.\n * 2. `PgVectorDescriptor` extends {@link CodecDescriptorImpl} with the codec id, traits, target types, params schema (`{ length: number }`, validated against {@link VECTOR_MAX_DIM}), `meta` (postgres `nativeType: 'vector'`), and the emit-path `renderOutputType` producing `Vector<${length}>`.\n * 3. `pgVectorColumn(length)` per-codec column helper invoking `descriptor.factory({ length })` directly + passing the bare `nativeType: 'vector'`. The family-layer {@link expandNativeType} hook renders the parameterized form (`vector(1536)`) at emit/verify time from `nativeType` + `typeParams`.\n *\n * `length` threads into the runtime codec via the constructor so encode/decode/encodeJson/decodeJson enforce the declared dimension at every ingress path. Without this, `vector(3)` and `vector(1536)` would produce codecs with identical behaviour and a dimension-mismatched value would round-trip undetected.\n */\n\nimport type { JsonValue } from '@prisma-next/contract/types';\nimport {\n  type AnyCodecDescriptor,\n  type CodecCallContext,\n  CodecDescriptorImpl,\n  CodecImpl,\n  type CodecInstanceContext,\n  type ColumnHelperFor,\n  type ColumnHelperForStrict,\n  column,\n} from '@prisma-next/framework-components/codec';\nimport type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport { type as arktype } from 'arktype';\nimport { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from './constants';\n\ntype VectorParams = { readonly length: number };\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}) satisfies StandardSchemaV1<VectorParams>;\n\nconst PG_VECTOR_META = { db: { sql: { postgres: { nativeType: 'vector' } } } } as const;\n\nexport class PgVectorCodec extends CodecImpl<\n  typeof VECTOR_CODEC_ID,\n  readonly ['equality'],\n  string,\n  number[]\n> {\n  readonly length: number | undefined;\n\n  constructor(descriptor: AnyCodecDescriptor, length: number | undefined) {\n    super(descriptor);\n    this.length = length;\n  }\n\n  assertVector(value: unknown): asserts value is number[] {\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    if (this.length !== undefined && value.length !== this.length) {\n      throw new Error(`Vector length mismatch: expected ${this.length}, got ${value.length}`);\n    }\n  }\n\n  async encode(value: number[], _ctx: CodecCallContext): Promise<string> {\n    this.assertVector(value);\n    return `[${value.join(',')}]`;\n  }\n\n  async decode(wire: string, _ctx: CodecCallContext): Promise<number[]> {\n    if (typeof wire !== 'string') {\n      throw new Error('Vector wire value must be a string');\n    }\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    const parsed =\n      content === ''\n        ? []\n        : 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    this.assertVector(parsed);\n    return parsed;\n  }\n\n  encodeJson(value: number[]): JsonValue {\n    this.assertVector(value);\n    return value;\n  }\n\n  decodeJson(json: JsonValue): number[] {\n    this.assertVector(json);\n    return json;\n  }\n}\n\nexport class PgVectorDescriptor extends CodecDescriptorImpl<VectorParams> {\n  override readonly codecId = VECTOR_CODEC_ID;\n  override readonly traits = ['equality'] as const;\n  override readonly targetTypes = ['vector'] as const;\n  override readonly meta = PG_VECTOR_META;\n  override readonly paramsSchema: StandardSchemaV1<VectorParams> = vectorParamsSchema;\n  override renderOutputType(params: VectorParams): string {\n    return `Vector<${params.length}>`;\n  }\n  /**\n   * The runtime calls `factory(undefined)(ctx)` to materialize a representative codec for parameterized descriptors that ship a no-params column variant (here, `vectorColumn` vs `vector(N)`). The runtime cast widens `params` to `unknown`, so guarding with an optional read keeps the typed call site (`factory({ length })`) strict while still producing a length-agnostic codec for representative use. Encode/decode for an undimensioned column run through this representative; the wire format `[v1,v2,...]` is dimension-independent.\n   */\n  override factory(params: VectorParams): (ctx: CodecInstanceContext) => PgVectorCodec {\n    return () => new PgVectorCodec(this, (params as VectorParams | undefined)?.length);\n  }\n}\n\nexport const pgVectorDescriptor = new PgVectorDescriptor();\n\n/**\n * Per-codec column helper for `pg/vector@1`. Generic over `N extends number` so the column site preserves the dimension literal in `typeParams` (e.g. `pgVectorColumn(1536)` packs `typeParams: { length: 1536 }`).\n *\n * Passes the bare `nativeType: 'vector'`; the family-layer `expandNativeType` hook renders the parameterized form (`vector(1536)`) at emit/verify time from `nativeType` + `typeParams`.\n */\nexport const pgVectorColumn = <N extends number>(length: N) =>\n  column(pgVectorDescriptor.factory({ length }), pgVectorDescriptor.codecId, { length }, 'vector');\n\npgVectorColumn satisfies ColumnHelperFor<PgVectorDescriptor>;\npgVectorColumn satisfies ColumnHelperForStrict<PgVectorDescriptor>;\n\nconst codecDescriptorMap = {\n  vector: pgVectorDescriptor,\n} as const;\n\nexport type CodecTypes = ExtractCodecTypes<typeof codecDescriptorMap>;\n\nexport const codecDescriptors: readonly AnyCodecDescriptor[] = Object.values(codecDescriptorMap);\n","import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';\nimport type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';\nimport { codecDescriptors } from './codecs';\n\n/**\n * Registry of every codec descriptor shipped by `@prisma-next/extension-pgvector`.\n *\n * Public consumer surface for the pgvector codec set. Currently a single entry (`pg/vector@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.\n */\nexport const pgvectorCodecRegistry: CodecDescriptorRegistry =\n  buildCodecDescriptorRegistry(codecDescriptors);\n","import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';\nimport {\n  buildOperation,\n  type CodecExpression,\n  type Expression,\n  refsOf,\n  toExpr,\n} from '@prisma-next/sql-relational-core/expression';\nimport type { CodecTypes } from '../types/codec-types';\nimport { pgvectorAuthoringTypes } from './authoring';\nimport { pgvectorCodecRegistry } from './registry';\n\nconst pgvectorTypeId = 'pg/vector@1' as const;\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\nexport function pgvectorQueryOperations<\n  CT extends CodecTypesBase,\n>(): readonly SqlOperationDescriptor[] {\n  return [\n    {\n      method: 'cosineDistance',\n      self: { codecId: pgvectorTypeId },\n      impl: (\n        self: CodecExpression<'pg/vector@1', boolean, CT>,\n        other: CodecExpression<'pg/vector@1', boolean, CT>,\n      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> => {\n        const selfRefs = refsOf(self);\n        return buildOperation({\n          method: 'cosineDistance',\n          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],\n          returns: { codecId: 'pg/float8@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} <=> {{arg0}}',\n          },\n        });\n      },\n    },\n    {\n      method: 'cosineSimilarity',\n      self: { codecId: pgvectorTypeId },\n      impl: (\n        self: CodecExpression<'pg/vector@1', boolean, CT>,\n        other: CodecExpression<'pg/vector@1', boolean, CT>,\n      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> => {\n        const selfRefs = refsOf(self);\n        return buildOperation({\n          method: 'cosineSimilarity',\n          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],\n          returns: { codecId: 'pg/float8@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '1 - ({{self}} <=> {{arg0}})',\n          },\n        });\n      },\n    },\n  ];\n}\n\nconst pgvectorPackMetaBase = {\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  authoring: {\n    type: pgvectorAuthoringTypes,\n  },\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(pgvectorCodecRegistry.values()),\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    },\n    operationTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/operation-types',\n        named: 'OperationTypes',\n        alias: 'PgVectorOperationTypes',\n      },\n    },\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'PgVectorQueryOperationTypes',\n      },\n    },\n    storage: [\n      { typeId: pgvectorTypeId, familyId: 'sql', targetId: 'postgres', nativeType: 'vector' },\n    ],\n  },\n} as const;\n\nexport const pgvectorPackMeta: typeof pgvectorPackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = pgvectorPackMetaBase;\n"],"mappings":"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"}

package/dist/pack.d.mts

@@ -1,5 +1,5 @@
-import { t as CodecTypes } from "./codec-types-BifaP625.mjs";
-import * as _prisma_next_sql_relational_core_ast0 from "@prisma-next/sql-relational-core/ast";
+import { t as CodecTypes } from "./codec-types-BFZqW_TL.mjs";
+import * as _prisma_next_framework_components_codec0 from "@prisma-next/framework-components/codec";
 
 //#region src/core/descriptor-meta.d.ts
 
@@ -42,7 +42,7 @@ declare const pgvectorPackMetaBase: {
   };
   readonly types: {
     readonly codecTypes: {
-      readonly codecInstances: _prisma_next_sql_relational_core_ast0.Codec<"pg/vector@1", readonly ["equality"], string, number[], Record<string, unknown>, unknown>[];
+      readonly codecDescriptors: _prisma_next_framework_components_codec0.CodecDescriptor<unknown>[];
       readonly import: {
         readonly package: "@prisma-next/extension-pgvector/codec-types";
         readonly named: "CodecTypes";

package/dist/pack.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":[],"mappings":";;;;;cA0DM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAgDI,qCAAA,CAAA,8DAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEG,yBAAyB;0BACZ"}
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":[],"mappings":";;;;;cA+DM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAgDI,wCAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEG,yBAAyB;0BACZ"}

package/dist/pack.mjs

@@ -1,3 +1,3 @@
-import { t as pgvectorPackMeta } from "./descriptor-meta-DTopW_37.mjs";
+import { t as pgvectorPackMeta } from "./descriptor-meta-BaV3A8tJ.mjs";
 
 export { pgvectorPackMeta as default };

package/dist/runtime.d.mts

@@ -1,7 +1,17 @@
 import { SqlRuntimeExtensionDescriptor } from "@prisma-next/sql-runtime";
+import { CodecDescriptorRegistry } from "@prisma-next/sql-relational-core/query-lane-context";
 
+//#region src/core/registry.d.ts
+
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/extension-pgvector`.
+ *
+ * Public consumer surface for the pgvector codec set. Currently a single entry (`pg/vector@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.
+ */
+declare const pgvectorCodecRegistry: CodecDescriptorRegistry;
+//#endregion
 //#region src/exports/runtime.d.ts
 declare const pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>;
 //#endregion
-export { pgvectorRuntimeDescriptor as default };
+export { pgvectorRuntimeDescriptor as default, pgvectorCodecRegistry };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;cA6DM,2BAA2B"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/registry.ts","../src/exports/runtime.ts"],"sourcesContent":[],"mappings":";;;;;;;;AASA;;cAAa,uBAAuB;;;cCL9B,2BAA2B"}

package/dist/runtime.mjs

@@ -1,40 +1,15 @@
-import { n as VECTOR_MAX_DIM, t as VECTOR_CODEC_ID } from "./constants-Co5golCK.mjs";
-import { n as pgvectorQueryOperations, r as codecDefinitions, t as pgvectorPackMeta } from "./descriptor-meta-DTopW_37.mjs";
-import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
-import { type } from "arktype";
+import { n as pgvectorQueryOperations, r as pgvectorCodecRegistry, t as pgvectorPackMeta } from "./descriptor-meta-BaV3A8tJ.mjs";
 
 //#region src/exports/runtime.ts
-const vectorParamsSchema = type({ 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;
-});
-const sharedVectorCodec = codecDefinitions.vector.codec;
-const vectorFactory = (_params) => (_ctx) => sharedVectorCodec;
-const parameterizedCodecDescriptors = [{
-	codecId: VECTOR_CODEC_ID,
-	traits: ["equality"],
-	targetTypes: ["vector"],
-	paramsSchema: vectorParamsSchema,
-	renderOutputType: (params) => `Vector<${params.length}>`,
-	factory: vectorFactory
-}];
-function createPgvectorCodecRegistry() {
-	const registry = createCodecRegistry();
-	for (const def of Object.values(codecDefinitions)) registry.register(def.codec);
-	return registry;
-}
 const pgvectorRuntimeDescriptor = {
 	kind: "extension",
 	id: pgvectorPackMeta.id,
 	version: pgvectorPackMeta.version,
 	familyId: "sql",
 	targetId: "postgres",
-	types: { codecTypes: { codecInstances: Object.values(codecDefinitions).map((def) => def.codec) } },
-	codecs: createPgvectorCodecRegistry,
+	types: { codecTypes: { codecDescriptors: Array.from(pgvectorCodecRegistry.values()) } },
+	codecs: () => Array.from(pgvectorCodecRegistry.values()),
 	queryOperations: () => pgvectorQueryOperations(),
-	parameterizedCodecs: () => parameterizedCodecDescriptors,
 	create() {
 		return {
 			familyId: "sql",
@@ -45,5 +20,5 @@ const pgvectorRuntimeDescriptor = {
 var runtime_default = pgvectorRuntimeDescriptor;
 
 //#endregion
-export { runtime_default as default };
+export { runtime_default as default, pgvectorCodecRegistry };
 //# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["arktype","sharedVectorCodec: Codec","pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { Codec, CodecInstanceContext } from '@prisma-next/framework-components/codec';\nimport { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type {\n  RuntimeParameterizedCodecDescriptor,\n  SqlRuntimeExtensionDescriptor,\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, pgvectorQueryOperations } 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// pgvector's encode is parameter-independent (the wire format `[v1,v2,...]`\n// doesn't care about declared length), so the resolved codec for every\n// `(length)` instance is the same shared codec object today. The factory\n// returns it directly; `ctx` is unused. When a future refactor wants per-\n// instance state (e.g. capping wire length to declared dimension), the\n// closure over `params` is the place to add it.\n//\n// The factory parameter types as the family-agnostic\n// `CodecInstanceContext` because pgvector doesn't read the SQL-specific\n// `usedAt` field. The SQL runtime materializer passes a\n// `SqlCodecInstanceContext`; family-agnostic factories are structurally\n// compatible with the SQL extended type.\nconst sharedVectorCodec: Codec = codecDefinitions.vector.codec;\nconst vectorFactory = (_params: { readonly length: number }) => (_ctx: CodecInstanceContext) =>\n  sharedVectorCodec;\n\nconst parameterizedCodecDescriptors = [\n  {\n    codecId: VECTOR_CODEC_ID,\n    traits: ['equality'] as const,\n    targetTypes: ['vector'] as const,\n    paramsSchema: vectorParamsSchema,\n    renderOutputType: (params: { readonly length: number }) => `Vector<${params.length}>`,\n    factory: vectorFactory,\n  },\n] as const satisfies ReadonlyArray<\n  RuntimeParameterizedCodecDescriptor<{ readonly length: number }>\n>;\n\nfunction createPgvectorCodecRegistry() {\n  const registry = createCodecRegistry();\n  for (const def of Object.values(codecDefinitions)) {\n    registry.register(def.codec);\n  }\n  return registry;\n}\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  // Mirror `pgvectorPackMeta.types.codecTypes.codecInstances` here so that\n  // runtime-plane assemblers driven by `extractCodecLookup` (which reads\n  // `descriptor.types?.codecTypes?.codecInstances`) discover `pg/vector@1`.\n  // Without this, the Postgres adapter's runtime-plane codec lookup misses\n  // the vector codec and `$N::vector` would silently disappear once the\n  // renderer switches to lookup-driven cast policy.\n  types: {\n    codecTypes: {\n      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),\n    },\n  },\n  codecs: createPgvectorCodecRegistry,\n  queryOperations: () => pgvectorQueryOperations(),\n  parameterizedCodecs: () => parameterizedCodecDescriptors,\n  create() {\n    return {\n      familyId: 'sql' as const,\n      targetId: 'postgres' as const,\n    };\n  },\n};\n\nexport default pgvectorRuntimeDescriptor;\n"],"mappings":";;;;;;AAWA,MAAM,qBAAqBA,KAAQ,EACjC,QAAQ,UACT,CAAC,CAAC,QAAQ,QAAQ,QAAQ;CACzB,MAAM,EAAE,WAAW;AACnB,KAAI,CAAC,OAAO,UAAU,OAAO,CAC3B,QAAO,IAAI,OAAO,aAAa;AAEjC,KAAI,SAAS,KAAK,SAAS,eACzB,QAAO,IAAI,OAAO,oBAAoB,eAAe,GAAG;AAE1D,QAAO;EACP;AAcF,MAAMC,oBAA2B,iBAAiB,OAAO;AACzD,MAAM,iBAAiB,aAA0C,SAC/D;AAEF,MAAM,gCAAgC,CACpC;CACE,SAAS;CACT,QAAQ,CAAC,WAAW;CACpB,aAAa,CAAC,SAAS;CACvB,cAAc;CACd,mBAAmB,WAAwC,UAAU,OAAO,OAAO;CACnF,SAAS;CACV,CACF;AAID,SAAS,8BAA8B;CACrC,MAAM,WAAW,qBAAqB;AACtC,MAAK,MAAM,OAAO,OAAO,OAAO,iBAAiB,CAC/C,UAAS,SAAS,IAAI,MAAM;AAE9B,QAAO;;AAGT,MAAMC,4BAAuE;CAC3E,MAAM;CACN,IAAI,iBAAiB;CACrB,SAAS,iBAAiB;CAC1B,UAAU;CACV,UAAU;CAOV,OAAO,EACL,YAAY,EACV,gBAAgB,OAAO,OAAO,iBAAiB,CAAC,KAAK,QAAQ,IAAI,MAAM,EACxE,EACF;CACD,QAAQ;CACR,uBAAuB,yBAAyB;CAChD,2BAA2B;CAC3B,SAAS;AACP,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAED,sBAAe"}
+{"version":3,"file":"runtime.mjs","names":["pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>"],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';\nimport { pgvectorPackMeta, pgvectorQueryOperations } from '../core/descriptor-meta';\nimport { pgvectorCodecRegistry } from '../core/registry';\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  // Expose the unified descriptor list so `extractCodecLookup` reads `targetTypes` / `meta` / `renderOutputType` directly off the descriptors and materializes the representative `Codec` for the SQL renderer's cast-policy lookup.\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(pgvectorCodecRegistry.values()),\n    },\n  },\n  codecs: () => Array.from(pgvectorCodecRegistry.values()),\n  queryOperations: () => pgvectorQueryOperations(),\n  create() {\n    return {\n      familyId: 'sql' as const,\n      targetId: 'postgres' as const,\n    };\n  },\n};\n\nexport { pgvectorCodecRegistry };\nexport default pgvectorRuntimeDescriptor;\n"],"mappings":";;;AAIA,MAAMA,4BAAuE;CAC3E,MAAM;CACN,IAAI,iBAAiB;CACrB,SAAS,iBAAiB;CAC1B,UAAU;CACV,UAAU;CAEV,OAAO,EACL,YAAY,EACV,kBAAkB,MAAM,KAAK,sBAAsB,QAAQ,CAAC,EAC7D,EACF;CACD,cAAc,MAAM,KAAK,sBAAsB,QAAQ,CAAC;CACxD,uBAAuB,yBAAyB;CAChD,SAAS;AACP,SAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ;AAGD,sBAAe"}

package/package.json

@@ -1,30 +1,31 @@
 {
   "name": "@prisma-next/extension-pgvector",
-  "version": "0.5.0-dev.60",
+  "version": "0.5.0-dev.62",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.0.0",
-    "@prisma-next/contract": "0.5.0-dev.60",
-    "@prisma-next/contract-authoring": "0.5.0-dev.60",
-    "@prisma-next/family-sql": "0.5.0-dev.60",
-    "@prisma-next/framework-components": "0.5.0-dev.60",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.60",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.60",
-    "@prisma-next/sql-runtime": "0.5.0-dev.60",
-    "@prisma-next/sql-operations": "0.5.0-dev.60"
+    "@prisma-next/contract": "0.5.0-dev.62",
+    "@prisma-next/family-sql": "0.5.0-dev.62",
+    "@prisma-next/framework-components": "0.5.0-dev.62",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.62",
+    "@prisma-next/contract-authoring": "0.5.0-dev.62",
+    "@prisma-next/sql-operations": "0.5.0-dev.62",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.62",
+    "@prisma-next/sql-runtime": "0.5.0-dev.62"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/sql-contract": "0.5.0-dev.60",
-    "@prisma-next/operations": "0.5.0-dev.60",
+    "@prisma-next/operations": "0.5.0-dev.62",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.62",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.60",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/sql-contract": "0.5.0-dev.62"
   },
   "files": [
     "dist",

package/src/core/codecs.ts

@@ -1,77 +1,145 @@
 /**
- * Vector codec implementation for pgvector extension.
+ * pgvector extension codec.
  *
- * Provides encoding/decoding for the `vector` PostgreSQL type.
- * Wire format is a string like `[1,2,3]` (PostgreSQL vector text format).
+ * Mirrors the patterns in `postgres/codecs-class.ts` and `sqlite/codecs-class.ts` for the single `pg/vector@1` codec. Three artifacts:
+ *
+ * 1. `PgVectorCodec` extends {@link CodecImpl} with the runtime encode/decode/encodeJson/decodeJson conversions inline. Conversions are simple enough (PostgreSQL `[1,2,3]` text format) that no shared helper module is warranted; the class body is the source of truth.
+ * 2. `PgVectorDescriptor` extends {@link CodecDescriptorImpl} with the codec id, traits, target types, params schema (`{ length: number }`, validated against {@link VECTOR_MAX_DIM}), `meta` (postgres `nativeType: 'vector'`), and the emit-path `renderOutputType` producing `Vector<${length}>`.
+ * 3. `pgVectorColumn(length)` per-codec column helper invoking `descriptor.factory({ length })` directly + passing the bare `nativeType: 'vector'`. The family-layer {@link expandNativeType} hook renders the parameterized form (`vector(1536)`) at emit/verify time from `nativeType` + `typeParams`.
+ *
+ * `length` threads into the runtime codec via the constructor so encode/decode/encodeJson/decodeJson enforce the declared dimension at every ingress path. Without this, `vector(3)` and `vector(1536)` would produce codecs with identical behaviour and a dimension-mismatched value would round-trip undetected.
  */
 
-import { codec, defineCodecs } from '@prisma-next/sql-relational-core/ast';
-
-const pgVectorCodec = codec({
-  typeId: 'pg/vector@1',
-  targetTypes: ['vector'],
-  traits: ['equality'],
-  renderOutputType: (typeParams) => {
-    const length = typeParams['length'];
-    if (length === undefined) return undefined;
-    if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {
-      throw new Error(
-        `renderOutputType: expected positive integer "length" in typeParams for Vector, got ${String(length)}`,
-      );
-    }
-    return `Vector<${length}>`;
-  },
-  encode: (value: number[]): string => {
-    // Validate that value is an array of numbers
+import type { JsonValue } from '@prisma-next/contract/types';
+import {
+  type AnyCodecDescriptor,
+  type CodecCallContext,
+  CodecDescriptorImpl,
+  CodecImpl,
+  type CodecInstanceContext,
+  type ColumnHelperFor,
+  type ColumnHelperForStrict,
+  column,
+} from '@prisma-next/framework-components/codec';
+import type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { type as arktype } from 'arktype';
+import { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from './constants';
+
+type VectorParams = { readonly length: number };
+
+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;
+}) satisfies StandardSchemaV1<VectorParams>;
+
+const PG_VECTOR_META = { db: { sql: { postgres: { nativeType: 'vector' } } } } as const;
+
+export class PgVectorCodec extends CodecImpl<
+  typeof VECTOR_CODEC_ID,
+  readonly ['equality'],
+  string,
+  number[]
+> {
+  readonly length: number | undefined;
+
+  constructor(descriptor: AnyCodecDescriptor, length: number | undefined) {
+    super(descriptor);
+    this.length = length;
+  }
+
+  assertVector(value: unknown): asserts value is number[] {
     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');
     }
-    // Format as PostgreSQL vector text format: [1,2,3]
-    // PostgreSQL's pg library requires the vector format string
+    if (this.length !== undefined && value.length !== this.length) {
+      throw new Error(`Vector length mismatch: expected ${this.length}, got ${value.length}`);
+    }
+  }
+
+  async encode(value: number[], _ctx: CodecCallContext): Promise<string> {
+    this.assertVector(value);
     return `[${value.join(',')}]`;
-  },
-  decode: (wire: string): number[] => {
-    // Handle string format from PostgreSQL: [1,2,3]
+  }
+
+  async decode(wire: string, _ctx: CodecCallContext): Promise<number[]> {
     if (typeof wire !== 'string') {
       throw new Error('Vector wire value must be a string');
     }
-    // Parse PostgreSQL vector format: [1,2,3]
     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',
-        },
-      },
-    },
-  },
-});
-
-// Build codec definitions using the builder DSL
-const codecs = defineCodecs().add('vector', pgVectorCodec);
-
-// Export derived structures directly from codecs builder
-export const codecDefinitions = codecs.codecDefinitions;
-export const dataTypes = codecs.dataTypes;
-
-// Export types derived from codecs builder
-export type CodecTypes = typeof codecs.CodecTypes;
+    const parsed =
+      content === ''
+        ? []
+        : 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;
+          });
+    this.assertVector(parsed);
+    return parsed;
+  }
+
+  encodeJson(value: number[]): JsonValue {
+    this.assertVector(value);
+    return value;
+  }
+
+  decodeJson(json: JsonValue): number[] {
+    this.assertVector(json);
+    return json;
+  }
+}
+
+export class PgVectorDescriptor extends CodecDescriptorImpl<VectorParams> {
+  override readonly codecId = VECTOR_CODEC_ID;
+  override readonly traits = ['equality'] as const;
+  override readonly targetTypes = ['vector'] as const;
+  override readonly meta = PG_VECTOR_META;
+  override readonly paramsSchema: StandardSchemaV1<VectorParams> = vectorParamsSchema;
+  override renderOutputType(params: VectorParams): string {
+    return `Vector<${params.length}>`;
+  }
+  /**
+   * The runtime calls `factory(undefined)(ctx)` to materialize a representative codec for parameterized descriptors that ship a no-params column variant (here, `vectorColumn` vs `vector(N)`). The runtime cast widens `params` to `unknown`, so guarding with an optional read keeps the typed call site (`factory({ length })`) strict while still producing a length-agnostic codec for representative use. Encode/decode for an undimensioned column run through this representative; the wire format `[v1,v2,...]` is dimension-independent.
+   */
+  override factory(params: VectorParams): (ctx: CodecInstanceContext) => PgVectorCodec {
+    return () => new PgVectorCodec(this, (params as VectorParams | undefined)?.length);
+  }
+}
+
+export const pgVectorDescriptor = new PgVectorDescriptor();
+
+/**
+ * Per-codec column helper for `pg/vector@1`. Generic over `N extends number` so the column site preserves the dimension literal in `typeParams` (e.g. `pgVectorColumn(1536)` packs `typeParams: { length: 1536 }`).
+ *
+ * Passes the bare `nativeType: 'vector'`; the family-layer `expandNativeType` hook renders the parameterized form (`vector(1536)`) at emit/verify time from `nativeType` + `typeParams`.
+ */
+export const pgVectorColumn = <N extends number>(length: N) =>
+  column(pgVectorDescriptor.factory({ length }), pgVectorDescriptor.codecId, { length }, 'vector');
+
+pgVectorColumn satisfies ColumnHelperFor<PgVectorDescriptor>;
+pgVectorColumn satisfies ColumnHelperForStrict<PgVectorDescriptor>;
+
+const codecDescriptorMap = {
+  vector: pgVectorDescriptor,
+} as const;
+
+export type CodecTypes = ExtractCodecTypes<typeof codecDescriptorMap>;
+
+export const codecDescriptors: readonly AnyCodecDescriptor[] = Object.values(codecDescriptorMap);

package/src/core/descriptor-meta.ts

@@ -3,11 +3,12 @@ import {
   buildOperation,
   type CodecExpression,
   type Expression,
+  refsOf,
   toExpr,
 } from '@prisma-next/sql-relational-core/expression';
 import type { CodecTypes } from '../types/codec-types';
 import { pgvectorAuthoringTypes } from './authoring';
-import { codecDefinitions } from './codecs';
+import { pgvectorCodecRegistry } from './registry';
 
 const pgvectorTypeId = 'pg/vector@1' as const;
 
@@ -23,17 +24,19 @@ export function pgvectorQueryOperations<
       impl: (
         self: CodecExpression<'pg/vector@1', boolean, CT>,
         other: CodecExpression<'pg/vector@1', boolean, CT>,
-      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> =>
-        buildOperation({
+      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
           method: 'cosineDistance',
-          args: [toExpr(self, pgvectorTypeId), toExpr(other, pgvectorTypeId)],
+          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
           returns: { codecId: 'pg/float8@1', nullable: false },
           lowering: {
             targetFamily: 'sql',
             strategy: 'function',
             template: '{{self}} <=> {{arg0}}',
           },
-        }),
+        });
+      },
     },
     {
       method: 'cosineSimilarity',
@@ -41,17 +44,19 @@ export function pgvectorQueryOperations<
       impl: (
         self: CodecExpression<'pg/vector@1', boolean, CT>,
         other: CodecExpression<'pg/vector@1', boolean, CT>,
-      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> =>
-        buildOperation({
+      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
           method: 'cosineSimilarity',
-          args: [toExpr(self, pgvectorTypeId), toExpr(other, pgvectorTypeId)],
+          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
           returns: { codecId: 'pg/float8@1', nullable: false },
           lowering: {
             targetFamily: 'sql',
             strategy: 'function',
             template: '1 - ({{self}} <=> {{arg0}})',
           },
-        }),
+        });
+      },
     },
   ];
 }
@@ -72,7 +77,7 @@ const pgvectorPackMetaBase = {
   },
   types: {
     codecTypes: {
-      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
+      codecDescriptors: Array.from(pgvectorCodecRegistry.values()),
       import: {
         package: '@prisma-next/extension-pgvector/codec-types',
         named: 'CodecTypes',

package/src/core/registry.ts

@@ -0,0 +1,11 @@
+import { buildCodecDescriptorRegistry } from '@prisma-next/sql-relational-core/codec-descriptor-registry';
+import type { CodecDescriptorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { codecDescriptors } from './codecs';
+
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/extension-pgvector`.
+ *
+ * Public consumer surface for the pgvector codec set. Currently a single entry (`pg/vector@1`); the registry shape stays consistent with the other codec-shipping packages so consumers don't need to special-case extensions. See ADR 208.
+ */
+export const pgvectorCodecRegistry: CodecDescriptorRegistry =
+  buildCodecDescriptorRegistry(codecDescriptors);

package/src/exports/column-types.ts

@@ -1,16 +1,14 @@
 /**
  * Column type descriptors for pgvector extension.
  *
- * 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.
+ * 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';
+import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 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.
+ * Static vector column descriptor without dimension. Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
  */
 export const vectorColumn = {
   codecId: VECTOR_CODEC_ID,
@@ -25,7 +23,6 @@ export const vectorColumn = {
  * .column('embedding', { type: vector(1536), nullable: false })
  * // Produces: nativeType: 'vector', 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]

package/src/exports/runtime.ts

@@ -1,63 +1,6 @@
-import type { Codec, CodecInstanceContext } from '@prisma-next/framework-components/codec';
-import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
-import type {
-  RuntimeParameterizedCodecDescriptor,
-  SqlRuntimeExtensionDescriptor,
-} 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 type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';
 import { pgvectorPackMeta, pgvectorQueryOperations } 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;
-});
-
-// pgvector's encode is parameter-independent (the wire format `[v1,v2,...]`
-// doesn't care about declared length), so the resolved codec for every
-// `(length)` instance is the same shared codec object today. The factory
-// returns it directly; `ctx` is unused. When a future refactor wants per-
-// instance state (e.g. capping wire length to declared dimension), the
-// closure over `params` is the place to add it.
-//
-// The factory parameter types as the family-agnostic
-// `CodecInstanceContext` because pgvector doesn't read the SQL-specific
-// `usedAt` field. The SQL runtime materializer passes a
-// `SqlCodecInstanceContext`; family-agnostic factories are structurally
-// compatible with the SQL extended type.
-const sharedVectorCodec: Codec = codecDefinitions.vector.codec;
-const vectorFactory = (_params: { readonly length: number }) => (_ctx: CodecInstanceContext) =>
-  sharedVectorCodec;
-
-const parameterizedCodecDescriptors = [
-  {
-    codecId: VECTOR_CODEC_ID,
-    traits: ['equality'] as const,
-    targetTypes: ['vector'] as const,
-    paramsSchema: vectorParamsSchema,
-    renderOutputType: (params: { readonly length: number }) => `Vector<${params.length}>`,
-    factory: vectorFactory,
-  },
-] as const satisfies ReadonlyArray<
-  RuntimeParameterizedCodecDescriptor<{ readonly length: number }>
->;
-
-function createPgvectorCodecRegistry() {
-  const registry = createCodecRegistry();
-  for (const def of Object.values(codecDefinitions)) {
-    registry.register(def.codec);
-  }
-  return registry;
-}
+import { pgvectorCodecRegistry } from '../core/registry';
 
 const pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
   kind: 'extension' as const,
@@ -65,20 +8,14 @@ const pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
   version: pgvectorPackMeta.version,
   familyId: 'sql' as const,
   targetId: 'postgres' as const,
-  // Mirror `pgvectorPackMeta.types.codecTypes.codecInstances` here so that
-  // runtime-plane assemblers driven by `extractCodecLookup` (which reads
-  // `descriptor.types?.codecTypes?.codecInstances`) discover `pg/vector@1`.
-  // Without this, the Postgres adapter's runtime-plane codec lookup misses
-  // the vector codec and `$N::vector` would silently disappear once the
-  // renderer switches to lookup-driven cast policy.
+  // Expose the unified descriptor list so `extractCodecLookup` reads `targetTypes` / `meta` / `renderOutputType` directly off the descriptors and materializes the representative `Codec` for the SQL renderer's cast-policy lookup.
   types: {
     codecTypes: {
-      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
+      codecDescriptors: Array.from(pgvectorCodecRegistry.values()),
     },
   },
-  codecs: createPgvectorCodecRegistry,
+  codecs: () => Array.from(pgvectorCodecRegistry.values()),
   queryOperations: () => pgvectorQueryOperations(),
-  parameterizedCodecs: () => parameterizedCodecDescriptors,
   create() {
     return {
       familyId: 'sql' as const,
@@ -87,4 +24,5 @@ const pgvectorRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
   },
 };
 
+export { pgvectorCodecRegistry };
 export default pgvectorRuntimeDescriptor;

package/dist/codec-types-BifaP625.d.mts

@@ -1,27 +0,0 @@
-import * as _prisma_next_sql_relational_core_ast0 from "@prisma-next/sql-relational-core/ast";
-
-//#region src/core/codecs.d.ts
-
-/**
- * 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_ast0.CodecDefBuilder<{} & Record<"vector", _prisma_next_sql_relational_core_ast0.Codec<"pg/vector@1", readonly ["equality"], string, number[], Record<string, unknown>, unknown>>>;
-type CodecTypes$1 = typeof codecs.CodecTypes;
-//#endregion
-//#region src/types/codec-types.d.ts
-/**
- * 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>).
- */
-type Vector<N extends number = number> = number[] & {
-  readonly __vectorLength?: N;
-};
-type CodecTypes = CodecTypes$1;
-//#endregion
-export { Vector as n, CodecTypes as t };
-//# sourceMappingURL=codec-types-BifaP625.d.mts.map

package/dist/codec-types-BifaP625.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-types-BifaP625.d.mts","names":[],"sources":["../src/core/codecs.ts","../src/types/codec-types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAqEY;;;cAAN,MAAM,EAAA,qCAAA,CAAA,eAAA,CAAA,CAAA,CAAA,GAAA,MAAA,CAAA,QAAA,EAAA,qCAAA,CAAA,KAAA,CAAA,aAAA,EAAA,SAAA,CAAA,UAAA,CAAA,EAAA,MAAA,EAAA,MAAA,EAAA,EAAA,MAAA,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,OAAA,CAAA,CAAA,CAAA;KAOA,YAAA,UAAoB,MAAA,CAAO;;;AAAvC;;;;AC3DA;AAEA;KAFY;4BAA2E;;KAE3E,UAAA,GAAa"}

package/dist/descriptor-meta-DTopW_37.mjs

@@ -1,147 +0,0 @@
-import { n as VECTOR_MAX_DIM } from "./constants-Co5golCK.mjs";
-import { buildOperation, toExpr } from "@prisma-next/sql-relational-core/expression";
-import { codec, defineCodecs } from "@prisma-next/sql-relational-core/ast";
-
-//#region src/core/authoring.ts
-const pgvectorAuthoringTypes = { pgvector: { Vector: {
-	kind: "typeConstructor",
-	args: [{
-		kind: "number",
-		name: "length",
-		integer: true,
-		minimum: 1,
-		maximum: VECTOR_MAX_DIM
-	}],
-	output: {
-		codecId: "pg/vector@1",
-		nativeType: "vector",
-		typeParams: { length: {
-			kind: "arg",
-			index: 0
-		} }
-	}
-} } };
-
-//#endregion
-//#region src/core/codecs.ts
-/**
-* 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).
-*/
-const pgVectorCodec = codec({
-	typeId: "pg/vector@1",
-	targetTypes: ["vector"],
-	traits: ["equality"],
-	renderOutputType: (typeParams) => {
-		const length = typeParams["length"];
-		if (length === void 0) return void 0;
-		if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected positive integer "length" in typeParams for Vector, got ${String(length)}`);
-		return `Vector<${length}>`;
-	},
-	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 [];
-		return 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;
-		});
-	},
-	meta: { db: { sql: { postgres: { nativeType: "vector" } } } }
-});
-const codecs = defineCodecs().add("vector", pgVectorCodec);
-const codecDefinitions = codecs.codecDefinitions;
-const dataTypes = codecs.dataTypes;
-
-//#endregion
-//#region src/core/descriptor-meta.ts
-const pgvectorTypeId = "pg/vector@1";
-function pgvectorQueryOperations() {
-	return [{
-		method: "cosineDistance",
-		self: { codecId: pgvectorTypeId },
-		impl: (self, other) => buildOperation({
-			method: "cosineDistance",
-			args: [toExpr(self, pgvectorTypeId), toExpr(other, pgvectorTypeId)],
-			returns: {
-				codecId: "pg/float8@1",
-				nullable: false
-			},
-			lowering: {
-				targetFamily: "sql",
-				strategy: "function",
-				template: "{{self}} <=> {{arg0}}"
-			}
-		})
-	}, {
-		method: "cosineSimilarity",
-		self: { codecId: pgvectorTypeId },
-		impl: (self, other) => buildOperation({
-			method: "cosineSimilarity",
-			args: [toExpr(self, pgvectorTypeId), toExpr(other, pgvectorTypeId)],
-			returns: {
-				codecId: "pg/float8@1",
-				nullable: false
-			},
-			lowering: {
-				targetFamily: "sql",
-				strategy: "function",
-				template: "1 - ({{self}} <=> {{arg0}})"
-			}
-		})
-	}];
-}
-const pgvectorPackMetaBase = {
-	kind: "extension",
-	id: "pgvector",
-	familyId: "sql",
-	targetId: "postgres",
-	version: "0.0.1",
-	capabilities: { postgres: { "pgvector.cosine": true } },
-	authoring: { type: pgvectorAuthoringTypes },
-	types: {
-		codecTypes: {
-			codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
-			import: {
-				package: "@prisma-next/extension-pgvector/codec-types",
-				named: "CodecTypes",
-				alias: "PgVectorTypes"
-			},
-			typeImports: [{
-				package: "@prisma-next/extension-pgvector/codec-types",
-				named: "Vector",
-				alias: "Vector"
-			}]
-		},
-		operationTypes: { import: {
-			package: "@prisma-next/extension-pgvector/operation-types",
-			named: "OperationTypes",
-			alias: "PgVectorOperationTypes"
-		} },
-		queryOperationTypes: { import: {
-			package: "@prisma-next/extension-pgvector/operation-types",
-			named: "QueryOperationTypes",
-			alias: "PgVectorQueryOperationTypes"
-		} },
-		storage: [{
-			typeId: pgvectorTypeId,
-			familyId: "sql",
-			targetId: "postgres",
-			nativeType: "vector"
-		}]
-	}
-};
-const pgvectorPackMeta = pgvectorPackMetaBase;
-
-//#endregion
-export { pgvectorQueryOperations as n, codecDefinitions as r, pgvectorPackMeta as t };
-//# sourceMappingURL=descriptor-meta-DTopW_37.mjs.map

package/dist/descriptor-meta-DTopW_37.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-DTopW_37.mjs","names":["pgvectorPackMeta: typeof pgvectorPackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n}"],"sources":["../src/core/authoring.ts","../src/core/codecs.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';\nimport { VECTOR_MAX_DIM } from './constants';\n\nexport const pgvectorAuthoringTypes = {\n  pgvector: {\n    Vector: {\n      kind: 'typeConstructor',\n      args: [\n        { kind: 'number', name: 'length', integer: true, minimum: 1, maximum: VECTOR_MAX_DIM },\n      ],\n      output: {\n        codecId: 'pg/vector@1',\n        nativeType: 'vector',\n        typeParams: {\n          length: { kind: 'arg', index: 0 },\n        },\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\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({\n  typeId: 'pg/vector@1',\n  targetTypes: ['vector'],\n  traits: ['equality'],\n  renderOutputType: (typeParams) => {\n    const length = typeParams['length'];\n    if (length === undefined) return undefined;\n    if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {\n      throw new Error(\n        `renderOutputType: expected positive integer \"length\" in typeParams for Vector, got ${String(length)}`,\n      );\n    }\n    return `Vector<${length}>`;\n  },\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","import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';\nimport {\n  buildOperation,\n  type CodecExpression,\n  type Expression,\n  toExpr,\n} from '@prisma-next/sql-relational-core/expression';\nimport type { CodecTypes } from '../types/codec-types';\nimport { pgvectorAuthoringTypes } from './authoring';\nimport { codecDefinitions } from './codecs';\n\nconst pgvectorTypeId = 'pg/vector@1' as const;\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\nexport function pgvectorQueryOperations<\n  CT extends CodecTypesBase,\n>(): readonly SqlOperationDescriptor[] {\n  return [\n    {\n      method: 'cosineDistance',\n      self: { codecId: pgvectorTypeId },\n      impl: (\n        self: CodecExpression<'pg/vector@1', boolean, CT>,\n        other: CodecExpression<'pg/vector@1', boolean, CT>,\n      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> =>\n        buildOperation({\n          method: 'cosineDistance',\n          args: [toExpr(self, pgvectorTypeId), toExpr(other, pgvectorTypeId)],\n          returns: { codecId: 'pg/float8@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} <=> {{arg0}}',\n          },\n        }),\n    },\n    {\n      method: 'cosineSimilarity',\n      self: { codecId: pgvectorTypeId },\n      impl: (\n        self: CodecExpression<'pg/vector@1', boolean, CT>,\n        other: CodecExpression<'pg/vector@1', boolean, CT>,\n      ): Expression<{ codecId: 'pg/float8@1'; nullable: false }> =>\n        buildOperation({\n          method: 'cosineSimilarity',\n          args: [toExpr(self, pgvectorTypeId), toExpr(other, pgvectorTypeId)],\n          returns: { codecId: 'pg/float8@1', nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '1 - ({{self}} <=> {{arg0}})',\n          },\n        }),\n    },\n  ];\n}\n\nconst pgvectorPackMetaBase = {\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  authoring: {\n    type: pgvectorAuthoringTypes,\n  },\n  types: {\n    codecTypes: {\n      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),\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    },\n    operationTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/operation-types',\n        named: 'OperationTypes',\n        alias: 'PgVectorOperationTypes',\n      },\n    },\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/extension-pgvector/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'PgVectorQueryOperationTypes',\n      },\n    },\n    storage: [\n      { typeId: pgvectorTypeId, familyId: 'sql', targetId: 'postgres', nativeType: 'vector' },\n    ],\n  },\n} as const;\n\nexport const pgvectorPackMeta: typeof pgvectorPackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = pgvectorPackMetaBase;\n"],"mappings":"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"}