@prisma-next/extension-pgvector 0.5.0-dev.9 → 0.5.0

package/README.md

@@ -69,7 +69,7 @@ Add vector columns to your contract and enable the namespace via pack refs:
 import { int4Column, textColumn } from '@prisma-next/adapter-postgres/column-types';
 import sqlFamily from '@prisma-next/family-sql/pack';
 import { defineContract, field, model } from '@prisma-next/sql-contract-ts/contract-builder';
-import { vectorColumn } from '@prisma-next/extension-pgvector/column-types';
+import { vector, vectorColumn } from '@prisma-next/extension-pgvector/column-types';
 import pgvector from '@prisma-next/extension-pgvector/pack';
 import postgres from '@prisma-next/target-postgres/pack';
 
@@ -82,13 +82,16 @@ export const contract = defineContract({
       fields: {
         id: field.column(int4Column).id(),
         title: field.column(textColumn),
-        embedding: field.column(vectorColumn).optional(),
+        // Dimensioned vector — `field.embedding` resolves to `Vector<1536>`.
+        embedding: field.column(vector(1536)).optional(),
       },
     }).sql({ table: 'post' }),
   },
 });
 ```
 
+The `vector(N)` factory is registered through the unified `CodecDescriptor<{ length: number }>` shape — `paramsSchema` validates the dimension at the contract boundary, `renderOutputType: ({ length }) => 'Vector<' + length + '>'` produces the column's TS type for `contract.d.ts`, and the curried `factory` materializes the runtime codec at context construction. See [ADR 208 — Higher-order codecs for parameterized types](../../../docs/architecture%20docs/adrs/ADR%20208%20-%20Higher-order%20codecs%20for%20parameterized%20types.md) for the descriptor model. For undimensioned vector columns (rare; typically only valid in legacy schemas where `vector` was declared without a dimension), use `vectorColumn` instead.
+
 ### Runtime Setup
 
 Register the extension when creating your execution stack:

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

@@ -0,0 +1,63 @@
+import { JsonValue } from "@prisma-next/contract/types";
+import { AnyCodecDescriptor, CodecCallContext, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
+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-yMSpEJJM.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-yMSpEJJM.d.mts","names":[],"sources":["../src/core/constants.ts","../src/core/codecs.ts","../src/types/codec-types.ts"],"mappings":";;;;;;;;;cAGa,eAAA;;;KCyBR,YAAA;EAAA,SAA0B,MAAA;AAAA;AAAA,cAiBlB,aAAA,SAAsB,SAAA,QAC1B,eAAA;EAAA,SAKE,MAAA;cAEG,UAAA,EAAY,kBAAA,EAAoB,MAAA;EAK5C,YAAA,CAAa,KAAA,oBAAyB,KAAA;EAYhC,MAAA,CAAO,KAAA,YAAiB,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAKjD,MAAA,CAAO,IAAA,UAAc,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAsBpD,UAAA,CAAW,KAAA,aAAkB,SAAA;EAK7B,UAAA,CAAW,IAAA,EAAM,SAAA;AAAA;AAAA,cAMN,kBAAA,SAA2B,mBAAA,CAAoB,YAAA;EAAA,SACxC,OAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,IAAA;IAAA;;;;;;;;WACA,YAAA,EAAc,gBAAA,CAAiB,YAAA;EACxC,gBAAA,CAAiB,MAAA,EAAQ,YAAA;EA5C5B;;;EAkDG,OAAA,CAAQ,MAAA,EAAQ,YAAA,IAAgB,GAAA,EAAK,oBAAA,KAAyB,aAAA;AAAA;AAAA,cAkBnE,kBAAA;EAAA,iBAEI,kBAAA;AAAA;AAAA,KAEE,YAAA,GAAa,iBAAA,QAAyB,kBAAA;;;;;;;;AApHY;KCTlD,MAAA;EAAA,SAA0D,cAAA,GAAiB,CAAA;AAAA;AAAA,KAE3E,UAAA,GAAa,YAAA"}

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-yMSpEJJM.mjs";
 export { type CodecTypes, type Vector };

package/dist/codec-types.mjs

@@ -1 +1 @@
-export {  };
+export {};

package/dist/column-types.d.mts

@@ -1,10 +1,8 @@
-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 +16,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"],"mappings":";;;;;AA6BA;cAjBa,YAAA;EAAA,SAG4B,OAAA;EAAA,SAAA,UAAA;AAAA;;;;;;;;;;;;;iBAczB,MAAA,kBAAA,CACd,MAAA,EAAQ,CAAA,GACP,oBAAA;EAAA,SAAkC,UAAA;IAAA,SAAuB,MAAA,EAAQ,CAAA;EAAA;AAAA"}

package/dist/column-types.mjs

@@ -1,9 +1,7 @@
-import { n as VECTOR_MAX_DIM, t as VECTOR_CODEC_ID } from "./constants-Co5golCK.mjs";
-
+import { n as VECTOR_MAX_DIM, t as VECTOR_CODEC_ID } from "./constants-DX-00vYk.mjs";
 //#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,20 +15,19 @@ 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]
 */
 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}`);
