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

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
 
@@ -198,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-yMSpEJJM.d.mts → codec-types-CQubO6uQ.d.mts}

@@ -1,5 +1,5 @@
-import { JsonValue } from "@prisma-next/contract/types";
 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";
 
@@ -60,4 +60,4 @@ type Vector<N extends number = number> = number[] & {
 type CodecTypes = CodecTypes$1;
 //#endregion
 export { Vector as n, CodecTypes as t };
-//# sourceMappingURL=codec-types-yMSpEJJM.d.mts.map
+//# sourceMappingURL=codec-types-CQubO6uQ.d.mts.map

package/dist/{codec-types-yMSpEJJM.d.mts.map → codec-types-CQubO6uQ.d.mts.map}

@@ -1 +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"}
+{"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-yMSpEJJM.mjs";
+import { n as Vector, t as CodecTypes } from "./codec-types-CQubO6uQ.mjs";
 export { type CodecTypes, type Vector };

package/dist/control.d.mts.map

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

package/dist/control.mjs

@@ -1,8 +1,133 @@
-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";
+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.
@@ -12,7 +137,7 @@ import { computeMigrationHash } from "@prisma-next/migration-tools/hash";
 * (`../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
+* `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
@@ -20,153 +145,10 @@ import { computeMigrationHash } from "@prisma-next/migration-tools/hash";
 * 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";
+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;
@@ -180,11 +162,15 @@ const vectorControlPlaneHooks = {
 	},
 	resolveIdentityValue: ({ typeParams }) => buildVectorIdentityValue(typeParams)
 };
-const pgvectorContractSpace = {
-	contractJson: pgvectorContract,
-	migrations: [pgvectorBaselineMigration],
-	headRef: pgvectorHeadRef
-};
+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,

package/dist/control.mjs.map

@@ -1 +1 @@
-{"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"}
+{"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"}

package/dist/pack.d.mts

@@ -1,4 +1,4 @@
-import { t as CodecTypes } from "./codec-types-yMSpEJJM.mjs";
+import { t as CodecTypes } from "./codec-types-CQubO6uQ.mjs";
 import * as _$_prisma_next_framework_components_codec0 from "@prisma-next/framework-components/codec";
 
 //#region src/core/descriptor-meta.d.ts

package/package.json

@@ -1,33 +1,44 @@
 {
   "name": "@prisma-next/extension-pgvector",
-  "version": "0.5.0",
+  "version": "0.6.0-dev.3",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.1.29",
-    "@prisma-next/contract": "0.5.0",
-    "@prisma-next/family-sql": "0.5.0",
-    "@prisma-next/framework-components": "0.5.0",
-    "@prisma-next/migration-tools": "0.5.0",
-    "@prisma-next/sql-contract": "0.5.0",
-    "@prisma-next/sql-operations": "0.5.0",
-    "@prisma-next/sql-relational-core": "0.5.0",
-    "@prisma-next/sql-runtime": "0.5.0",
-    "@prisma-next/contract-authoring": "0.5.0",
-    "@prisma-next/sql-schema-ir": "0.5.0"
+    "@prisma-next/contract": "0.6.0-dev.3",
+    "@prisma-next/family-sql": "0.6.0-dev.3",
+    "@prisma-next/contract-authoring": "0.6.0-dev.3",
+    "@prisma-next/framework-components": "0.6.0-dev.3",
+    "@prisma-next/migration-tools": "0.6.0-dev.3",
+    "@prisma-next/sql-contract": "0.6.0-dev.3",
+    "@prisma-next/sql-operations": "0.6.0-dev.3",
+    "@prisma-next/sql-runtime": "0.6.0-dev.3",
+    "@prisma-next/sql-schema-ir": "0.6.0-dev.3",
+    "@prisma-next/sql-relational-core": "0.6.0-dev.3"
   },
   "devDependencies": {
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5",
-    "@prisma-next/operations": "0.5.0",
-    "@prisma-next/sql-contract-ts": "0.5.0",
+    "@prisma-next/adapter-postgres": "0.6.0-dev.3",
+    "@prisma-next/operations": "0.6.0-dev.3",
+    "@prisma-next/cli": "0.6.0-dev.3",
+    "@prisma-next/sql-contract-ts": "0.6.0-dev.3",
+    "@prisma-next/target-postgres": "0.6.0-dev.3",
     "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },
+  "peerDependencies": {
+    "@prisma-next/adapter-postgres": "0.6.0-dev.3"
+  },
+  "peerDependenciesMeta": {
+    "@prisma-next/adapter-postgres": {
+      "optional": true
+    }
+  },
   "files": [
     "dist",
     "src"
@@ -47,6 +58,7 @@
     "directory": "packages/3-extensions/pgvector"
   },
   "scripts": {
+    "build:contract-space": "prisma-next contract emit",
     "build": "tsdown",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",

package/src/contract.d.ts

@@ -0,0 +1,91 @@
+// ⚠️  GENERATED FILE - DO NOT EDIT
+// This file is automatically generated by 'prisma-next contract emit'.
+// To regenerate, run: prisma-next contract emit
+import type { CodecTypes as PgTypes } from '@prisma-next/target-postgres/codec-types';
+import type { JsonValue } from '@prisma-next/target-postgres/codec-types';
+import type { Char } from '@prisma-next/target-postgres/codec-types';
+import type { Varchar } from '@prisma-next/target-postgres/codec-types';
+import type { Numeric } from '@prisma-next/target-postgres/codec-types';
+import type { Bit } from '@prisma-next/target-postgres/codec-types';
+import type { VarBit } from '@prisma-next/target-postgres/codec-types';
+import type { Timestamp } from '@prisma-next/target-postgres/codec-types';
+import type { Timestamptz } from '@prisma-next/target-postgres/codec-types';
+import type { Time } from '@prisma-next/target-postgres/codec-types';
+import type { Timetz } from '@prisma-next/target-postgres/codec-types';
+import type { Interval } from '@prisma-next/target-postgres/codec-types';
+import type { QueryOperationTypes as PgAdapterQueryOps } from '@prisma-next/adapter-postgres/operation-types';
+
+import type {
+  ContractWithTypeMaps,
+  TypeMaps as TypeMapsType,
+} from '@prisma-next/sql-contract/types';
+import type {
+  Contract as ContractType,
+  ExecutionHashBase,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+
+export type StorageHash =
+  StorageHashBase<'sha256:382dae5bb1548e62cbc449530ea08a9ce0a0dbb280401e9588642223f33783ae'>;
+export type ExecutionHash = ExecutionHashBase<string>;
+export type ProfileHash =
+  ProfileHashBase<'sha256:1a8dbe044289f30a1de958fe800cc5a8378b285d2e126a8c44b58864bac2c18e'>;
+
+export type CodecTypes = PgTypes;
+export type LaneCodecTypes = CodecTypes;
+export type QueryOperationTypes = PgAdapterQueryOps<CodecTypes>;
+type DefaultLiteralValue<CodecId extends string, _Encoded> = CodecId extends keyof CodecTypes
+  ? CodecTypes[CodecId]['output']
+  : _Encoded;
+
+export type FieldOutputTypes = Record<string, never>;
+export type FieldInputTypes = Record<string, never>;
+export type TypeMaps = TypeMapsType<
+  CodecTypes,
+  QueryOperationTypes,
+  FieldOutputTypes,
+  FieldInputTypes
+>;
+
+type ContractBase = ContractType<
+  {
+    readonly tables: {};
+    readonly types: {
+      readonly vector: {
+        readonly codecId: 'pg/vector@1';
+        readonly nativeType: 'vector';
+        readonly typeParams: Record<string, never>;
+      };
+    };
+    readonly storageHash: StorageHash;
+  },
+  Record<string, never>
+> & {
+  readonly target: 'postgres';
+  readonly targetFamily: 'sql';
+  readonly roots: Record<string, string>;
+  readonly capabilities: {
+    readonly postgres: {
+      readonly jsonAgg: true;
+      readonly lateral: true;
+      readonly limit: true;
+      readonly orderBy: true;
+      readonly returning: true;
+    };
+    readonly sql: {
+      readonly defaultInInsert: true;
+      readonly enums: true;
+      readonly returning: true;
+    };
+  };
+  readonly extensionPacks: {};
+  readonly meta: {};
+
+  readonly profileHash: ProfileHash;
+};
+
+export type Contract = ContractWithTypeMaps<ContractBase, TypeMaps>;
+
+export type Tables = Contract['storage']['tables'];
+export type Models = Contract['models'];

package/src/contract.json

@@ -0,0 +1,40 @@
+{
+  "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"
+  }
+}

package/src/contract.ts

@@ -0,0 +1,67 @@
+/**
+ * TS contract source for the `extension-pgvector` package.
+ *
+ * Authored against the contract-space package layout convention. The
+ * same emit pipeline application authors use is applied here:
+ *
+ *   `prisma-next contract emit` → `<package>/src/contract.{json,d.ts}`
+ *   `prisma-next migration plan` → `<package>/migrations/<dirName>/`
+ *
+ * The descriptor at `src/exports/control.ts` then wires the emitted
+ * JSON artefacts via JSON-import declarations.
+ *
+ * ## IR coverage
+ *
+ * pgvector ships **no tables** of its own. The single object the
+ * extension contributes to the contract IR is the parameterised native
+ * type `vector(N)`, registered under `storage.types`. Per-column
+ * instances on the user's side carry concrete `typeParams.length`
+ * (e.g. `vector(1536)`); the registration here declares the
+ * parameterised shape so the verifier sees `vector` as part of
+ * pgvector's space contribution and so the pinned `contract.json` on
+ * disk is materially distinct from an empty space.
+ *
+ * Unlike CipherStash's deferred typed objects (composite types /
+ * domains / enums — IR vocabulary deferral, see
+ * `packages/3-extensions/cipherstash/src/contract.prisma`),
+ * pgvector's `vector` IS representable in today's IR via
+ * {@link StorageTypeInstance}.
+ *
+ * ## Why TS, not PSL
+ *
+ * The contract-space package layout convention prefers PSL
+ * (`src/contract.prisma`). pgvector is the narrow exception called out
+ * in the convention: PSL's `types {}` block instantiates parameterised
+ * types at app authoring time (`Vector1536 = pgvector.Vector(1536)`)
+ * but has no surface for an extension to register the parameterised
+ * BASE type itself (the `storage.types.vector` entry with empty
+ * `typeParams` shown below). Until PSL grows that surface, this
+ * extension keeps its contract source in TS.
+ *
+ * @see docs/architecture docs/adrs/ADR 212 - Contract spaces.md
+ */
+
+import sqlFamily from '@prisma-next/family-sql/pack';
+import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
+import postgresPack from '@prisma-next/target-postgres/pack';
+import { VECTOR_CODEC_ID } from './core/constants';
+import { PGVECTOR_NATIVE_TYPE } from './core/contract-space-constants';
+
+export const contract = defineContract(
+  {
+    family: sqlFamily,
+    target: postgresPack,
+  },
+  () => ({
+    types: {
+      [PGVECTOR_NATIVE_TYPE]: {
+        codecId: VECTOR_CODEC_ID,
+        nativeType: PGVECTOR_NATIVE_TYPE,
+        typeParams: {},
+      },
+    },
+    models: {},
+  }),
+);
+
+export default contract;

package/src/core/contract-space-constants.ts

@@ -6,7 +6,7 @@
  * (`../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
+ * `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

package/src/exports/control.ts

@@ -1,23 +1,33 @@
 /**
  * Control-plane descriptor for the pgvector extension.
  *
- * Exposes a `contractSpace` so the framework's per-space planner /
- * runner / verifier (project: extension-contract-spaces, M1+M2)
- * manages the pgvector extension's database scaffolding the same way
- * it manages an application's own schema. The descriptor is consumed
- * by the framework only at authoring time (`migrate`); apply / verify
- * paths read the user's repo (`migrations/pgvector/...`) instead — see
- * project spec NFR3 / FR2 / FR10.
+ * **Contract-space package layout.** The extension's contract
+ * + migrations are emitted by the same pipeline application authors use:
  *
- * `databaseDependencies` is intentionally absent — pgvector was
- * migrated off the legacy `databaseDependencies.init` mechanism in M4
- * (project spec FR13). The `CREATE EXTENSION IF NOT EXISTS vector`
- * DDL the legacy entry carried now lives as the body of the
- * `installVectorExtension` op inside the baseline migration package
- * (`../core/migrations.ts`). Presence of `contractSpace` is the
- * shipping-strategy gate: the framework loads the contract space and
- * ignores any `databaseDependencies` block (project plan §
- * "Shipping Strategy"). M5 removes the field at the framework level.
+ *   `prisma-next contract emit` → `<package>/src/contract.{json,d.ts}`
+ *   `prisma-next migration plan` → `<package>/migrations/<dir>/...`
+ *
+ * The descriptor wires those JSON artefacts via JSON-import declarations
+ * so they flow through the consuming application's module resolver
+ * without filesystem assumptions, and synthesises the canonical
+ * {@link import('@prisma-next/framework-components/control').MigrationPackage}
+ * shape for the framework's runner / verifier to consume. Readers in
+ * `@prisma-next/migration-tools` add `dirPath` when loading from disk
+ * (`OnDiskMigrationPackage`); descriptor-bundled packages do not need
+ * it because the framework reads them directly from the descriptor.
+ *
+ * Wired surfaces:
+ *
+ *   - `contractSpace.{contractJson,migrations,headRef}` — sourced from
+ *     the on-disk artefacts emitted by `build:contract-space`.
+ *   - `types.codecTypes.controlPlaneHooks[PGVECTOR_CODEC_ID]` — codec
+ *     control hooks (`expandNativeType`, `resolveIdentityValue`) the
+ *     SQL planner extracts via `extractCodecControlHooks` and uses to
+ *     render `vector(N)` column types and the canonical zero-vector
+ *     identity literal.
+ *
+ * @see docs/architecture docs/adrs/ADR 212 - Contract spaces.md
+ *   (contract-space package layout convention).
  */
 
 import type { Contract } from '@prisma-next/contract/types';
@@ -25,14 +35,21 @@ import type {
   CodecControlHooks,
   SqlControlExtensionDescriptor,
 } from '@prisma-next/family-sql/control';
-import type { ContractSpace } from '@prisma-next/framework-components/control';
+import { contractSpaceFromJson } from '@prisma-next/migration-tools/spaces';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
-import { pgvectorContract } from '../core/contract';
+import baselineMetadata from '../../migrations/20260601T0000_install_vector_extension/migration.json' with {
+  type: 'json',
+};
+import baselineOps from '../../migrations/20260601T0000_install_vector_extension/ops.json' with {
+  type: 'json',
+};
+import headRef from '../../migrations/refs/head.json' with { type: 'json' };
+import contractJson from '../contract.json' with { type: 'json' };
 import { PGVECTOR_SPACE_ID } from '../core/contract-space-constants';
 import { pgvectorPackMeta, pgvectorQueryOperations } from '../core/descriptor-meta';
-import { pgvectorBaselineMigration, pgvectorHeadRef } from '../core/migrations';
 
 const PGVECTOR_CODEC_ID = 'pg/vector@1' as const;
+const BASELINE_DIR_NAME = '20260601T0000_install_vector_extension';
 
 function buildVectorIdentityValue(typeParams: Record<string, unknown> | undefined): string | null {
   const length = typeParams?.['length'];
@@ -55,11 +72,17 @@ const vectorControlPlaneHooks: CodecControlHooks = {
   resolveIdentityValue: ({ typeParams }) => buildVectorIdentityValue(typeParams),
 };
 
-const pgvectorContractSpace: ContractSpace<Contract<SqlStorage>> = {
-  contractJson: pgvectorContract,
-  migrations: [pgvectorBaselineMigration],
-  headRef: pgvectorHeadRef,
-};
+const pgvectorContractSpace = contractSpaceFromJson<Contract<SqlStorage>>({
+  contractJson,
+  migrations: [
+    {
+      dirName: BASELINE_DIR_NAME,
+      metadata: baselineMetadata,
+      ops: baselineOps,
+    },
+  ],
+  headRef,
+});
 
 const pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {
   ...pgvectorPackMeta,

package/src/core/contract.ts

@@ -1,74 +0,0 @@
-/**
- * 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.
- */
-
-import { computeStorageHash } from '@prisma-next/contract/hashing';
-import { type Contract, coreHash, profileHash } from '@prisma-next/contract/types';
-import type { SqlStorage } from '@prisma-next/sql-contract/types';
-import { VECTOR_CODEC_ID } from './constants';
-import { PGVECTOR_NATIVE_TYPE } from './contract-space-constants';
-
-const TARGET = 'postgres' as const;
-const TARGET_FAMILY = 'sql' as const;
-
-/**
- * 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. */
-export const PGVECTOR_STORAGE_HASH = computeStorageHash({
-  target: TARGET,
-  targetFamily: TARGET_FAMILY,
-  storage: storageBody,
-});
-
-/** pgvector's contract value, exposed via the descriptor's `contractSpace.contractJson`. */
-export const pgvectorContract: Contract<SqlStorage> = {
-  target: TARGET,
-  targetFamily: TARGET_FAMILY,
-  roots: {},
-  models: {},
-  capabilities: {},
-  extensionPacks: {},
-  meta: {},
-  profileHash: profileHash('pgvector-extension-profile-v1'),
-  storage: {
-    ...storageBody,
-    storageHash: coreHash(PGVECTOR_STORAGE_HASH),
-  },
-};

package/src/core/migrations.ts

@@ -1,125 +0,0 @@
-/**
- * pgvector contract space — baseline migration package.
- *
- * An extension's `contractSpace.migrations` is a list of in-memory
- * `MigrationPackage` values whose `ops` carry framework-level
- * `MigrationPlanOperation`s. The SQL family runner reads the additional
- * runtime fields (`target`, `precheck`, `execute`, `postcheck`) at
- * apply time.
- *
- * Ships a single baseline migration whose only op is
- * {@link installVectorExtensionOp} — it carries the
- * `CREATE EXTENSION IF NOT EXISTS vector` DDL plus a postcondition that
- * confirms the extension landed. Mirrors the prior
- * `databaseDependencies.init[0]` shape (precheck / execute / postcheck)
- * but as a `MigrationPackage` op so the framework's per-space runner /
- * verifier can manage it the same way it manages an application's own
- * migrations.
- *
- * The op carries the stable `pgvector:install-vector-v1` invariantId —
- * once published it is immutable.
- */
-
-import type { SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
-import type {
-  ContractSpaceHeadRef,
-  MigrationPackage,
-  MigrationPlanOperation,
-} from '@prisma-next/framework-components/control';
-import { computeMigrationHash } from '@prisma-next/migration-tools/hash';
-import { PGVECTOR_STORAGE_HASH, pgvectorContract } from './contract';
-import { PGVECTOR_BASELINE_MIGRATION_NAME, PGVECTOR_INVARIANTS } from './contract-space-constants';
-
-/**
- * Postgres-style `target.details` shape the SQL runner consumes when
- * executing extension-space ops. pgvector targets only Postgres;
- * locking the target id here keeps the per-op `target` literal narrow
- * without coupling to the Postgres adapter package's
- * `PostgresPlanTargetDetails`.
- */
-type PostgresTargetDetails = {
-  readonly schema: string;
-  readonly objectType: 'extension';
-  readonly name: string;
-};
-
-const installVectorExtensionOp: SqlMigrationPlanOperation<unknown> = {
-  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',
-    } satisfies PostgresTargetDetails,
-  },
-  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 pgvectorBaselineOps: readonly MigrationPlanOperation[] = [installVectorExtensionOp];
-
-/** Sorted list of invariantIds the baseline migration provides. */
-export const PGVECTOR_BASELINE_INVARIANTS: readonly string[] = (() => {
-  const ids = pgvectorBaselineOps
-    .map((op) => op.invariantId)
-    .filter((id): id is string => typeof id === 'string');
-  return [...new Set(ids)].sort();
-})();
-
-const baselineMetadataWithoutHash: Omit<MigrationPackage['metadata'], 'migrationHash'> = {
-  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.
- */
-export const pgvectorBaselineMigration: MigrationPackage = {
-  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.
- */
-export const pgvectorHeadRef: ContractSpaceHeadRef = {
-  hash: PGVECTOR_STORAGE_HASH,
-  invariants: PGVECTOR_BASELINE_INVARIANTS,
-};