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

package/README.md

@@ -13,7 +13,7 @@ This extension pack adds support for the `vector` data type and vector similarit
 - **CLI Integration**: Provides extension descriptor for `prisma-next.config.ts` configuration
 - **Runtime Extension**: Registers codecs and operations at runtime for vector column operations
 - **Pack Ref Export**: Ships a pure `/pack` entrypoint for TypeScript contract authoring without runtime filesystem access
-- **Database Dependencies**: Declares the `vector` Postgres extension as a database dependency, which the migration planner emits as a `CREATE EXTENSION IF NOT EXISTS vector` operation and the verifier checks against the schema IR
+- **Baseline Migration**: Ships an on-disk baseline migration in its contract space that installs the `vector` Postgres extension (`CREATE EXTENSION IF NOT EXISTS vector`) when the extension is composed into an application
 
 ## Dependencies
 
@@ -30,15 +30,15 @@ pnpm add @prisma-next/extension-pgvector
 
 ## Database Setup
 
-The pgvector extension declares its database requirements as component-owned database dependencies. When using the `prisma-next db init` command, the migration planner automatically includes a `CREATE EXTENSION IF NOT EXISTS vector` operation.
+The pgvector extension ships an on-disk baseline migration in its contract space; applying that migration installs pgvector with `CREATE EXTENSION IF NOT EXISTS vector`. When the extension is composed into an application via `extensionPacks`, `prisma-next db init` and `prisma-next db update` apply the baseline (and any subsequent migrations) automatically.
 
-For manual database setup, ensure the pgvector extension is installed:
+For manual database setup, the equivalent DDL is:
 
 ```sql
 CREATE EXTENSION IF NOT EXISTS vector;
 ```
 
-The verifier will check for the presence of the `vector` extension in your database schema and report an error if it's missing.
+Ensure the baseline migration (or equivalent DDL) has been applied before running workloads that use vector columns.
 
 ## Configuration
 
@@ -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:
@@ -195,10 +198,24 @@ The extension declares the following capabilities:
 
 - `pgvector.cosine`: Indicates support for cosine distance and similarity operations
 