+	if (!Number.isInteger(length) || length < 1 || length > 16e3) throw new RangeError(`pgvector: dimension must be an integer in [1, ${VECTOR_MAX_DIM}], got ${length}`);
 	return {
 		codecId: VECTOR_CODEC_ID,
 		nativeType: "vector",
 		typeParams: { length }
 	};
 }
-
 //#endregion
 export { vector, vectorColumn };
+
 //# sourceMappingURL=column-types.mjs.map

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;CACxE,IAAI,CAAC,OAAO,UAAU,OAAO,IAAI,SAAS,KAAK,SAAA,MAC7C,MAAM,IAAI,WACR,iDAAiD,eAAe,SAAS,SAC1E;CAEH,OAAO;EACL,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,QAAQ;EACvB"}

package/dist/{constants-Co5golCK.mjs → constants-DX-00vYk.mjs}

@@ -7,7 +7,7 @@ const VECTOR_CODEC_ID = "pg/vector@1";
 * Maximum dimension for pgvector vectors (VECTOR_MAX_DIM from pgvector).
 */
 const VECTOR_MAX_DIM = 16e3;
-
 //#endregion
 export { VECTOR_MAX_DIM as n, VECTOR_CODEC_ID as t };
-//# sourceMappingURL=constants-Co5golCK.mjs.map
+
+//# sourceMappingURL=constants-DX-00vYk.mjs.map

package/dist/{constants-Co5golCK.mjs.map → constants-DX-00vYk.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"constants-Co5golCK.mjs","names":[],"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":";;;;AAGA,MAAa,kBAAkB;;;;AAK/B,MAAa,iBAAiB"}
+{"version":3,"file":"constants-DX-00vYk.mjs","names":[],"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":";;;;AAGA,MAAa,kBAAkB;;;;AAK/B,MAAa,iBAAiB"}

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;cAkEM,6BAA6B"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;;cA+DM,2BAAA,EAA6B,6BAAA"}

package/dist/control.mjs

