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

package/README.md

@@ -4,21 +4,21 @@ ParadeDB full-text search extension pack for Prisma Next.
 
 ## Overview
 
-This extension pack adds support for [ParadeDB](https://docs.paradedb.com/) BM25 full-text search indexes in the contract authoring layer. It keeps BM25 metadata inside extension-owned index `config` payloads, so `contract.json` and `contract.d.ts` carry the full search schema without hard-coding ParadeDB types into core SQL index IR.
+This extension pack registers a `'bm25'` index type with the SQL family's index-type registry, so contracts can author BM25 full-text search indexes via the standard `constraints.index(...)` surface and the Postgres adapter emits `CREATE INDEX ... USING bm25 WITH (...)` DDL.
 
-This is the **contract-only foundation**. Query-plane support (`@@@` operator, `pdb.*` functions) and migration-plane support (`CREATE INDEX ... USING bm25` DDL generation) are planned as follow-up work.
+The v1 surface covers the `key_field` storage parameter only. Per-field tokenizer and column configuration is deferred to expression-index support.
 
 ## Responsibilities
 
-- **BM25 Index Authoring**: Typed `bm25.*` field builders for defining BM25 indexes in `contract.ts`
-- **Tokenizer Catalog**: `TokenizerId` type union covering all 12 built-in ParadeDB tokenizers
-- **Extension Descriptor**: Declares `paradedb/bm25` capability for contract-level feature detection
-- **Pack Ref Export**: Ships a pure `/pack` entrypoint for TypeScript contract authoring
+- **bm25 index registration**: declares a `'bm25'` entry via `defineIndexTypes()` carrying an arktype validator for the bm25 options shape
+- **Extension descriptor**: declares the `paradedb/bm25` capability for contract-level feature detection
+- **Pack ref export**: ships a pure `/pack` entrypoint for TypeScript contract authoring
 
 ## Dependencies
 
-- **`@prisma-next/contract`**: Core contract types
-- **`@prisma-next/contract-authoring`**: Column type descriptor interface
+- **`@prisma-next/sql-contract`**: index-type registry primitive
+- **`@prisma-next/contract`** / **`@prisma-next/contract-authoring`**: core contract types
+- **`arktype`**: option-shape validation
 
 ## Installation
 
@@ -28,15 +28,14 @@ pnpm add @prisma-next/extension-paradedb
 
 ## Usage
 
-### Contract Definition
+### Contract definition
 
-Define BM25 indexes on your tables using `bm25` field builders plus `bm25Index()`:
+Author bm25 indexes via the standard `constraints.index(...)` surface; the registered `'bm25'` entry narrows `options` per-`type`:
 
 ```typescript
-import { int4Column, textColumn, jsonbColumn } from '@prisma-next/adapter-postgres/column-types';
+import { int4Column, textColumn } from '@prisma-next/adapter-postgres/column-types';
 import sqlFamily from '@prisma-next/family-sql/pack';
 import { defineContract, field, model } from '@prisma-next/sql-contract-ts/contract-builder';
-import { bm25, bm25Index } from '@prisma-next/extension-paradedb/index-types';
 import paradedb from '@prisma-next/extension-paradedb/pack';
 import postgres from '@prisma-next/target-postgres/pack';
 
@@ -48,121 +47,53 @@ export const contract = defineContract({
     Item: model('Item', {
       fields: {
         id: field.column(int4Column).id(),
-        description: field.column(textColumn),
-        category: field.column(textColumn),
-        rating: field.column(int4Column),
-        metadata: field.column(jsonbColumn),
+        body: field.column(textColumn),
       },
-    }).sql({
+    }).sql(({ cols, constraints }) => ({
       table: 'items',
       indexes: [
-        bm25Index({
-          keyField: 'id',
-          fields: [
-            bm25.text('description', { tokenizer: 'simple', stemmer: 'english' }),
-            bm25.text('category'),
-            bm25.numeric('rating'),
-            bm25.json('metadata', { tokenizer: 'ngram', min: 2, max: 3 }),
-          ],
-          name: 'search_idx',
+        constraints.index([cols.body], {
+          name: 'item_body_bm25_idx',
+          type: 'bm25',
+          options: { key_field: 'id' },
         }),
       ],
-    }),
+    })),
   },
 });
 ```
 
-### Field Builders
+### key_field
 
-The `bm25` namespace provides typed field builders that produce `Bm25FieldConfig` objects:
+ParadeDB BM25 indexes require a `key_field` — a unique column that identifies each document. It is required, must be a string, and is typically (but not always) the table's primary key.
 
-| Builder | Description | Tokenizer support |
-|---------|-------------|-------------------|
-| `bm25.text(column, opts?)` | Text field (`text`, `varchar`) | Yes — any tokenizer + stemmer, remove_emojis |
-| `bm25.numeric(column)` | Numeric field (filterable, sortable) | No |
-| `bm25.boolean(column)` | Boolean field | No |
-| `bm25.json(column, opts?)` | JSON/JSONB field | Yes — tokenizer + ngram params |
-| `bm25.datetime(column)` | Timestamp/date field | No |
-| `bm25.range(column)` | Range field | No |
-| `bm25.expression(sql, opts)` | Raw SQL expression | Yes — `alias` required |
-
-### Expression-Based Fields
-
-For computed or JSON sub-field indexing, use `bm25.expression()` with a raw SQL string:
-
-```typescript
-.index(
-  bm25Index({
-    keyField: 'id',
-    fields: [
-      bm25.text('description'),
-      bm25.expression("description || ' ' || category", {
-        alias: 'concat',
-        tokenizer: 'simple',
-      }),
-      bm25.expression("(metadata->>'color')", {
-        alias: 'meta_color',
-        tokenizer: 'ngram',
-        min: 2,
-        max: 3,
-      }),
-    ],
-  }),
-)
-```
-
-### keyField Behavior
-
-ParadeDB BM25 indexes require a `key_field` — a unique column that identifies each document:
-
-- **Required**: Set `keyField` explicitly in `bm25Index(...)`.
-- **Recommended**: Use the table primary key in most cases.
-- **Override**: You can choose another unique column when needed.
+## Capabilities
 
-```typescript
-.index(bm25Index({ keyField: 'id', fields: [bm25.text('body')] }))
-.index(bm25Index({ keyField: 'uuid', fields: [bm25.text('body')] }))
-```
+- `paradedb/bm25` — indicates support for BM25 full-text search indexes
 
-## Tokenizers
-
-All 12 built-in ParadeDB tokenizers are available via the `TokenizerId` type:
-
-| Tokenizer | Description |
-|-----------|-------------|
-| `unicode_words` | Default. Unicode word boundaries (UAX #29). Lowercases. |
-| `simple` | Splits on non-alphanumeric. Lowercases. |
-| `ngram` | Character n-grams of configurable length. |
-| `icu` | ICU Unicode standard segmentation. Multilingual. |
-| `regex_pattern` | Regex-based tokenization. |
-| `source_code` | camelCase / snake_case splitting. |
-| `literal` | No splitting. Exact match, sort, aggregation. |
-| `literal_normalized` | Literal + lowercase + token filters. |
-| `whitespace` | Whitespace splitting + lowercase. |
-| `chinese_compatible` | CJK-aware word segmentation. |
-| `jieba` | Chinese segmentation via Jieba. |
-| `lindera` | Japanese/Korean/Chinese via Lindera. |
+## Authoring (maintainers)
 
-## Capabilities
+The extension's contract + baseline migration are emitted on-disk inside this package using the same pipeline application authors use:
 
-The extension declares:
+- `pnpm build:contract-space` — runs `prisma-next contract emit` to produce `src/contract.{json,d.ts}` from the PSL source at `src/contract.prisma`.
+- `pnpm exec prisma-next migration plan --name <slug>` (run from this package directory) — scaffolds a new migration directory under `migrations/<dirName>/` for schema changes. **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: paradedb's contract declares no tables or models, so the planner currently refuses to scaffold the baseline migration (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 or 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`.
 
-- `paradedb/bm25`: Indicates support for BM25 full-text search indexes
+The descriptor at `src/exports/control.ts` then JSON-imports those artefacts and synthesises the framework's `MigrationPackage` shape.
 
-## Not Yet Implemented
+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.
 
-The following are planned for follow-up work:
+## Not yet implemented
 
-- **Query plane**: `@@@` operator support in the sql-orm query builder
-- **Query plane**: `pdb.*` query builder functions (match, term, phrase, fuzzy, etc.)
-- **Migration plane**: `CREATE INDEX ... USING bm25` DDL generation from contract diffs
-- **Runtime**: Scoring, aggregation, and highlight functions
-- **Database dependencies**: `CREATE EXTENSION pg_search` via migration planner
+- Per-column / per-expression tokenizer configuration (deferred to expression-index support)
+- `@@@` operator and `pdb.*` query builder functions
+- Scoring, aggregation, and highlight functions
 
 ## References
 
 - [ParadeDB documentation](https://docs.paradedb.com/)
 - [ParadeDB CREATE INDEX](https://docs.paradedb.com/documentation/indexing/create-index)
-- [ParadeDB Tokenizers](https://docs.paradedb.com/documentation/tokenizers/overview)
-- [pg_search source](https://github.com/paradedb/paradedb/tree/main/pg_search)
+- [ADR 210 — Index-type registry](../../../docs/architecture%20docs/adrs/ADR%20210%20-%20Index-type%20registry.md)
+- [ADR 212 — Contract spaces](../../../docs/architecture%20docs/adrs/ADR%20212%20-%20Contract%20spaces.md)
 - [Prisma Next Architecture Overview](../../../docs/Architecture%20Overview.md)

package/dist/control.d.mts

@@ -1,3 +1,6 @@
+import * as _$_prisma_next_sql_contract_index_types0 from "@prisma-next/sql-contract/index-types";
+import { SqlControlExtensionDescriptor } from "@prisma-next/family-sql/control";
+
 //#region src/core/descriptor-meta.d.ts
 declare const paradedbPackMeta: {
   readonly kind: "extension";
@@ -10,7 +13,24 @@ declare const paradedbPackMeta: {
       readonly 'paradedb/bm25': true;
     };
   };
+  readonly indexTypes: _$_prisma_next_sql_contract_index_types0.IndexTypeBuilder<Record<never, never> & Record<"bm25", {
+    readonly options: {
+      key_field: string;
+    };
+  }>>;
+  readonly types: {
+    readonly queryOperationTypes: {
+      readonly import: {
+        readonly package: "@prisma-next/extension-paradedb/operation-types";
+        readonly named: "QueryOperationTypes";
+        readonly alias: "ParadeDbQueryOperationTypes";
+      };
+    };
+  };
 };
 //#endregion
-export { paradedbPackMeta };
+//#region src/exports/control.d.ts
+declare const paradedbExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'>;
+//#endregion
+export { paradedbExtensionDescriptor as default, paradedbExtensionDescriptor, paradedbPackMeta };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":[],"mappings":";cAEa;EAAA,SAAA,IAAA,EAAA,WAWH"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts","../src/exports/control.ts"],"mappings":";;;;cAgMa,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cCtIP,2BAAA,EAA6B,6BAAA"}

package/dist/control.mjs

@@ -1,3 +1,133 @@
-import { t as paradedbPackMeta } from "./descriptor-meta-BTFnIGJ6.mjs";
+import { n as paradedbQueryOperations, r as PARADEDB_SPACE_ID, t as paradedbPackMeta } from "./descriptor-meta-Dr4mAlbx.mjs";
+import { contractSpaceFromJson } from "@prisma-next/migration-tools/spaces";
+//#endregion
+//#region src/exports/control.ts
+const paradedbContractSpace = contractSpaceFromJson({
+	contractJson: {
+		schemaVersion: "1",
+		targetFamily: "sql",
+		target: "postgres",
+		profileHash: "sha256:1a8dbe044289f30a1de958fe800cc5a8378b285d2e126a8c44b58864bac2c18e",
+		roots: {},
+		models: {},
+		storage: {
+			"storageHash": "sha256:7d13ea93bd4726b9962c00ced807a79149e3ff69e0a47d936c0e82f39a637393",
+			"tables": {}
+		},
+		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"
+		}
+	},
+	migrations: [{
+		dirName: "20260601T0000_install_pg_search_extension",
+		metadata: {
+			from: null,
+			to: "sha256:7d13ea93bd4726b9962c00ced807a79149e3ff69e0a47d936c0e82f39a637393",
+			labels: [],
+			providedInvariants: ["paradedb:install-pg-search-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:7d13ea93bd4726b9962c00ced807a79149e3ff69e0a47d936c0e82f39a637393",
+					"tables": {}
+				},
+				"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:3eb230aa63c65ee27e664c067dbf6a23c59e03fd0ad34b3f09d74fe4053b3ab4"
+		},
+		ops: [{
+			"id": "paradedb.install-pg-search-extension",
+			"label": "Enable extension \"pg_search\"",
+			"operationClass": "additive",
+			"invariantId": "paradedb:install-pg-search-v1",
+			"target": {
+				"id": "postgres",
+				"details": {
+					"schema": "public",
+					"objectType": "dependency",
+					"name": "pg_search"
+				}
+			},
+			"precheck": [{
+				"description": "verify extension \"pg_search\" is not already enabled",
+				"sql": "SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')"
+			}],
+			"execute": [{
+				"description": "create extension \"pg_search\"",
+				"sql": "CREATE EXTENSION IF NOT EXISTS pg_search"
+			}],
+			"postcheck": [{
+				"description": "confirm extension \"pg_search\" is enabled",
+				"sql": "SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')"
+			}]
+		}]
+	}],
+	headRef: {
+		hash: "sha256:7d13ea93bd4726b9962c00ced807a79149e3ff69e0a47d936c0e82f39a637393",
+		invariants: ["paradedb:install-pg-search-v1"]
+	}
+});
+const paradedbExtensionDescriptor = {
+	...paradedbPackMeta,
+	id: PARADEDB_SPACE_ID,
+	contractSpace: paradedbContractSpace,
+	queryOperations: () => paradedbQueryOperations(),
+	create: () => ({
+		familyId: "sql",
+		targetId: "postgres"
+	})
+};
+//#endregion
+export { paradedbExtensionDescriptor as default, paradedbExtensionDescriptor, paradedbPackMeta };
 
-export { paradedbPackMeta };
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":["baselineMetadata","baselineOps"],"sources":["../migrations/20260601T0000_install_pg_search_extension/migration.json","../migrations/20260601T0000_install_pg_search_extension/ops.json","../migrations/refs/head.json","../src/contract.json","../src/exports/control.ts"],"sourcesContent":["","","","","/**\n * Control-plane descriptor for the paradedb 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 *   - `queryOperations` — BM25 full-text search operations registered\n *     via `paradedbQueryOperations()`.\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 { SqlControlExtensionDescriptor } 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_pg_search_extension/migration.json' with {\n  type: 'json',\n};\nimport baselineOps from '../../migrations/20260601T0000_install_pg_search_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 { PARADEDB_SPACE_ID } from '../core/constants';\nimport { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';\n\nconst BASELINE_DIR_NAME = '20260601T0000_install_pg_search_extension';\n\nconst paradedbContractSpace = 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 paradedbExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {\n  ...paradedbPackMeta,\n  id: PARADEDB_SPACE_ID,\n  contractSpace: paradedbContractSpace,\n  queryOperations: () => paradedbQueryOperations(),\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n};\n\nexport { paradedbExtensionDescriptor, paradedbPackMeta };\nexport default paradedbExtensionDescriptor;\n"],"mappings":";;;;AI8CA,MAAM,wBAAwB,sBAA4C;CACxE,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA;CACA,YAAY,CACV;EACE,SAAS;EACT,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAAA;EACV,KAAKC;;;;;;;;;;;;;;;;;;;;;;;;;IAAAA;EACN,CACF;CACD,SAAA;;;EAAA;CACD,CAAC;AAEF,MAAM,8BAAyE;CAC7E,GAAG;CACH,IAAI;CACJ,eAAe;CACf,uBAAuB,yBAAyB;CAChD,eAAe;EACb,UAAU;EACV,UAAU;EACX;CACF"}

package/dist/descriptor-meta-Dr4mAlbx.mjs

@@ -0,0 +1,276 @@
+import { t as paradedbIndexTypes } from "./index-types-BZqoAhWT.mjs";
+import { LiteralExpr, OperationExpr } from "@prisma-next/sql-relational-core/ast";
+import { buildOperation, toExpr } from "@prisma-next/sql-relational-core/expression";
+//#region src/core/constants.ts
+/**
+* Extension ID for ParadeDB pg_search.
+*/
+const PARADEDB_EXTENSION_ID = "paradedb";
+/**
+* Static names and identifiers used across paradedb'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 `'paradedb'` is what the framework writes to
+* `migrations/` in the user's repo and what the marker table's
+* `space` column carries for paradedb-owned rows.
+*
+* The `paradedb:*` invariantId namespace is locked here — once
+* published, an invariantId is immutable so downstream consumers can
+* reference it by literal string match.
+*/
+const PARADEDB_SPACE_ID = "paradedb";
+//#endregion
+//#region src/core/proximity-chain.ts
+const TEXT$1 = "pg/text@1";
+var ParadeDbProximityChain = class ParadeDbProximityChain {
+	returnType = {
+		codecId: TEXT$1,
+		nullable: false
+	};
+	start;
+	steps;
+	constructor(start, steps = []) {
+		this.start = start;
+		this.steps = steps;
+	}
+	within(distance, term, options) {
+		if (!Number.isInteger(distance) || distance < 0) throw new Error(`paradeDbProximity.within: distance must be a non-negative integer; got ${String(distance)}`);
+		return new ParadeDbProximityChain(this.start, [...this.steps, {
+			distance,
+			term,
+			ordered: options?.ordered === true
+		}]);
+	}
+	buildAst() {
+		if (this.steps.length === 0) throw new Error("paradeDbProximity: chain must have at least one .within(distance, term) step");
+		const args = [toExpr(this.start, TEXT$1)];
+		let template = "({{self}}";
+		this.steps.forEach((step, i) => {
+			const op = step.ordered ? "##>" : "##";
+			args.push(LiteralExpr.of(step.distance));
+			args.push(toExpr(step.term, TEXT$1));
+			template += ` ${op} {{arg${2 * i}}} ${op} {{arg${2 * i + 1}}}`;
+		});
+		template += ")";
+		const [self, ...rest] = args;
+		if (!self) throw new Error("paradeDbProximity: invariant violation — empty args");
+		return new OperationExpr({
+			method: "paradeDbProximity",
+			self,
+			args: rest.length > 0 ? rest : void 0,
+			returns: this.returnType,
+			lowering: {
+				targetFamily: "sql",
+				strategy: "function",
+				template
+			}
+		});
+	}
+};
+//#endregion
+//#region src/core/descriptor-meta.ts
+const TEXT = "pg/text@1";
+const BOOL = "pg/bool@1";
+const FLOAT4 = "pg/float4@1";
+const INT4 = "pg/int4@1";
+function paradedbQueryOperations() {
+	return {
+		paradeDbMatch: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbMatch",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} @@@ {{arg0}}"
+				}
+			})
+		},
+		paradeDbMatchAny: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbMatchAny",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} ||| {{arg0}}"
+				}
+			})
+		},
+		paradeDbMatchAll: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbMatchAll",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} &&& {{arg0}}"
+				}
+			})
+		},
+		paradeDbTerm: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbTerm",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} === {{arg0}}"
+				}
+			})
+		},
+		paradeDbPhrase: {
+			self: { codecId: TEXT },
+			impl: (self, query) => buildOperation({
+				method: "paradeDbPhrase",
+				args: [toExpr(self, TEXT), toExpr(query, TEXT)],
+				returns: {
+					codecId: BOOL,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "{{self}} ### {{arg0}}"
+				}
+			})
+		},
+		paradeDbScore: {
+			self: { codecId: INT4 },
+			impl: (self) => buildOperation({
+				method: "paradeDbScore",
+				args: [toExpr(self, INT4)],
+				returns: {
+					codecId: FLOAT4,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "function",
+					template: "pdb.score({{self}})"
+				}
+			})
+		},
+		paradeDbFuzzy: {
+			self: { codecId: TEXT },
+			impl: (self, distance) => {
+				if (!Number.isInteger(distance) || distance < 0 || distance > 2) throw new Error(`paradeDbFuzzy: distance must be an integer in [0, 2]; got ${String(distance)}`);
+				return buildOperation({
+					method: "paradeDbFuzzy",
+					args: [toExpr(self, TEXT), LiteralExpr.of(distance)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.fuzzy({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbBoost: {
+			self: { codecId: TEXT },
+			impl: (self, weight) => {
+				if (!Number.isInteger(weight) || weight < -2048 || weight > 2048) throw new Error(`paradeDbBoost: boost must be an integer in [-2048, 2048]; got ${String(weight)}`);
+				return buildOperation({
+					method: "paradeDbBoost",
+					args: [toExpr(self, TEXT), LiteralExpr.of(weight)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.boost({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbConst: {
+			self: { codecId: TEXT },
+			impl: (self, value) => {
+				if (!Number.isInteger(value)) throw new Error(`paradeDbConst: value must be an integer; got ${String(value)}`);
+				return buildOperation({
+					method: "paradeDbConst",
+					args: [toExpr(self, TEXT), LiteralExpr.of(value)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.const({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbSlop: {
+			self: { codecId: TEXT },
+			impl: (self, slop) => {
+				if (!Number.isInteger(slop) || slop < 0) throw new Error(`paradeDbSlop: slop must be a non-negative integer; got ${String(slop)}`);
+				return buildOperation({
+					method: "paradeDbSlop",
+					args: [toExpr(self, TEXT), LiteralExpr.of(slop)],
+					returns: {
+						codecId: TEXT,
+						nullable: false
+					},
+					lowering: {
+						targetFamily: "sql",
+						strategy: "function",
+						template: "{{self}}::pdb.slop({{arg0}})"
+					}
+				});
+			}
+		},
+		paradeDbProximity: {
+			self: { codecId: TEXT },
+			impl: (start) => new ParadeDbProximityChain(start)
+		}
+	};
+}
+const paradedbPackMeta = {
+	kind: "extension",
+	id: PARADEDB_EXTENSION_ID,
+	familyId: "sql",
+	targetId: "postgres",
+	version: "0.0.1",
+	capabilities: { postgres: { "paradedb/bm25": true } },
+	indexTypes: paradedbIndexTypes,
+	types: { queryOperationTypes: { import: {
+		package: "@prisma-next/extension-paradedb/operation-types",
+		named: "QueryOperationTypes",
+		alias: "ParadeDbQueryOperationTypes"
+	} } }
+};
+//#endregion
+export { paradedbQueryOperations as n, PARADEDB_SPACE_ID as r, paradedbPackMeta as t };
+
+//# sourceMappingURL=descriptor-meta-Dr4mAlbx.mjs.map