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

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/codecs.ts

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

package/src/core/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/` 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/descriptor-meta.ts

@@ -1,38 +1,49 @@
-import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
+import { buildOperation, refsOf, toExpr } from '@prisma-next/sql-relational-core/expression';
 import type { CodecTypes } from '../types/codec-types';
+import type { QueryOperationTypes } from '../types/operation-types';
 import { pgvectorAuthoringTypes } from './authoring';
-import { codecDefinitions } from './codecs';
+import { pgvectorCodecRegistry } from './registry';
 
 const pgvectorTypeId = 'pg/vector@1' as const;
 
-export const pgvectorQueryOperations: readonly SqlOperationDescriptor[] = [
-  {
-    method: 'cosineDistance',
-    args: [
-      { codecId: pgvectorTypeId, nullable: false },
-      { codecId: pgvectorTypeId, nullable: false },
-    ],
-    returns: { codecId: 'pg/float8@1', nullable: false },
-    lowering: {
-      targetFamily: 'sql',
-      strategy: 'function',
-      template: '{{self}} <=> {{arg0}}',
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export function pgvectorQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {
+  return {
+    cosineDistance: {
+      self: { codecId: pgvectorTypeId },
+      impl: (self, other) => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
+          method: 'cosineDistance',
+          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
+          returns: { codecId: 'pg/float8@1', nullable: false },
+          lowering: {
+            targetFamily: 'sql',
+            strategy: 'function',
+            template: '{{self}} <=> {{arg0}}',
+          },
+        });
+      },
     },
-  },
-  {
-    method: 'cosineSimilarity',
-    args: [
-      { codecId: pgvectorTypeId, nullable: false },
-      { codecId: pgvectorTypeId, nullable: false },
-    ],
-    returns: { codecId: 'pg/float8@1', nullable: false },
-    lowering: {
-      targetFamily: 'sql',
-      strategy: 'function',
-      template: '1 - ({{self}} <=> {{arg0}})',
+    cosineSimilarity: {
+      self: { codecId: pgvectorTypeId },
+      impl: (self, other) => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
+          method: 'cosineSimilarity',
+          args: [toExpr(self, pgvectorTypeId, selfRefs), toExpr(other, pgvectorTypeId, selfRefs)],
+          returns: { codecId: 'pg/float8@1', nullable: false },
+          lowering: {
+            targetFamily: 'sql',
+            strategy: 'function',
+            template: '1 - ({{self}} <=> {{arg0}})',
+          },
+        });
+      },
     },
-  },
-];
+  };
+}
 
 const pgvectorPackMetaBase = {
   kind: 'extension',
@@ -50,7 +61,7 @@ const pgvectorPackMetaBase = {
   },
   types: {
     codecTypes: {
-      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
+      codecDescriptors: Array.from(pgvectorCodecRegistry.values()),
       import: {
         package: '@prisma-next/extension-pgvector/codec-types',
         named: 'CodecTypes',
@@ -64,13 +75,6 @@ const pgvectorPackMetaBase = {
         },
       ],
     },
-    operationTypes: {
-      import: {
-        package: '@prisma-next/extension-pgvector/operation-types',
-        named: 'OperationTypes',
-        alias: 'PgVectorOperationTypes',
-      },
-    },
     queryOperationTypes: {
       import: {
         package: '@prisma-next/extension-pgvector/operation-types',

package/src/core/registry.ts

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

package/src/exports/column-types.ts

@@ -1,16 +1,14 @@
 /**
  * Column type descriptors for pgvector extension.
  *
- * These descriptors provide both codecId and nativeType for use in contract authoring.
- * They are derived from the same source of truth as codec definitions and manifests.
+ * These descriptors provide both codecId and nativeType for use in contract authoring. They are derived from the same source of truth as codec definitions and manifests.
  */
 
-import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+import type { ColumnTypeDescriptor } from '@prisma-next/framework-components/codec';
 import { VECTOR_CODEC_ID, VECTOR_MAX_DIM } from '../core/constants';
 
 /**
- * Static vector column descriptor without dimension.
- * Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
+ * Static vector column descriptor without dimension. Use `vector(N)` for dimensioned vectors that produce `vector(N)` DDL.
  */
 export const vectorColumn = {
   codecId: VECTOR_CODEC_ID,
@@ -25,7 +23,6 @@ export const vectorColumn = {
  * .column('embedding', { type: vector(1536), nullable: false })
  * // Produces: nativeType: 'vector', typeParams: { length: 1536 }
  * ```
- *
  * @param length - The dimension of the vector (e.g., 1536 for OpenAI embeddings)
  * @returns A column type descriptor with `typeParams.length` set
  * @throws {RangeError} If length is not an integer in the range [1, VECTOR_MAX_DIM]

package/src/exports/control.ts

@@ -1,11 +1,55 @@
+/**
+ * Control-plane descriptor for the pgvector extension.
+ *
+ * **Contract-space package layout.** The extension's contract
+ * + migrations are emitted by the same pipeline application authors use:
+ *
+ *   `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';
 import type {
   CodecControlHooks,
-  ComponentDatabaseDependencies,
   SqlControlExtensionDescriptor,
 } from '@prisma-next/family-sql/control';
+import { contractSpaceFromJson } from '@prisma-next/migration-tools/spaces';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+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';
 
 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'];
@@ -28,44 +72,22 @@ const vectorControlPlaneHooks: CodecControlHooks = {
   resolveIdentityValue: ({ typeParams }) => buildVectorIdentityValue(typeParams),
 };
 
-const pgvectorDatabaseDependencies: ComponentDatabaseDependencies<unknown> = {
-  init: [
+const pgvectorContractSpace = contractSpaceFromJson<Contract<SqlStorage>>({
+  contractJson,
+  migrations: [
     {
-      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')",
-            },
-          ],
-        },
-      ],
+      dirName: BASELINE_DIR_NAME,
+      metadata: baselineMetadata,
+      ops: baselineOps,
     },
   ],
-};
+  headRef,
+});
 
 const pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {
   ...pgvectorPackMeta,
+  id: PGVECTOR_SPACE_ID,
+  contractSpace: pgvectorContractSpace,
   types: {
     ...pgvectorPackMeta.types,
     codecTypes: {
@@ -75,8 +97,7 @@ const pgvectorExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {
       },
     },
   },
-  queryOperations: () => pgvectorQueryOperations,
-  databaseDependencies: pgvectorDatabaseDependencies,
+  queryOperations: () => pgvectorQueryOperations(),
   create: () => ({
     familyId: 'sql' as const,
     targetId: 'postgres' as const,

package/src/exports/operation-types.ts

@@ -4,4 +4,4 @@
  * Re-export from types module for public API.
  */
 
-export type { OperationTypes, QueryOperationTypes } from '../types/operation-types';
+export type { QueryOperationTypes } from '../types/operation-types';