@@ -1,5 +1,170 @@
-import { n as pgvectorQueryOperations, t as pgvectorPackMeta } from "./descriptor-meta-BQbvJJxu.mjs";
-
+import { t as VECTOR_CODEC_ID } from "./constants-DX-00vYk.mjs";
+import { n as pgvectorQueryOperations, t as pgvectorPackMeta } from "./descriptor-meta-DEgJjLLi.mjs";
+import { computeStorageHash } from "@prisma-next/contract/hashing";
+import { coreHash, profileHash } from "@prisma-next/contract/types";
+import { computeMigrationHash } from "@prisma-next/migration-tools/hash";
+//#region src/core/contract-space-constants.ts
+/**
+* Static names and identifiers used across pgvector's contract space.
+*
+* Centralised here so the contract IR (`./contract`), the baseline
+* migration ops (`./migrations`), the head ref, and the descriptor
+* (`../exports/control`) all reference the same values without typos.
+*
+* The space identifier `'pgvector'` is what the framework writes to
+* `migrations/pgvector/` in the user's repo and what the marker table's
+* `space` column carries for pgvector-owned rows.
+*
+* The `pgvector:*` invariantId namespace is locked here — once
+* published, an invariantId is immutable so downstream consumers can
+* reference it by literal string match.
+*/
+const PGVECTOR_SPACE_ID = "pgvector";
+const PGVECTOR_NATIVE_TYPE = "vector";
+const PGVECTOR_BASELINE_MIGRATION_NAME = "20260601T0000_install_vector_extension";
+/**
+* `pgvector:*` invariantIds emitted by the baseline migration. Each id,
+* once published, is immutable: downstream consumers (other extensions,
+* the marker table) reference them by literal string match.
+*/
+const PGVECTOR_INVARIANTS = { installVector: "pgvector:install-vector-v1" };
+//#endregion
+//#region src/core/contract.ts
+/**
+* pgvector contract space — declares the parameterised native type
+* `vector(N)` that user columns can name as `nativeType`.
+*
+* Unlike CipherStash's typed objects (composite types / domains / enums
+* — deferred behind `meta.cipherstashFutureIR` until the IR vocabulary
+* gains first-class support), pgvector's `vector` is a parameterised
+* native type and *is* representable in today's IR via
+* {@link StorageTypeInstance}: `{ codecId, nativeType, typeParams }`.
+* The contract registers a representative instance under
+* `storage.types.vector` so the verifier sees the type as part of
+* pgvector's space contribution and so the pinned `contract.json` on
+* disk is materially distinct from an empty space.
+*
+* Per-column instances on the user's side carry concrete
+* `typeParams.length` (e.g. `vector(1536)`); the registration here
+* declares the parameterised shape — it is not consumed as a literal
+* column type by any user table.
+*/
+const TARGET = "postgres";
+const TARGET_FAMILY = "sql";
+/**
+* Storage body for the contract — pgvector ships no tables of its own;
+* the `vector` parameterised native type is registered under
+* `storage.types` so pgvector's IR contribution is non-empty and the
+* pinned `contract.json` on disk differs materially from an empty
+* extension space.
+*
+* Authored without `storageHash` here so {@link computeStorageHash} can
+* digest the canonical body (the hashing pipeline panics if asked to
+* hash an object that already carries its own output — see
+* `assertDescriptorSelfConsistency`'s storage-hash strip).
+*/
+const storageBody = {
+	tables: {},
+	types: { [PGVECTOR_NATIVE_TYPE]: {
+		codecId: VECTOR_CODEC_ID,
+		nativeType: PGVECTOR_NATIVE_TYPE,
+		typeParams: {}
+	} }
+};
+/** Content-addressed hash of pgvector's storage IR. */
+const PGVECTOR_STORAGE_HASH = computeStorageHash({
+	target: TARGET,
+	targetFamily: TARGET_FAMILY,
+	storage: storageBody
+});
+/** pgvector's contract value, exposed via the descriptor's `contractSpace.contractJson`. */
+const pgvectorContract = {
+	target: TARGET,
+	targetFamily: TARGET_FAMILY,
+	roots: {},
+	models: {},
+	capabilities: {},
+	extensionPacks: {},
+	meta: {},
+	profileHash: profileHash("pgvector-extension-profile-v1"),
+	storage: {
+		...storageBody,
+		storageHash: coreHash(PGVECTOR_STORAGE_HASH)
+	}
+};
+//#endregion
+//#region src/core/migrations.ts
+const pgvectorBaselineOps = [{
+	id: "pgvector.install-vector-extension",
+	label: "Enable extension \"vector\"",
+	operationClass: "additive",
+	invariantId: PGVECTOR_INVARIANTS.installVector,
+	target: {
+		id: "postgres",
+		details: {
+			schema: "public",
+			objectType: "extension",
+			name: "vector"
+		}
+	},
+	precheck: [{
+		description: "verify extension \"vector\" is not already enabled",
+		sql: "SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')"
+	}],
+	execute: [{
+		description: "create extension \"vector\"",
+		sql: "CREATE EXTENSION IF NOT EXISTS vector"
+	}],
+	postcheck: [{
+		description: "confirm extension \"vector\" is enabled",
+		sql: "SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')"
+	}]
+}];
+/** Sorted list of invariantIds the baseline migration provides. */
+const PGVECTOR_BASELINE_INVARIANTS = (() => {
+	const ids = pgvectorBaselineOps.map((op) => op.invariantId).filter((id) => typeof id === "string");
+	return [...new Set(ids)].sort();
+})();
+const baselineMetadataWithoutHash = {
+	from: null,
+	to: PGVECTOR_STORAGE_HASH,
+	fromContract: null,
+	toContract: pgvectorContract,
+	hints: {
+		used: [],
+		applied: [],
+		plannerVersion: "2.0.0"
+	},
+	labels: [],
+	providedInvariants: PGVECTOR_BASELINE_INVARIANTS,
+	createdAt: "2026-06-01T00:00:00.000Z"
+};
+/**
+* Baseline migration package the descriptor publishes via
+* `contractSpace.migrations`. The framework's emitter writes this to
+* `migrations/pgvector/<dirName>/{manifest,ops,contract}.json` in the
+* user's repo at `migrate` time.
+*/
+const pgvectorBaselineMigration = {
+	dirName: PGVECTOR_BASELINE_MIGRATION_NAME,
+	metadata: {
+		...baselineMetadataWithoutHash,
+		migrationHash: computeMigrationHash(baselineMetadataWithoutHash, pgvectorBaselineOps)
+	},
+	ops: pgvectorBaselineOps
+};
+/**
+* Pinned head ref the descriptor publishes. The framework writes this
+* verbatim to `migrations/pgvector/refs/head.json` (with `invariants`
+* sorted alphabetically per the canonicalisation rules); the runner's
+* `findPathWithDecision` step consults `head.json` to decide which
+* migrations need to apply.
+*/
+const pgvectorHeadRef = {
+	hash: PGVECTOR_STORAGE_HASH,
+	invariants: PGVECTOR_BASELINE_INVARIANTS
+};
+//#endregion
 //#region src/exports/control.ts
 const PGVECTOR_CODEC_ID = "pg/vector@1";
 function buildVectorIdentityValue(typeParams) {
@@ -15,31 +180,15 @@ const vectorControlPlaneHooks = {
 	},
 	resolveIdentityValue: ({ typeParams }) => buildVectorIdentityValue(typeParams)
 };
