@prisma-next/extension-pgvector 0.5.0-dev.71 → 0.5.0-dev.73

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

@@ -1,5 +1,5 @@
-import { AnyCodecDescriptor, CodecCallContext, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
 import { JsonValue } from "@prisma-next/contract/types";
+import { AnyCodecDescriptor, CodecCallContext, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
 import { ExtractCodecTypes } from "@prisma-next/sql-relational-core/ast";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
@@ -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-CQubO6uQ.d.mts.map
+//# sourceMappingURL=codec-types-yMSpEJJM.d.mts.map

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

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

package/dist/codec-types.d.mts

@@ -1,2 +1,2 @@
-import { n as Vector, t as CodecTypes } from "./codec-types-CQubO6uQ.mjs";
+import { n as Vector, t as CodecTypes } from "./codec-types-yMSpEJJM.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":";;;cAkEM,2BAAA,EAA6B,6BAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;;cA+DM,2BAAA,EAA6B,6BAAA"}

package/dist/control.mjs

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

package/dist/control.mjs.map

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

package/dist/operation-types.d.mts

@@ -1,43 +1,6 @@
 import { CodecExpression, Expression } from "@prisma-next/sql-relational-core/expression";
-import { CodecTrait } from "@prisma-next/framework-components/codec";
-//#region ../../2-sql/1-core/contract/dist/types-CjGH62ec.d.mts
-/**
- * Dispatch hint identifying the first-argument target of an operation.
- *
- * Used by ORM column helpers to decide whether an operation is reachable on a
- * field. Either names a concrete codec identity or a set of capability traits
- * that the field's codec must carry.
- */
-type QueryOperationSelfSpec = {
-  readonly codecId: string;
-  readonly traits?: never;
-} | {
-  readonly traits: readonly CodecTrait[];
-  readonly codecId?: never;
-};
-/**
- * Structural shape an operation's impl must return: any value carrying a
- * codec-exact `returnType` descriptor. `Expression<T>` (from
- * `@prisma-next/sql-relational-core/expression`, with `T extends ScopeField`)
- * extends this. Trait-targeted returns are deliberately excluded — predicate
- * detection and result decoding both depend on knowing the concrete return
- * codec.
- */
-type QueryOperationReturn = {
-  readonly returnType: {
-    readonly codecId: string;
-    readonly nullable: boolean;
-  };
-};
-type QueryOperationTypeEntry = {
-  readonly self?: QueryOperationSelfSpec;
-  readonly impl: (...args: never[]) => QueryOperationReturn;
-};
-type SqlQueryOperationTypes<_CT extends Record<string, {
-  readonly input: unknown;
-  readonly output: unknown;
-}>, T extends Record<string, QueryOperationTypeEntry>> = T;
-//#endregion
+import { SqlQueryOperationTypes } from "@prisma-next/sql-contract/types";
+
 //#region src/types/operation-types.d.ts
 type CodecTypesBase = Record<string, {
   readonly input: unknown;

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

@@ -1 +1 @@
-{"version":3,"file":"operation-types.d.mts","names":["ColumnDefault","StorageBase","CodecTrait","StorageColumn","Record","nativeType","codecId","nullable","typeParams","typeRef","default","PrimaryKey","columns","name","UniqueConstraint","Index","using","config","ForeignKeyReferences","table","ReferentialAction","ForeignKeyOptions","onDelete","onUpdate","ForeignKey","references","constraint","index","StorageTable","ReadonlyArray","primaryKey","uniques","indexes","foreignKeys","StorageTypeInstance","SqlStorage","THash","tables","types","SqlModelFieldStorage","column","SqlModelStorage","fields","DEFAULT_FK_CONSTRAINT","DEFAULT_FK_INDEX","applyFkDefaults","fk","overrideDefaults","TypeMaps","TCodecTypes","TOperationTypes","TQueryOperationTypes","TFieldOutputTypes","TFieldInputTypes","output","codecTypes","operationTypes","queryOperationTypes","fieldOutputTypes","fieldInputTypes","CodecTypesOf","T","C","OperationTypesOf","O","QueryOperationSelfSpec","traits","QueryOperationReturn","returnType","QueryOperationTypeEntry","self","impl","args","SqlQueryOperationTypes","_CT","input","QueryOperationTypesBase","QueryOperationTypesOf","Q","TypeMapsPhantomKey","ContractWithTypeMaps","TContract","TTypeMaps","K","ExtractTypeMapsFromContract","NonNullable","FieldOutputTypesOf","F","FieldInputTypesOf","ExtractCodecTypes","ExtractQueryOperationTypes","ExtractFieldOutputTypes","ExtractFieldInputTypes","ResolveCodecTypes","ResolveOperationTypes","_TContract","A","D","E","I","M","N","P","S","_","a","b","c","d","f","g","h","i","j","k","l","m","n","o","p","r","s","t","u","v","w","x","y"],"sources":["../../../2-sql/1-core/contract/dist/types-CjGH62ec.d.mts","../src/types/operation-types.ts"],"mappings":";;;;;;;;;;KAoJKiE,sBAAAA;EAAAA,SACM3D,OAAAA;EAAAA,SACA4D,MAAAA;AAAAA;EAAAA,SAEAA,MAAAA,WAAiBhE,UAAAA;EAAAA,SACjBI,OAAAA;AAAAA;;;;;;;;;KAUN6D,oBAAAA;EAAAA,SACMC,UAAAA;IAAAA,SACE9D,OAAAA;IAAAA,SACAC,QAAAA;EAAAA;AAAAA;AAAAA,KAGR8D,uBAAAA;EAAAA,SACMC,IAAAA,GAAOL,sBAAAA;EAAAA,SACPM,IAAAA,MAAUC,IAAAA,cAAkBL,oBAAAA;AAAAA;AAAAA,KAElCM,sBAAAA,aAAmCrE,MAAAA;EAAAA,SAC7BuE,KAAAA;EAAAA,SACArB,MAAAA;AAAAA,cACGlD,MAAAA,SAAeiE,uBAAAA,KAA4BR,CAAAA;;;KC7KpD,cAAA,GAAiB,MAAA;EAAA,SAA0B,KAAA;EAAA,SAAyB,MAAA;AAAA;;;;;;;KAS7D,cAAA;EAAA,SACD,aAAA;IAAA,SACE,cAAA;MAAA,SACE,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SAEnB,gBAAA;MAAA,SACE,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;EAAA;AAAA;;KAMpB,mBAAA,YAA+B,cAAA,IAAkB,sBAAA,CAC3D,EAAA;EAAA,SAEW,cAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,yBAAwC,EAAA,GAC9C,KAAA,EAAO,eAAA,yBAAwC,EAAA,MAC5C,UAAA;MAAa,OAAA;MAAwB,QAAA;IAAA;EAAA;EAAA,SAEnC,gBAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,yBAAwC,EAAA,GAC9C,KAAA,EAAO,eAAA,yBAAwC,EAAA,MAC5C,UAAA;MAAa,OAAA;MAAwB,QAAA;IAAA;EAAA;AAAA"}
+{"version":3,"file":"operation-types.d.mts","names":[],"sources":["../src/types/operation-types.ts"],"mappings":";;;;KAGK,cAAA,GAAiB,MAAA;EAAA,SAA0B,KAAA;EAAA,SAAyB,MAAA;AAAA;;;;;;;KAS7D,cAAA;EAAA,SACD,aAAA;IAAA,SACE,cAAA;MAAA,SACE,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SAEnB,gBAAA;MAAA,SACE,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;EAAA;AAAA;AAMhC;AAAA,KAAY,mBAAA,YAA+B,cAAA,IAAkB,sBAAA,CAC3D,EAAA;EAAA,SAEW,cAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,yBAAwC,EAAA,GAC9C,KAAA,EAAO,eAAA,yBAAwC,EAAA,MAC5C,UAAA;MAAa,OAAA;MAAwB,QAAA;IAAA;EAAA;EAAA,SAEnC,gBAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,yBAAwC,EAAA,GAC9C,KAAA,EAAO,eAAA,yBAAwC,EAAA,MAC5C,UAAA;MAAa,OAAA;MAAwB,QAAA;IAAA;EAAA;AAAA"}

package/dist/pack.d.mts

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

package/package.json

@@ -1,30 +1,31 @@
 {
   "name": "@prisma-next/extension-pgvector",
-  "version": "0.5.0-dev.71",
+  "version": "0.5.0-dev.73",
   "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-dev.71",
-    "@prisma-next/family-sql": "0.5.0-dev.71",
-    "@prisma-next/framework-components": "0.5.0-dev.71",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.71",
-    "@prisma-next/sql-runtime": "0.5.0-dev.71",
-    "@prisma-next/contract-authoring": "0.5.0-dev.71",
-    "@prisma-next/sql-operations": "0.5.0-dev.71",
-    "@prisma-next/sql-schema-ir": "0.5.0-dev.71"
+    "@prisma-next/contract-authoring": "0.5.0-dev.73",
+    "@prisma-next/contract": "0.5.0-dev.73",
+    "@prisma-next/framework-components": "0.5.0-dev.73",
+    "@prisma-next/family-sql": "0.5.0-dev.73",
+    "@prisma-next/migration-tools": "0.5.0-dev.73",
+    "@prisma-next/sql-contract": "0.5.0-dev.73",
+    "@prisma-next/sql-operations": "0.5.0-dev.73",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.73",
+    "@prisma-next/sql-runtime": "0.5.0-dev.73",
+    "@prisma-next/sql-schema-ir": "0.5.0-dev.73"
   },
   "devDependencies": {
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5",
-    "@prisma-next/sql-contract": "0.5.0-dev.71",
-    "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/sql-contract-ts": "0.5.0-dev.71",
+    "@prisma-next/operations": "0.5.0-dev.73",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.73",
     "@prisma-next/test-utils": "0.0.1",
-    "@prisma-next/operations": "0.5.0-dev.71",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },
   "files": [

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

@@ -0,0 +1,30 @@
+/**
+ * Static names and identifiers used across pgvector's contract space.
+ *
+ * Centralised here so the contract IR (`./contract`), the baseline
+ * migration ops (`./migrations`), the head ref, and the descriptor
+ * (`../exports/control`) all reference the same values without typos.
+ *
+ * The space identifier `'pgvector'` is what the framework writes to
+ * `migrations/pgvector/` in the user's repo and what the marker table's
+ * `space` column carries for pgvector-owned rows.
+ *
+ * The `pgvector:*` invariantId namespace is locked here — once
+ * published, an invariantId is immutable so downstream consumers can
+ * reference it by literal string match.
+ */
+
+export const PGVECTOR_SPACE_ID = 'pgvector' as const;
+
+export const PGVECTOR_NATIVE_TYPE = 'vector' as const;
+
+export const PGVECTOR_BASELINE_MIGRATION_NAME = '20260601T0000_install_vector_extension' as const;
+
+/**
+ * `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.
+ */
+export const PGVECTOR_INVARIANTS = {
+  installVector: 'pgvector:install-vector-v1',
+} as const;

package/src/core/contract.ts

@@ -0,0 +1,74 @@
+/**
+ * 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

@@ -0,0 +1,125 @@
+/**
+ * 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,
+};

package/src/exports/control.ts

@@ -1,9 +1,36 @@
+/**
+ * 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.
+ *
+ * `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.
+ */
+
+import type { Contract } from '@prisma-next/contract/types';
 import type {
   CodecControlHooks,
-  ComponentDatabaseDependencies,
   SqlControlExtensionDescriptor,
 } from '@prisma-next/family-sql/control';
+import type { ContractSpace } from '@prisma-next/framework-components/control';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { pgvectorContract } from '../core/contract';
+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;
 
@@ -28,44 +55,16 @@ const vectorControlPlaneHooks: CodecControlHooks = {
   resolveIdentityValue: ({ typeParams }) => buildVectorIdentityValue(typeParams),
 };
 
-const pgvectorDatabaseDependencies: ComponentDatabaseDependencies<unknown> = {
-  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: ContractSpace<Contract<SqlStorage>> = {
+  contractJson: pgvectorContract,
+  migrations: [pgvectorBaselineMigration],
+  headRef: pgvectorHeadRef,
 };
 
 const pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {
   ...pgvectorPackMeta,
+  id: PGVECTOR_SPACE_ID,
+  contractSpace: pgvectorContractSpace,
   types: {
     ...pgvectorPackMeta.types,
     codecTypes: {
@@ -76,7 +75,6 @@ const pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {
     },
   },
   queryOperations: () => pgvectorQueryOperations(),
-  databaseDependencies: pgvectorDatabaseDependencies,
   create: () => ({
     familyId: 'sql' as const,
     targetId: 'postgres' as const,