+## Authoring (maintainers)
+
+The extension's contract + baseline migration are emitted on-disk inside this package using the same pipeline application authors use:
+
+- `pnpm build:contract-space` — runs `prisma-next contract emit` to produce `src/contract.{json,d.ts}` from the TS source at `src/contract.ts`.
+- `pnpm exec prisma-next migration plan --name <slug>` (run from this package directory) — scaffolds a new migration directory under `migrations/<dirName>/` for schema changes that touch tables / models. **Not chained into `pnpm build`**: `migration plan` is non-idempotent (each invocation generates a new timestamped directory), so it runs manually when the contract source changes. Note: pgvector's contract declares only the parameterised `vector` native type under `storage.types` (no tables / models), so the planner currently refuses to scaffold the baseline migration with `PN-CLI-4020 Contract changed but planner produced no operations` (this is **Path B** authoring per [ADR 212](../../../docs/architecture%20docs/adrs/ADR%20212%20-%20Contract%20spaces.md#contract-space-package-layout)). That directory was hand-authored once (Migration subclass + seed `migration.json` preserving the full `toContract`) and `pnpm tsx migrations/<dirName>/migration.ts` re-emits `ops.json` + `migration.json` deterministically. Future migrations that add tables / models can use `migration plan` directly (Path A).
+- `pnpm tsx migrations/<dirName>/migration.ts` (run from this package directory) — re-emits `ops.json` + `migration.json` from the hand-edited subclass. Use `tsx`, not bare `node`, because the Migration subclass imports relative TypeScript siblings which Node's native loader can't resolve without a TS-aware loader.
+- `migrations/refs/head.json` is hand-pinned with the latest migration's `to` hash + `providedInvariants`.
+
+The descriptor at `src/exports/control.ts` then JSON-imports those artefacts and synthesises the framework's `MigrationPackage` shape.
+
+See [ADR 212 — Contract spaces](../../../docs/architecture%20docs/adrs/ADR%20212%20-%20Contract%20spaces.md) ("Contract-space package layout") for the canonical layout and rationale.
+
 ## References
 
 - [pgvector documentation](https://github.com/pgvector/pgvector)
 - [Prisma Next Architecture Overview](../../../docs/Architecture%20Overview.md)
 - [Extension Packs Guide](../../../docs/reference/Extension-Packs-Naming-and-Layout.md)
+- [ADR 212 — Contract spaces](../../../docs/architecture%20docs/adrs/ADR%20212%20-%20Contract%20spaces.md)
 
 Pack refs (`@prisma-next/extension-pgvector/pack`) are pure data objects generated from the hydrated manifest (`src/core/manifest.ts`), so TypeScript contract builders can enable the pgvector namespace in both emit and no-emit workflows without touching the filesystem.

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

@@ -0,0 +1,63 @@
+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-CQubO6uQ.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-CQubO6uQ.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-CQubO6uQ.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":";;;cAsFM,2BAAA,EAA6B,6BAAA"}

package/dist/control.mjs

@@ -1,7 +1,154 @@
-import { n as pgvectorQueryOperations, t as pgvectorPackMeta } from "./descriptor-meta-BQbvJJxu.mjs";
-
+import { n as pgvectorQueryOperations, t as pgvectorPackMeta } from "./descriptor-meta-DEgJjLLi.mjs";
+import { contractSpaceFromJson } from "@prisma-next/migration-tools/spaces";
+//#region migrations/20260601T0000_install_vector_extension/migration.json
+var migration_default = {
+	from: null,
+	to: "sha256:382dae5bb1548e62cbc449530ea08a9ce0a0dbb280401e9588642223f33783ae",
+	labels: [],
+	providedInvariants: ["pgvector:install-vector-v1"],
+	createdAt: "2026-06-01T00:00:00.000Z",
+	fromContract: null,
+	toContract: {
+		"schemaVersion": "1",
+		"targetFamily": "sql",
+		"target": "postgres",
+		"profileHash": "sha256:1a8dbe044289f30a1de958fe800cc5a8378b285d2e126a8c44b58864bac2c18e",
+		"roots": {},
+		"models": {},
+		"storage": {
+			"storageHash": "sha256:382dae5bb1548e62cbc449530ea08a9ce0a0dbb280401e9588642223f33783ae",
+			"tables": {},
+			"types": { "vector": {
+				"codecId": "pg/vector@1",
+				"nativeType": "vector",
+				"typeParams": {}
+			} }
+		},
+		"capabilities": {
+			"postgres": {
+				"jsonAgg": true,
+				"lateral": true,
+				"limit": true,
+				"orderBy": true,
+				"returning": true
+			},
+			"sql": {
+				"defaultInInsert": true,
+				"enums": true,
+				"returning": true
+			}
+		},
+		"extensionPacks": {},
+		"meta": {},
+		"_generated": {
+			"warning": "⚠️  GENERATED FILE - DO NOT EDIT",
+			"message": "This file is automatically generated by \"prisma-next contract emit\".",
+			"regenerate": "To regenerate, run: prisma-next contract emit"
+		}
+	},
+	hints: {
+		"used": [],
+		"applied": [],
+		"plannerVersion": "2.0.0"
+	},
+	migrationHash: "sha256:7419a7bfdac708cff9db1b35e48b035b09f3a883f099483e41385738d146622a"
+};
+//#endregion
+//#region migrations/20260601T0000_install_vector_extension/ops.json
+var ops_default = [{
+	"id": "pgvector.install-vector-extension",
+	"label": "Enable extension \"vector\"",
+	"operationClass": "additive",
+	"invariantId": "pgvector:install-vector-v1",
+	"target": {
+		"id": "postgres",
+		"details": {
+			"schema": "public",
+			"objectType": "dependency",
+			"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')"
+	}]
+}];
+//#endregion
+//#region migrations/refs/head.json
+var head_default = {
+	hash: "sha256:382dae5bb1548e62cbc449530ea08a9ce0a0dbb280401e9588642223f33783ae",
+	invariants: ["pgvector:install-vector-v1"]
+};
+//#endregion
+//#region src/contract.json
+var contract_default = {
+	schemaVersion: "1",
+	targetFamily: "sql",
+	target: "postgres",
+	profileHash: "sha256:1a8dbe044289f30a1de958fe800cc5a8378b285d2e126a8c44b58864bac2c18e",
+	roots: {},
+	models: {},
+	storage: {
+		"storageHash": "sha256:382dae5bb1548e62cbc449530ea08a9ce0a0dbb280401e9588642223f33783ae",
+		"tables": {},
+		"types": { "vector": {
+			"codecId": "pg/vector@1",
+			"nativeType": "vector",
+			"typeParams": {}
+		} }
+	},
+	capabilities: {
+		"postgres": {
+			"jsonAgg": true,
+			"lateral": true,
+			"limit": true,
+			"orderBy": true,
+			"returning": true
+		},
+		"sql": {
+			"defaultInInsert": true,
+			"enums": true,
+			"returning": true
+		}
+	},
+	extensionPacks: {},
+	meta: {},
+	_generated: {
+		"warning": "⚠️  GENERATED FILE - DO NOT EDIT",
+		"message": "This file is automatically generated by \"prisma-next contract emit\".",
+		"regenerate": "To regenerate, run: prisma-next contract emit"
+	}
+};
+//#endregion
+//#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/` 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";
+//#endregion
 //#region src/exports/control.ts
 const PGVECTOR_CODEC_ID = "pg/vector@1";
+const BASELINE_DIR_NAME = "20260601T0000_install_vector_extension";
 function buildVectorIdentityValue(typeParams) {
 	const length = typeParams?.["length"];
 	if (typeof length !== "number" || !Number.isInteger(length) || length <= 0) return null;
@@ -15,31 +162,19 @@ 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 = contractSpaceFromJson({
+	contractJson: contract_default,
+	migrations: [{
+		dirName: BASELINE_DIR_NAME,
+		metadata: migration_default,
+		ops: ops_default
+	}],
+	headRef: head_default
+});
 const pgvectorExtensionDescriptor = {
 	...pgvectorPackMeta,
+	id: PGVECTOR_SPACE_ID,
+	contractSpace: pgvectorContractSpace,
 	types: {
 		...pgvectorPackMeta.types,
 		codecTypes: {
@@ -47,15 +182,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":["baselineMetadata","baselineOps"],"sources":["../migrations/20260601T0000_install_vector_extension/migration.json","../migrations/20260601T0000_install_vector_extension/ops.json","../migrations/refs/head.json","../src/contract.json","../src/core/contract-space-constants.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/` 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 * Control-plane descriptor for the pgvector extension.\n *\n * **Contract-space package layout.** The extension's contract\n * + migrations are emitted by the same pipeline application authors use:\n *\n *   `prisma-next contract emit` → `<package>/src/contract.{json,d.ts}`\n *   `prisma-next migration plan` → `<package>/migrations/<dir>/...`\n *\n * The descriptor wires those JSON artefacts via JSON-import declarations\n * so they flow through the consuming application's module resolver\n * without filesystem assumptions, and synthesises the canonical\n * {@link import('@prisma-next/framework-components/control').MigrationPackage}\n * shape for the framework's runner / verifier to consume. Readers in\n * `@prisma-next/migration-tools` add `dirPath` when loading from disk\n * (`OnDiskMigrationPackage`); descriptor-bundled packages do not need\n * it because the framework reads them directly from the descriptor.\n *\n * Wired surfaces:\n *\n *   - `contractSpace.{contractJson,migrations,headRef}` — sourced from\n *     the on-disk artefacts emitted by `build:contract-space`.\n *   - `types.codecTypes.controlPlaneHooks[PGVECTOR_CODEC_ID]` — codec\n *     control hooks (`expandNativeType`, `resolveIdentityValue`) the\n *     SQL planner extracts via `extractCodecControlHooks` and uses to\n *     render `vector(N)` column types and the canonical zero-vector\n *     identity literal.\n *\n * @see docs/architecture docs/adrs/ADR 212 - Contract spaces.md\n *   (contract-space package layout convention).\n */\n\nimport type { Contract } from '@prisma-next/contract/types';\nimport type {\n  CodecControlHooks,\n  SqlControlExtensionDescriptor,\n} from '@prisma-next/family-sql/control';\nimport { contractSpaceFromJson } from '@prisma-next/migration-tools/spaces';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport baselineMetadata from '../../migrations/20260601T0000_install_vector_extension/migration.json' with {\n  type: 'json',\n};\nimport baselineOps from '../../migrations/20260601T0000_install_vector_extension/ops.json' with {\n  type: 'json',\n};\nimport headRef from '../../migrations/refs/head.json' with { type: 'json' };\nimport contractJson from '../contract.json' with { type: 'json' };\nimport { PGVECTOR_SPACE_ID } from '../core/contract-space-constants';\nimport { pgvectorPackMeta, pgvectorQueryOperations } from '../core/descriptor-meta';\n\nconst PGVECTOR_CODEC_ID = 'pg/vector@1' as const;\nconst BASELINE_DIR_NAME = '20260601T0000_install_vector_extension';\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 = contractSpaceFromJson<Contract<SqlStorage>>({\n  contractJson,\n  migrations: [\n    {\n      dirName: BASELINE_DIR_NAME,\n      metadata: baselineMetadata,\n      ops: baselineOps,\n    },\n  ],\n  headRef,\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AIgBA,MAAa,oBAAoB;;;ACkCjC,MAAM,oBAAoB;AAC1B,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,wBAAwB,sBAA4C;CACxE,cAAA;CACA,YAAY,CACV;EACE,SAAS;EACT,UAAUA;EACV,KAAKC;EACN,CACF;CACD,SAAA;CACD,CAAC;AAEF,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"}