-const pgvectorDatabaseDependencies = { init: [{
-	id: "postgres.extension.vector",
-	label: "Enable vector extension",
-	install: [{
-		id: "extension.vector",
-		label: "Enable extension \"vector\"",
-		summary: "Ensures the vector extension is available for pgvector operations",
-		operationClass: "additive",
-		target: { id: "postgres" },
-		precheck: [{
-			description: "verify extension \"vector\" is not already enabled",
-			sql: "SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')"
-		}],
-		execute: [{
-			description: "create extension \"vector\"",
-			sql: "CREATE EXTENSION IF NOT EXISTS vector"
-		}],
-		postcheck: [{
-			description: "confirm extension \"vector\" is enabled",
-			sql: "SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')"
-		}]
-	}]
-}] };
+const pgvectorContractSpace = {
+	contractJson: pgvectorContract,
+	migrations: [pgvectorBaselineMigration],
+	headRef: pgvectorHeadRef
+};
 const pgvectorExtensionDescriptor = {
 	...pgvectorPackMeta,
+	id: PGVECTOR_SPACE_ID,
+	contractSpace: pgvectorContractSpace,
 	types: {
 		...pgvectorPackMeta.types,
 		codecTypes: {
@@ -47,15 +196,13 @@ const pgvectorExtensionDescriptor = {
 			controlPlaneHooks: { [PGVECTOR_CODEC_ID]: vectorControlPlaneHooks }
 		}
 	},
-	queryOperations: () => pgvectorQueryOperations,
-	databaseDependencies: pgvectorDatabaseDependencies,
+	queryOperations: () => pgvectorQueryOperations(),
 	create: () => ({
 		familyId: "sql",
 		targetId: "postgres"
 	})
 };
-var control_default = pgvectorExtensionDescriptor;
-
 //#endregion
-export { control_default as default, pgvectorExtensionDescriptor };
+export { pgvectorExtensionDescriptor as default, pgvectorExtensionDescriptor };
+
 //# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"control.mjs","names":["vectorControlPlaneHooks: CodecControlHooks","pgvectorDatabaseDependencies: ComponentDatabaseDependencies<unknown>","pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'>"],"sources":["../src/exports/control.ts"],"sourcesContent":["import type {\n  CodecControlHooks,\n  ComponentDatabaseDependencies,\n  SqlControlExtensionDescriptor,\n} from '@prisma-next/family-sql/control';\nimport { pgvectorPackMeta, pgvectorQueryOperations } from '../core/descriptor-meta';\n\nconst PGVECTOR_CODEC_ID = 'pg/vector@1' as const;\n\nfunction buildVectorIdentityValue(typeParams: Record<string, unknown> | undefined): string | null {\n  const length = typeParams?.['length'];\n  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {\n    return null;\n  }\n\n  const zeroVector = `[${new Array(length).fill('0').join(',')}]`;\n  return `'${zeroVector}'::vector`;\n}\n\nconst vectorControlPlaneHooks: CodecControlHooks = {\n  expandNativeType: ({ nativeType, typeParams }) => {\n    const length = typeParams?.['length'];\n    if (typeof length === 'number' && Number.isInteger(length) && length > 0) {\n      return `${nativeType}(${length})`;\n    }\n    return nativeType;\n  },\n  resolveIdentityValue: ({ typeParams }) => buildVectorIdentityValue(typeParams),\n};\n\nconst pgvectorDatabaseDependencies: ComponentDatabaseDependencies<unknown> = {\n  init: [\n    {\n      id: 'postgres.extension.vector',\n      label: 'Enable vector extension',\n      install: [\n        {\n          id: 'extension.vector',\n          label: 'Enable extension \"vector\"',\n          summary: 'Ensures the vector extension is available for pgvector operations',\n          operationClass: 'additive',\n          target: { id: 'postgres' },\n          precheck: [\n            {\n              description: 'verify extension \"vector\" is not already enabled',\n              sql: \"SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')\",\n            },\n          ],\n          execute: [\n            {\n              description: 'create extension \"vector\"',\n              sql: 'CREATE EXTENSION IF NOT EXISTS vector',\n            },\n          ],\n          postcheck: [\n            {\n              description: 'confirm extension \"vector\" is enabled',\n              sql: \"SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')\",\n            },\n          ],\n        },\n      ],\n    },\n  ],\n};\n\nconst pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {\n  ...pgvectorPackMeta,\n  types: {\n    ...pgvectorPackMeta.types,\n    codecTypes: {\n      ...pgvectorPackMeta.types.codecTypes,\n      controlPlaneHooks: {\n        [PGVECTOR_CODEC_ID]: vectorControlPlaneHooks,\n      },\n    },\n  },\n  queryOperations: () => pgvectorQueryOperations,\n  databaseDependencies: pgvectorDatabaseDependencies,\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n};\n\nexport { pgvectorExtensionDescriptor };\nexport default pgvectorExtensionDescriptor;\n"],"mappings":";;;AAOA,MAAM,oBAAoB;AAE1B,SAAS,yBAAyB,YAAgE;CAChG,MAAM,SAAS,aAAa;AAC5B,KAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,EACvE,QAAO;AAIT,QAAO,IADY,IAAI,IAAI,MAAM,OAAO,CAAC,KAAK,IAAI,CAAC,KAAK,IAAI,CAAC,GACvC;;AAGxB,MAAMA,0BAA6C;CACjD,mBAAmB,EAAE,YAAY,iBAAiB;EAChD,MAAM,SAAS,aAAa;AAC5B,MAAI,OAAO,WAAW,YAAY,OAAO,UAAU,OAAO,IAAI,SAAS,EACrE,QAAO,GAAG,WAAW,GAAG,OAAO;AAEjC,SAAO;;CAET,uBAAuB,EAAE,iBAAiB,yBAAyB,WAAW;CAC/E;AAED,MAAMC,+BAAuE,EAC3E,MAAM,CACJ;CACE,IAAI;CACJ,OAAO;CACP,SAAS,CACP;EACE,IAAI;EACJ,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,QAAQ,EAAE,IAAI,YAAY;EAC1B,UAAU,CACR;GACE,aAAa;GACb,KAAK;GACN,CACF;EACD,SAAS,CACP;GACE,aAAa;GACb,KAAK;GACN,CACF;EACD,WAAW,CACT;GACE,aAAa;GACb,KAAK;GACN,CACF;EACF,CACF;CACF,CACF,EACF;AAED,MAAMC,8BAAyE;CAC7E,GAAG;CACH,OAAO;EACL,GAAG,iBAAiB;EACpB,YAAY;GACV,GAAG,iBAAiB,MAAM;GAC1B,mBAAmB,GAChB,oBAAoB,yBACtB;GACF;EACF;CACD,uBAAuB;CACvB,sBAAsB;CACtB,eAAe;EACb,UAAU;EACV,UAAU;EACX;CACF;AAGD,sBAAe"}
+{"version":3,"file":"control.mjs","names":[],"sources":["../src/core/contract-space-constants.ts","../src/core/contract.ts","../src/core/migrations.ts","../src/exports/control.ts"],"sourcesContent":["/**\n * Static names and identifiers used across pgvector's contract space.\n *\n * Centralised here so the contract IR (`./contract`), the baseline\n * migration ops (`./migrations`), the head ref, and the descriptor\n * (`../exports/control`) all reference the same values without typos.\n *\n * The space identifier `'pgvector'` is what the framework writes to\n * `migrations/pgvector/` in the user's repo and what the marker table's\n * `space` column carries for pgvector-owned rows.\n *\n * The `pgvector:*` invariantId namespace is locked here — once\n * published, an invariantId is immutable so downstream consumers can\n * reference it by literal string match.\n */\n\nexport const PGVECTOR_SPACE_ID = 'pgvector' as const;\n\nexport const PGVECTOR_NATIVE_TYPE = 'vector' as const;\n\nexport const PGVECTOR_BASELINE_MIGRATION_NAME = '20260601T0000_install_vector_extension' as const;\n\n/**\n * `pgvector:*` invariantIds emitted by the baseline migration. Each id,\n * once published, is immutable: downstream consumers (other extensions,\n * the marker table) reference them by literal string match.\n */\nexport const PGVECTOR_INVARIANTS = {\n  installVector: 'pgvector:install-vector-v1',\n} as const;\n","/**\n * pgvector contract space — declares the parameterised native type\n * `vector(N)` that user columns can name as `nativeType`.\n *\n * Unlike CipherStash's typed objects (composite types / domains / enums\n * — deferred behind `meta.cipherstashFutureIR` until the IR vocabulary\n * gains first-class support), pgvector's `vector` is a parameterised\n * native type and *is* representable in today's IR via\n * {@link StorageTypeInstance}: `{ codecId, nativeType, typeParams }`.\n * The contract registers a representative instance under\n * `storage.types.vector` so the verifier sees the type as part of\n * pgvector's space contribution and so the pinned `contract.json` on\n * disk is materially distinct from an empty space.\n *\n * Per-column instances on the user's side carry concrete\n * `typeParams.length` (e.g. `vector(1536)`); the registration here\n * declares the parameterised shape — it is not consumed as a literal\n * column type by any user table.\n */\n\nimport { computeStorageHash } from '@prisma-next/contract/hashing';\nimport { type Contract, coreHash, profileHash } from '@prisma-next/contract/types';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { VECTOR_CODEC_ID } from './constants';\nimport { PGVECTOR_NATIVE_TYPE } from './contract-space-constants';\n\nconst TARGET = 'postgres' as const;\nconst TARGET_FAMILY = 'sql' as const;\n\n/**\n * Storage body for the contract — pgvector ships no tables of its own;\n * the `vector` parameterised native type is registered under\n * `storage.types` so pgvector's IR contribution is non-empty and the\n * pinned `contract.json` on disk differs materially from an empty\n * extension space.\n *\n * Authored without `storageHash` here so {@link computeStorageHash} can\n * digest the canonical body (the hashing pipeline panics if asked to\n * hash an object that already carries its own output — see\n * `assertDescriptorSelfConsistency`'s storage-hash strip).\n */\nconst storageBody = {\n  tables: {},\n  types: {\n    [PGVECTOR_NATIVE_TYPE]: {\n      codecId: VECTOR_CODEC_ID,\n      nativeType: PGVECTOR_NATIVE_TYPE,\n      typeParams: {},\n    },\n  },\n};\n\n/** Content-addressed hash of pgvector's storage IR. */\nexport const PGVECTOR_STORAGE_HASH = computeStorageHash({\n  target: TARGET,\n  targetFamily: TARGET_FAMILY,\n  storage: storageBody,\n});\n\n/** pgvector's contract value, exposed via the descriptor's `contractSpace.contractJson`. */\nexport const pgvectorContract: Contract<SqlStorage> = {\n  target: TARGET,\n  targetFamily: TARGET_FAMILY,\n  roots: {},\n  models: {},\n  capabilities: {},\n  extensionPacks: {},\n  meta: {},\n  profileHash: profileHash('pgvector-extension-profile-v1'),\n  storage: {\n    ...storageBody,\n    storageHash: coreHash(PGVECTOR_STORAGE_HASH),\n  },\n};\n","/**\n * pgvector contract space — baseline migration package.\n *\n * An extension's `contractSpace.migrations` is a list of in-memory\n * `MigrationPackage` values whose `ops` carry framework-level\n * `MigrationPlanOperation`s. The SQL family runner reads the additional\n * runtime fields (`target`, `precheck`, `execute`, `postcheck`) at\n * apply time.\n *\n * Ships a single baseline migration whose only op is\n * {@link installVectorExtensionOp} — it carries the\n * `CREATE EXTENSION IF NOT EXISTS vector` DDL plus a postcondition that\n * confirms the extension landed. Mirrors the prior\n * `databaseDependencies.init[0]` shape (precheck / execute / postcheck)\n * but as a `MigrationPackage` op so the framework's per-space runner /\n * verifier can manage it the same way it manages an application's own\n * migrations.\n *\n * The op carries the stable `pgvector:install-vector-v1` invariantId —\n * once published it is immutable.\n */\n\nimport type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';\nimport type {\n  ContractSpaceHeadRef,\n  MigrationPackage,\n  MigrationPlanOperation,\n} from '@prisma-next/framework-components/control';\nimport { computeMigrationHash } from '@prisma-next/migration-tools/hash';\nimport { PGVECTOR_STORAGE_HASH, pgvectorContract } from './contract';\nimport { PGVECTOR_BASELINE_MIGRATION_NAME, PGVECTOR_INVARIANTS } from './contract-space-constants';\n\n/**\n * Postgres-style `target.details` shape the SQL runner consumes when\n * executing extension-space ops. pgvector targets only Postgres;\n * locking the target id here keeps the per-op `target` literal narrow\n * without coupling to the Postgres adapter package's\n * `PostgresPlanTargetDetails`.\n */\ntype PostgresTargetDetails = {\n  readonly schema: string;\n  readonly objectType: 'extension';\n  readonly name: string;\n};\n\nconst installVectorExtensionOp: SqlMigrationPlanOperation<unknown> = {\n  id: 'pgvector.install-vector-extension',\n  label: 'Enable extension \"vector\"',\n  operationClass: 'additive',\n  invariantId: PGVECTOR_INVARIANTS.installVector,\n  target: {\n    id: 'postgres',\n    details: {\n      schema: 'public',\n      objectType: 'extension',\n      name: 'vector',\n    } satisfies PostgresTargetDetails,\n  },\n  precheck: [\n    {\n      description: 'verify extension \"vector\" is not already enabled',\n      sql: \"SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')\",\n    },\n  ],\n  execute: [\n    {\n      description: 'create extension \"vector\"',\n      sql: 'CREATE EXTENSION IF NOT EXISTS vector',\n    },\n  ],\n  postcheck: [\n    {\n      description: 'confirm extension \"vector\" is enabled',\n      sql: \"SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'vector')\",\n    },\n  ],\n};\n\nconst pgvectorBaselineOps: readonly MigrationPlanOperation[] = [installVectorExtensionOp];\n\n/** Sorted list of invariantIds the baseline migration provides. */\nexport const PGVECTOR_BASELINE_INVARIANTS: readonly string[] = (() => {\n  const ids = pgvectorBaselineOps\n    .map((op) => op.invariantId)\n    .filter((id): id is string => typeof id === 'string');\n  return [...new Set(ids)].sort();\n})();\n\nconst baselineMetadataWithoutHash: Omit<MigrationPackage['metadata'], 'migrationHash'> = {\n  from: null,\n  to: PGVECTOR_STORAGE_HASH,\n  fromContract: null,\n  toContract: pgvectorContract,\n  hints: { used: [], applied: [], plannerVersion: '2.0.0' },\n  labels: [],\n  providedInvariants: PGVECTOR_BASELINE_INVARIANTS,\n  createdAt: '2026-06-01T00:00:00.000Z',\n};\n\n/**\n * Baseline migration package the descriptor publishes via\n * `contractSpace.migrations`. The framework's emitter writes this to\n * `migrations/pgvector/<dirName>/{manifest,ops,contract}.json` in the\n * user's repo at `migrate` time.\n */\nexport const pgvectorBaselineMigration: MigrationPackage = {\n  dirName: PGVECTOR_BASELINE_MIGRATION_NAME,\n  metadata: {\n    ...baselineMetadataWithoutHash,\n    migrationHash: computeMigrationHash(baselineMetadataWithoutHash, pgvectorBaselineOps),\n  },\n  ops: pgvectorBaselineOps,\n};\n\n/**\n * Pinned head ref the descriptor publishes. The framework writes this\n * verbatim to `migrations/pgvector/refs/head.json` (with `invariants`\n * sorted alphabetically per the canonicalisation rules); the runner's\n * `findPathWithDecision` step consults `head.json` to decide which\n * migrations need to apply.\n */\nexport const pgvectorHeadRef: ContractSpaceHeadRef = {\n  hash: PGVECTOR_STORAGE_HASH,\n  invariants: PGVECTOR_BASELINE_INVARIANTS,\n};\n","/**\n * Control-plane descriptor for the pgvector extension.\n *\n * Exposes a `contractSpace` so the framework's per-space planner /\n * runner / verifier (project: extension-contract-spaces, M1+M2)\n * manages the pgvector extension's database scaffolding the same way\n * it manages an application's own schema. The descriptor is consumed\n * by the framework only at authoring time (`migrate`); apply / verify\n * paths read the user's repo (`migrations/pgvector/...`) instead — see\n * project spec NFR3 / FR2 / FR10.\n *\n * `databaseDependencies` is intentionally absent — pgvector was\n * migrated off the legacy `databaseDependencies.init` mechanism in M4\n * (project spec FR13). The `CREATE EXTENSION IF NOT EXISTS vector`\n * DDL the legacy entry carried now lives as the body of the\n * `installVectorExtension` op inside the baseline migration package\n * (`../core/migrations.ts`). Presence of `contractSpace` is the\n * shipping-strategy gate: the framework loads the contract space and\n * ignores any `databaseDependencies` block (project plan §\n * \"Shipping Strategy\"). M5 removes the field at the framework level.\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  CodecControlHooks,\n  SqlControlExtensionDescriptor,\n} from '@prisma-next/family-sql/control';\nimport type { ContractSpace } from '@prisma-next/framework-components/control';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { pgvectorContract } from '../core/contract';\nimport { PGVECTOR_SPACE_ID } from '../core/contract-space-constants';\nimport { pgvectorPackMeta, pgvectorQueryOperations } from '../core/descriptor-meta';\nimport { pgvectorBaselineMigration, pgvectorHeadRef } from '../core/migrations';\n\nconst PGVECTOR_CODEC_ID = 'pg/vector@1' as const;\n\nfunction buildVectorIdentityValue(typeParams: Record<string, unknown> | undefined): string | null {\n  const length = typeParams?.['length'];\n  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {\n    return null;\n  }\n\n  const zeroVector = `[${new Array(length).fill('0').join(',')}]`;\n  return `'${zeroVector}'::vector`;\n}\n\nconst vectorControlPlaneHooks: CodecControlHooks = {\n  expandNativeType: ({ nativeType, typeParams }) => {\n    const length = typeParams?.['length'];\n    if (typeof length === 'number' && Number.isInteger(length) && length > 0) {\n      return `${nativeType}(${length})`;\n    }\n    return nativeType;\n  },\n  resolveIdentityValue: ({ typeParams }) => buildVectorIdentityValue(typeParams),\n};\n\nconst pgvectorContractSpace: ContractSpace<Contract<SqlStorage>> = {\n  contractJson: pgvectorContract,\n  migrations: [pgvectorBaselineMigration],\n  headRef: pgvectorHeadRef,\n};\n\nconst pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {\n  ...pgvectorPackMeta,\n  id: PGVECTOR_SPACE_ID,\n  contractSpace: pgvectorContractSpace,\n  types: {\n    ...pgvectorPackMeta.types,\n    codecTypes: {\n      ...pgvectorPackMeta.types.codecTypes,\n      controlPlaneHooks: {\n        [PGVECTOR_CODEC_ID]: vectorControlPlaneHooks,\n      },\n    },\n  },\n  queryOperations: () => pgvectorQueryOperations(),\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n};\n\nexport { pgvectorExtensionDescriptor };\nexport default pgvectorExtensionDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAgBA,MAAa,oBAAoB;AAEjC,MAAa,uBAAuB;AAEpC,MAAa,mCAAmC;;;;;;AAOhD,MAAa,sBAAsB,EACjC,eAAe,8BAChB;;;;;;;;;;;;;;;;;;;;;;ACHD,MAAM,SAAS;AACf,MAAM,gBAAgB;;;;;;;;;;;;;AActB,MAAM,cAAc;CAClB,QAAQ,EAAE;CACV,OAAO,GACJ,uBAAuB;EACtB,SAAS;EACT,YAAY;EACZ,YAAY,EAAE;EACf,EACF;CACF;;AAGD,MAAa,wBAAwB,mBAAmB;CACtD,QAAQ;CACR,cAAc;CACd,SAAS;CACV,CAAC;;AAGF,MAAa,mBAAyC;CACpD,QAAQ;CACR,cAAc;CACd,OAAO,EAAE;CACT,QAAQ,EAAE;CACV,cAAc,EAAE;CAChB,gBAAgB,EAAE;CAClB,MAAM,EAAE;CACR,aAAa,YAAY,gCAAgC;CACzD,SAAS;EACP,GAAG;EACH,aAAa,SAAS,sBAAsB;EAC7C;CACF;;;ACKD,MAAM,sBAAyD,CAAC;CAhC9D,IAAI;CACJ,OAAO;CACP,gBAAgB;CAChB,aAAa,oBAAoB;CACjC,QAAQ;EACN,IAAI;EACJ,SAAS;GACP,QAAQ;GACR,YAAY;GACZ,MAAM;GACP;EACF;CACD,UAAU,CACR;EACE,aAAa;EACb,KAAK;EACN,CACF;CACD,SAAS,CACP;EACE,aAAa;EACb,KAAK;EACN,CACF;CACD,WAAW,CACT;EACE,aAAa;EACb,KAAK;EACN,CACF;CAGqF,CAAC;;AAGzF,MAAa,sCAAyD;CACpE,MAAM,MAAM,oBACT,KAAK,OAAO,GAAG,YAAY,CAC3B,QAAQ,OAAqB,OAAO,OAAO,SAAS;CACvD,OAAO,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,MAAM;IAC7B;AAEJ,MAAM,8BAAmF;CACvF,MAAM;CACN,IAAI;CACJ,cAAc;CACd,YAAY;CACZ,OAAO;EAAE,MAAM,EAAE;EAAE,SAAS,EAAE;EAAE,gBAAgB;EAAS;CACzD,QAAQ,EAAE;CACV,oBAAoB;CACpB,WAAW;CACZ;;;;;;;AAQD,MAAa,4BAA8C;CACzD,SAAS;CACT,UAAU;EACR,GAAG;EACH,eAAe,qBAAqB,6BAA6B,oBAAoB;EACtF;CACD,KAAK;CACN;;;;;;;;AASD,MAAa,kBAAwC;CACnD,MAAM;CACN,YAAY;CACb;;;AC1FD,MAAM,oBAAoB;AAE1B,SAAS,yBAAyB,YAAgE;CAChG,MAAM,SAAS,aAAa;CAC5B,IAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,OAAO,IAAI,UAAU,GACvE,OAAO;CAIT,OAAO,IAAI,IADY,IAAI,MAAM,OAAO,CAAC,KAAK,IAAI,CAAC,KAAK,IAAI,CAAC,GACvC;;AAGxB,MAAM,0BAA6C;CACjD,mBAAmB,EAAE,YAAY,iBAAiB;EAChD,MAAM,SAAS,aAAa;EAC5B,IAAI,OAAO,WAAW,YAAY,OAAO,UAAU,OAAO,IAAI,SAAS,GACrE,OAAO,GAAG,WAAW,GAAG,OAAO;EAEjC,OAAO;;CAET,uBAAuB,EAAE,iBAAiB,yBAAyB,WAAW;CAC/E;AAED,MAAM,wBAA6D;CACjE,cAAc;CACd,YAAY,CAAC,0BAA0B;CACvC,SAAS;CACV;AAED,MAAM,8BAAyE;CAC7E,GAAG;CACH,IAAI;CACJ,eAAe;CACf,OAAO;EACL,GAAG,iBAAiB;EACpB,YAAY;GACV,GAAG,iBAAiB,MAAM;GAC1B,mBAAmB,GAChB,oBAAoB,yBACtB;GACF;EACF;CACD,uBAAuB,yBAAyB;CAChD,eAAe;EACb,UAAU;EACV,UAAU;EACX;CACF"}

package/dist/descriptor-meta-DEgJjLLi.mjs

@@ -0,0 +1,178 @@
+import { n as VECTOR_MAX_DIM, t as VECTOR_CODEC_ID } from "./constants-DX-00vYk.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 > 16e3) 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 codecDescriptorMap = { vector: new PgVectorDescriptor() };
+//#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(Object.values(codecDescriptorMap));
+//#endregion
+//#region src/core/descriptor-meta.ts
+const pgvectorTypeId = "pg/vector@1";
+function pgvectorQueryOperations() {
+	return {
+		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}}"
+					}
+				});
+			}
+		},
+		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 pgvectorPackMeta = {
+	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"
+			}]
+		},
+		queryOperationTypes: { import: {
+			package: "@prisma-next/extension-pgvector/operation-types",
+			named: "QueryOperationTypes",
+			alias: "PgVectorQueryOperationTypes"
+		} },
+		storage: [{
+			typeId: pgvectorTypeId,
+			familyId: "sql",
+			targetId: "postgres",
+			nativeType: "vector"
+		}]
+	}
+};
+//#endregion
+export { pgvectorQueryOperations as n, pgvectorCodecRegistry as r, pgvectorPackMeta as t };
+
+//# sourceMappingURL=descriptor-meta-DEgJjLLi.mjs.map