@prisma-next/extension-paradedb 0.5.0-dev.85 → 0.5.0-dev.87

package/dist/control.d.mts

@@ -1,4 +1,5 @@
 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: {
@@ -17,7 +18,19 @@ declare const paradedbPackMeta: {
       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"],"mappings":";;;cAGa,gBAAA;EAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts","../src/exports/control.ts"],"mappings":";;;;cAgMa,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cCtJP,2BAAA,EAA6B,6BAAA"}

package/dist/control.mjs

@@ -1,2 +1,38 @@
-import { t as paradedbPackMeta } from "./descriptor-meta-BF_fQseQ.mjs";
-export { paradedbPackMeta };
+import { n as paradedbQueryOperations, t as paradedbPackMeta } from "./descriptor-meta-CmokJ02r.mjs";
+//#region src/exports/control.ts
+const paradedbDatabaseDependencies = { init: [{
+	id: "postgres.extension.pg_search",
+	label: "Enable pg_search extension",
+	install: [{
+		id: "extension.pg_search",
+		label: "Enable extension \"pg_search\"",
+		summary: "Ensures the pg_search extension is available for ParadeDB BM25 operations",
+		operationClass: "additive",
+		target: { id: "postgres" },
+		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')"
+		}]
+	}]
+}] };
+const paradedbExtensionDescriptor = {
+	...paradedbPackMeta,
+	queryOperations: () => paradedbQueryOperations(),
+	databaseDependencies: paradedbDatabaseDependencies,
+	create: () => ({
+		familyId: "sql",
+		targetId: "postgres"
+	})
+};
+//#endregion
+export { paradedbExtensionDescriptor as default, paradedbExtensionDescriptor, paradedbPackMeta };
+
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":["import type {\n  ComponentDatabaseDependencies,\n  SqlControlExtensionDescriptor,\n} from '@prisma-next/family-sql/control';\nimport { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';\n\nconst paradedbDatabaseDependencies: ComponentDatabaseDependencies<unknown> = {\n  init: [\n    {\n      id: 'postgres.extension.pg_search',\n      label: 'Enable pg_search extension',\n      install: [\n        {\n          id: 'extension.pg_search',\n          label: 'Enable extension \"pg_search\"',\n          summary: 'Ensures the pg_search extension is available for ParadeDB BM25 operations',\n          operationClass: 'additive',\n          target: { id: 'postgres' },\n          precheck: [\n            {\n              description: 'verify extension \"pg_search\" is not already enabled',\n              sql: \"SELECT NOT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')\",\n            },\n          ],\n          execute: [\n            {\n              description: 'create extension \"pg_search\"',\n              sql: 'CREATE EXTENSION IF NOT EXISTS pg_search',\n            },\n          ],\n          postcheck: [\n            {\n              description: 'confirm extension \"pg_search\" is enabled',\n              sql: \"SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_search')\",\n            },\n          ],\n        },\n      ],\n    },\n  ],\n};\n\nconst paradedbExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {\n  ...paradedbPackMeta,\n  queryOperations: () => paradedbQueryOperations(),\n  databaseDependencies: paradedbDatabaseDependencies,\n  create: () => ({\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n  }),\n};\n\nexport { paradedbExtensionDescriptor, paradedbPackMeta };\nexport default paradedbExtensionDescriptor;\n"],"mappings":";;AAMA,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,uBAAuB,yBAAyB;CAChD,sBAAsB;CACtB,eAAe;EACb,UAAU;EACV,UAAU;EACX;CACF"}

package/dist/descriptor-meta-CmokJ02r.mjs

@@ -0,0 +1,260 @@
+import { t as paradedbIndexTypes } from "./index-types-BWFfNqUb.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";
+//#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, paradedbPackMeta as t };
+
+//# sourceMappingURL=descriptor-meta-CmokJ02r.mjs.map

package/dist/descriptor-meta-CmokJ02r.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-CmokJ02r.mjs","names":["TEXT"],"sources":["../src/core/constants.ts","../src/core/proximity-chain.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["/**\n * Extension ID for ParadeDB pg_search.\n */\nexport const PARADEDB_EXTENSION_ID = 'paradedb' as const;\n","import {\n  type AnyExpression,\n  LiteralExpr,\n  OperationExpr,\n} from '@prisma-next/sql-relational-core/ast';\nimport { type Expression, toExpr } from '@prisma-next/sql-relational-core/expression';\n\nconst TEXT = 'pg/text@1' as const;\n\nexport type ProximityTerm = unknown;\n\nexport interface ProximityWithinOptions {\n  readonly ordered?: boolean;\n}\n\ninterface ProximityStep {\n  readonly distance: number;\n  readonly term: ProximityTerm;\n  readonly ordered: boolean;\n}\n\n// https://docs.paradedb.com/documentation/full-text/proximity\nexport class ParadeDbProximityChain\n  implements Expression<{ codecId: 'pg/text@1'; nullable: false }>\n{\n  readonly returnType = { codecId: TEXT, nullable: false } as const;\n\n  private readonly start: ProximityTerm;\n  private readonly steps: readonly ProximityStep[];\n\n  constructor(start: ProximityTerm, steps: readonly ProximityStep[] = []) {\n    this.start = start;\n    this.steps = steps;\n  }\n\n  within(\n    distance: number,\n    term: ProximityTerm,\n    options?: ProximityWithinOptions,\n  ): ParadeDbProximityChain {\n    if (!Number.isInteger(distance) || distance < 0) {\n      throw new Error(\n        `paradeDbProximity.within: distance must be a non-negative integer; got ${String(distance)}`,\n      );\n    }\n    return new ParadeDbProximityChain(this.start, [\n      ...this.steps,\n      { distance, term, ordered: options?.ordered === true },\n    ]);\n  }\n\n  buildAst(): AnyExpression {\n    if (this.steps.length === 0) {\n      throw new Error(\n        'paradeDbProximity: chain must have at least one .within(distance, term) step',\n      );\n    }\n    const args: AnyExpression[] = [toExpr(this.start, TEXT)];\n    let template = '({{self}}';\n    this.steps.forEach((step, i) => {\n      const op = step.ordered ? '##>' : '##';\n      args.push(LiteralExpr.of(step.distance));\n      args.push(toExpr(step.term, TEXT));\n      template += ` ${op} {{arg${2 * i}}} ${op} {{arg${2 * i + 1}}}`;\n    });\n    template += ')';\n    const [self, ...rest] = args;\n    if (!self) {\n      throw new Error('paradeDbProximity: invariant violation — empty args');\n    }\n    return new OperationExpr({\n      method: 'paradeDbProximity',\n      self,\n      args: rest.length > 0 ? rest : undefined,\n      returns: this.returnType,\n      lowering: {\n        targetFamily: 'sql',\n        strategy: 'function',\n        template,\n      },\n    });\n  }\n}\n","import { LiteralExpr } from '@prisma-next/sql-relational-core/ast';\nimport { buildOperation, toExpr } from '@prisma-next/sql-relational-core/expression';\nimport { paradedbIndexTypes } from '../types/index-types';\nimport type { QueryOperationTypes } from '../types/operation-types';\nimport { PARADEDB_EXTENSION_ID } from './constants';\nimport { ParadeDbProximityChain } from './proximity-chain';\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\nconst TEXT = 'pg/text@1' as const;\nconst BOOL = 'pg/bool@1' as const;\nconst FLOAT4 = 'pg/float4@1' as const;\nconst INT4 = 'pg/int4@1' as const;\n\nexport function paradedbQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {\n  return {\n    // `@@@` accepts both text and structured query types on its RHS.\n    // https://docs.paradedb.com/documentation/full-text/match\n    paradeDbMatch: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbMatch',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} @@@ {{arg0}}',\n          },\n        }),\n    },\n    paradeDbMatchAny: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbMatchAny',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} ||| {{arg0}}',\n          },\n        }),\n    },\n    paradeDbMatchAll: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbMatchAll',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} &&& {{arg0}}',\n          },\n        }),\n    },\n    // https://docs.paradedb.com/documentation/full-text/term\n    paradeDbTerm: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbTerm',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} === {{arg0}}',\n          },\n        }),\n    },\n    // https://docs.paradedb.com/documentation/full-text/phrase\n    paradeDbPhrase: {\n      self: { codecId: TEXT },\n      impl: (self, query) =>\n        buildOperation({\n          method: 'paradeDbPhrase',\n          args: [toExpr(self, TEXT), toExpr(query, TEXT)],\n          returns: { codecId: BOOL, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}} ### {{arg0}}',\n          },\n        }),\n    },\n    // https://docs.paradedb.com/documentation/sorting/score\n    paradeDbScore: {\n      self: { codecId: INT4 },\n      impl: (self) =>\n        buildOperation({\n          method: 'paradeDbScore',\n          args: [toExpr(self, INT4)],\n          returns: { codecId: FLOAT4, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: 'pdb.score({{self}})',\n          },\n        }),\n    },\n    // PG rejects parameterized typmods, so the cast argument lowers to a literal.\n    // https://docs.paradedb.com/documentation/full-text/fuzzy\n    paradeDbFuzzy: {\n      self: { codecId: TEXT },\n      impl: (self, distance) => {\n        if (!Number.isInteger(distance) || distance < 0 || distance > 2) {\n          throw new Error(\n            `paradeDbFuzzy: distance must be an integer in [0, 2]; got ${String(distance)}`,\n          );\n        }\n        return buildOperation({\n          method: 'paradeDbFuzzy',\n          args: [toExpr(self, TEXT), LiteralExpr.of(distance)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.fuzzy({{arg0}})',\n          },\n        });\n      },\n    },\n    // https://docs.paradedb.com/documentation/sorting/boost\n    paradeDbBoost: {\n      self: { codecId: TEXT },\n      impl: (self, weight) => {\n        if (!Number.isInteger(weight) || weight < -2048 || weight > 2048) {\n          throw new Error(\n            `paradeDbBoost: boost must be an integer in [-2048, 2048]; got ${String(weight)}`,\n          );\n        }\n        return buildOperation({\n          method: 'paradeDbBoost',\n          args: [toExpr(self, TEXT), LiteralExpr.of(weight)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.boost({{arg0}})',\n          },\n        });\n      },\n    },\n    paradeDbConst: {\n      self: { codecId: TEXT },\n      impl: (self, value) => {\n        if (!Number.isInteger(value)) {\n          throw new Error(`paradeDbConst: value must be an integer; got ${String(value)}`);\n        }\n        return buildOperation({\n          method: 'paradeDbConst',\n          args: [toExpr(self, TEXT), LiteralExpr.of(value)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.const({{arg0}})',\n          },\n        });\n      },\n    },\n    paradeDbSlop: {\n      self: { codecId: TEXT },\n      impl: (self, slop) => {\n        if (!Number.isInteger(slop) || slop < 0) {\n          throw new Error(`paradeDbSlop: slop must be a non-negative integer; got ${String(slop)}`);\n        }\n        return buildOperation({\n          method: 'paradeDbSlop',\n          args: [toExpr(self, TEXT), LiteralExpr.of(slop)],\n          returns: { codecId: TEXT, nullable: false },\n          lowering: {\n            targetFamily: 'sql',\n            strategy: 'function',\n            template: '{{self}}::pdb.slop({{arg0}})',\n          },\n        });\n      },\n    },\n    // https://docs.paradedb.com/documentation/full-text/proximity\n    paradeDbProximity: {\n      self: { codecId: TEXT },\n      impl: (start) => new ParadeDbProximityChain(start),\n    },\n  };\n}\n\nexport const paradedbPackMeta = {\n  kind: 'extension',\n  id: PARADEDB_EXTENSION_ID,\n  familyId: 'sql',\n  targetId: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      'paradedb/bm25': true,\n    },\n  },\n  indexTypes: paradedbIndexTypes,\n  types: {\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/extension-paradedb/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'ParadeDbQueryOperationTypes',\n      },\n    },\n  },\n} as const;\n"],"mappings":"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"}

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

@@ -0,0 +1,135 @@
+import { AnyExpression } from "@prisma-next/sql-relational-core/ast";
+import { CodecExpression, Expression } from "@prisma-next/sql-relational-core/expression";
+import { SqlQueryOperationTypes } from "@prisma-next/sql-contract/types";
+
+//#region src/core/proximity-chain.d.ts
+type ProximityTerm = unknown;
+interface ProximityWithinOptions {
+  readonly ordered?: boolean;
+}
+interface ProximityStep {
+  readonly distance: number;
+  readonly term: ProximityTerm;
+  readonly ordered: boolean;
+}
+declare class ParadeDbProximityChain implements Expression<{
+  codecId: 'pg/text@1';
+  nullable: false;
+}> {
+  readonly returnType: {
+    readonly codecId: "pg/text@1";
+    readonly nullable: false;
+  };
+  private readonly start;
+  private readonly steps;
+  constructor(start: ProximityTerm, steps?: readonly ProximityStep[]);
+  within(distance: number, term: ProximityTerm, options?: ProximityWithinOptions): ParadeDbProximityChain;
+  buildAst(): AnyExpression;
+}
+//#endregion
+//#region src/types/operation-types.d.ts
+type CodecTypesBase = Record<string, {
+  readonly input: unknown;
+  readonly output: unknown;
+}>;
+type QueryOperationTypes<CT extends CodecTypesBase> = SqlQueryOperationTypes<CT, {
+  readonly paradeDbMatch: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, query: CodecExpression<'pg/text@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbMatchAny: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, query: CodecExpression<'pg/text@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbMatchAll: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, query: CodecExpression<'pg/text@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbTerm: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, query: CodecExpression<'pg/text@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbPhrase: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, query: CodecExpression<'pg/text@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbScore: {
+    readonly self: {
+      readonly codecId: 'pg/int4@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/int4@1', boolean, CT>) => Expression<{
+      codecId: 'pg/float4@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbFuzzy: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, distance: number) => Expression<{
+      codecId: 'pg/text@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbBoost: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, weight: number) => Expression<{
+      codecId: 'pg/text@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbConst: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, value: number) => Expression<{
+      codecId: 'pg/text@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbSlop: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/text@1', boolean, CT>, slop: number) => Expression<{
+      codecId: 'pg/text@1';
+      nullable: false;
+    }>;
+  };
+  readonly paradeDbProximity: {
+    readonly self: {
+      readonly codecId: 'pg/text@1';
+    };
+    readonly impl: (start: CodecExpression<'pg/text@1', boolean, CT>) => ParadeDbProximityChain;
+  };
+}>;
+//#endregion
+export { QueryOperationTypes as t };
+//# sourceMappingURL=operation-types-DXmTJ7jd.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operation-types-DXmTJ7jd.d.mts","names":[],"sources":["../src/core/proximity-chain.ts","../src/types/operation-types.ts"],"mappings":";;;;;KASY,aAAA;AAAA,UAEK,sBAAA;EAAA,SACN,OAAA;AAAA;AAAA,UAGD,aAAA;EAAA,SACC,QAAA;EAAA,SACA,IAAA,EAAM,aAAA;EAAA,SACN,OAAA;AAAA;AAAA,cAIE,sBAAA,YACA,UAAA;EAAa,OAAA;EAAsB,QAAA;AAAA;EAAA,SAErC,UAAA;IAAA;;;mBAEQ,KAAA;EAAA,iBACA,KAAA;cAEL,KAAA,EAAO,aAAA,EAAe,KAAA,YAAgB,aAAA;EAKlD,MAAA,CACE,QAAA,UACA,IAAA,EAAM,aAAA,EACN,OAAA,GAAU,sBAAA,GACT,sBAAA;EAYH,QAAA,CAAA,GAAY,aAAA;AAAA;;;KC/CT,cAAA,GAAiB,MAAA;EAAA,SAA0B,KAAA;EAAA,SAAyB,MAAA;AAAA;AAAA,KAE7D,mBAAA,YAA+B,cAAA,IAAkB,sBAAA,CAC3D,EAAA;EAAA,SAEW,aAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,KAAA,EAAO,eAAA,uBAAsC,EAAA,MAC1C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,gBAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,KAAA,EAAO,eAAA,uBAAsC,EAAA,MAC1C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,gBAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,KAAA,EAAO,eAAA,uBAAsC,EAAA,MAC1C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,YAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,KAAA,EAAO,eAAA,uBAAsC,EAAA,MAC1C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,cAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,KAAA,EAAO,eAAA,uBAAsC,EAAA,MAC1C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,aAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,MACzC,UAAA;MAAa,OAAA;MAAwB,QAAA;IAAA;EAAA;EAAA,SAEnC,aAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,QAAA,aACG,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,aAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,MAAA,aACG,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,aAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,KAAA,aACG,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,YAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,uBAAsC,EAAA,GAC5C,IAAA,aACG,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,iBAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GAAO,KAAA,EAAO,eAAA,uBAAsC,EAAA,MAAQ,sBAAA;EAAA;AAAA"}

package/dist/operation-types.d.mts

@@ -0,0 +1,2 @@
+import { t as QueryOperationTypes } from "./operation-types-DXmTJ7jd.mjs";
+export { type QueryOperationTypes };

package/dist/operation-types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/pack.d.mts

@@ -17,6 +17,15 @@ declare const paradedbPack: {
       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 { paradedbPack as default };

package/dist/pack.mjs

@@ -1,4 +1,4 @@
-import { t as paradedbPackMeta } from "./descriptor-meta-BF_fQseQ.mjs";
+import { t as paradedbPackMeta } from "./descriptor-meta-CmokJ02r.mjs";
 //#region src/exports/pack.ts
 const paradedbPack = paradedbPackMeta;
 //#endregion

package/dist/runtime.d.mts

@@ -0,0 +1,7 @@
+import { SqlRuntimeExtensionDescriptor } from "@prisma-next/sql-runtime";
+
+//#region src/exports/runtime.d.ts
+declare const paradedbRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>;
+//#endregion
+export { paradedbRuntimeDescriptor as default };
+//# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/exports/runtime.ts"],"mappings":";;;cAGM,yBAAA,EAA2B,6BAAA"}

package/dist/runtime.mjs

@@ -0,0 +1,21 @@
+import { n as paradedbQueryOperations, t as paradedbPackMeta } from "./descriptor-meta-CmokJ02r.mjs";
+//#region src/exports/runtime.ts
+const paradedbRuntimeDescriptor = {
+	kind: "extension",
+	id: paradedbPackMeta.id,
+	version: paradedbPackMeta.version,
+	familyId: "sql",
+	targetId: "postgres",
+	codecs: () => [],
+	queryOperations: () => paradedbQueryOperations(),
+	create() {
+		return {
+			familyId: "sql",
+			targetId: "postgres"
+		};
+	}
+};
+//#endregion
+export { paradedbRuntimeDescriptor as default };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';\nimport { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';\n\nconst paradedbRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {\n  kind: 'extension' as const,\n  id: paradedbPackMeta.id,\n  version: paradedbPackMeta.version,\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  codecs: () => [],\n  queryOperations: () => paradedbQueryOperations(),\n  create() {\n    return {\n      familyId: 'sql' as const,\n      targetId: 'postgres' as const,\n    };\n  },\n};\n\nexport default paradedbRuntimeDescriptor;\n"],"mappings":";;AAGA,MAAM,4BAAuE;CAC3E,MAAM;CACN,IAAI,iBAAiB;CACrB,SAAS,iBAAiB;CAC1B,UAAU;CACV,UAAU;CACV,cAAc,EAAE;CAChB,uBAAuB,yBAAyB;CAChD,SAAS;EACP,OAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ"}

package/package.json

@@ -1,21 +1,30 @@
 {
   "name": "@prisma-next/extension-paradedb",
-  "version": "0.5.0-dev.85",
+  "version": "0.5.0-dev.87",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
     "arktype": "^2.1.25",
-    "@prisma-next/contract": "0.5.0-dev.85",
-    "@prisma-next/sql-contract": "0.5.0-dev.85",
-    "@prisma-next/contract-authoring": "0.5.0-dev.85"
+    "@prisma-next/contract": "0.5.0-dev.87",
+    "@prisma-next/contract-authoring": "0.5.0-dev.87",
+    "@prisma-next/framework-components": "0.5.0-dev.87",
+    "@prisma-next/family-sql": "0.5.0-dev.87",
+    "@prisma-next/sql-operations": "0.5.0-dev.87",
+    "@prisma-next/sql-contract": "0.5.0-dev.87",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.87",
+    "@prisma-next/sql-runtime": "0.5.0-dev.87"
   },
   "devDependencies": {
     "tsdown": "0.22.0",
     "typescript": "5.9.3",
     "vitest": "4.1.5",
+    "@prisma-next/adapter-postgres": "0.5.0-dev.87",
+    "@prisma-next/operations": "0.5.0-dev.87",
+    "@prisma-next/sql-contract-ts": "0.5.0-dev.87",
+    "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/tsconfig": "0.0.0"
+    "@prisma-next/test-utils": "0.0.1"
   },
   "files": [
     "dist",
@@ -24,7 +33,9 @@
   "exports": {
     "./control": "./dist/control.mjs",
     "./index-types": "./dist/index-types.mjs",
+    "./operation-types": "./dist/operation-types.mjs",
     "./pack": "./dist/pack.mjs",
+    "./runtime": "./dist/runtime.mjs",
     "./package.json": "./package.json"
   },
   "repository": {

package/src/core/descriptor-meta.ts

@@ -1,5 +1,194 @@
+import { LiteralExpr } from '@prisma-next/sql-relational-core/ast';
+import { buildOperation, toExpr } from '@prisma-next/sql-relational-core/expression';
 import { paradedbIndexTypes } from '../types/index-types';
+import type { QueryOperationTypes } from '../types/operation-types';
 import { PARADEDB_EXTENSION_ID } from './constants';
+import { ParadeDbProximityChain } from './proximity-chain';
+
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+const TEXT = 'pg/text@1' as const;
+const BOOL = 'pg/bool@1' as const;
+const FLOAT4 = 'pg/float4@1' as const;
+const INT4 = 'pg/int4@1' as const;
+
+export function paradedbQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {
+  return {
+    // `@@@` accepts both text and structured query types on its RHS.
+    // https://docs.paradedb.com/documentation/full-text/match
+    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}}',
+          },
+        }),
+    },
+    // https://docs.paradedb.com/documentation/full-text/term
+    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}}',
+          },
+        }),
+    },
+    // https://docs.paradedb.com/documentation/full-text/phrase
+    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}}',
+          },
+        }),
+    },
+    // https://docs.paradedb.com/documentation/sorting/score
+    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}})',
+          },
+        }),
+    },
+    // PG rejects parameterized typmods, so the cast argument lowers to a literal.
+    // https://docs.paradedb.com/documentation/full-text/fuzzy
+    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}})',
+          },
+        });
+      },
+    },
+    // https://docs.paradedb.com/documentation/sorting/boost
+    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}})',
+          },
+        });
+      },
+    },
+    // https://docs.paradedb.com/documentation/full-text/proximity
+    paradeDbProximity: {
+      self: { codecId: TEXT },
+      impl: (start) => new ParadeDbProximityChain(start),
+    },
+  };
+}
 
 export const paradedbPackMeta = {
   kind: 'extension',
@@ -13,4 +202,13 @@ export const paradedbPackMeta = {
     },
   },
   indexTypes: paradedbIndexTypes,
+  types: {
+    queryOperationTypes: {
+      import: {
+        package: '@prisma-next/extension-paradedb/operation-types',
+        named: 'QueryOperationTypes',
+        alias: 'ParadeDbQueryOperationTypes',
+      },
+    },
+  },
 } as const;

package/src/core/proximity-chain.ts

@@ -0,0 +1,83 @@
+import {
+  type AnyExpression,
+  LiteralExpr,
+  OperationExpr,
+} from '@prisma-next/sql-relational-core/ast';
+import { type Expression, toExpr } from '@prisma-next/sql-relational-core/expression';
+
+const TEXT = 'pg/text@1' as const;
+
+export type ProximityTerm = unknown;
+
+export interface ProximityWithinOptions {
+  readonly ordered?: boolean;
+}
+
+interface ProximityStep {
+  readonly distance: number;
+  readonly term: ProximityTerm;
+  readonly ordered: boolean;
+}
+
+// https://docs.paradedb.com/documentation/full-text/proximity
+export class ParadeDbProximityChain
+  implements Expression<{ codecId: 'pg/text@1'; nullable: false }>
+{
+  readonly returnType = { codecId: TEXT, nullable: false } as const;
+
+  private readonly start: ProximityTerm;
+  private readonly steps: readonly ProximityStep[];
+
+  constructor(start: ProximityTerm, steps: readonly ProximityStep[] = []) {
+    this.start = start;
+    this.steps = steps;
+  }
+
+  within(
+    distance: number,
+    term: ProximityTerm,
+    options?: ProximityWithinOptions,
+  ): ParadeDbProximityChain {
+    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(): AnyExpression {
+    if (this.steps.length === 0) {
+      throw new Error(
+        'paradeDbProximity: chain must have at least one .within(distance, term) step',
+      );
+    }
+    const args: AnyExpression[] = [toExpr(this.start, TEXT)];
+    let template = '({{self}}';
+    this.steps.forEach((step, i) => {
+      const op = step.ordered ? '##>' : '##';
+      args.push(LiteralExpr.of(step.distance));
+      args.push(toExpr(step.term, TEXT));
+      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 : undefined,
+      returns: this.returnType,
+      lowering: {
+        targetFamily: 'sql',
+        strategy: 'function',
+        template,
+      },
+    });
+  }
+}

package/src/exports/control.ts

@@ -1,3 +1,54 @@
-import { paradedbPackMeta } from '../core/descriptor-meta';
+import type {
+  ComponentDatabaseDependencies,
+  SqlControlExtensionDescriptor,
+} from '@prisma-next/family-sql/control';
+import { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';
 
-export { paradedbPackMeta };
+const paradedbDatabaseDependencies: ComponentDatabaseDependencies<unknown> = {
+  init: [
+    {
+      id: 'postgres.extension.pg_search',
+      label: 'Enable pg_search extension',
+      install: [
+        {
+          id: 'extension.pg_search',
+          label: 'Enable extension "pg_search"',
+          summary: 'Ensures the pg_search extension is available for ParadeDB BM25 operations',
+          operationClass: 'additive',
+          target: { id: 'postgres' },
+          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')",
+            },
+          ],
+        },
+      ],
+    },
+  ],
+};
+
+const paradedbExtensionDescriptor: SqlControlExtensionDescriptor<'postgres'> = {
+  ...paradedbPackMeta,
+  queryOperations: () => paradedbQueryOperations(),
+  databaseDependencies: paradedbDatabaseDependencies,
+  create: () => ({
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+  }),
+};
+
+export { paradedbExtensionDescriptor, paradedbPackMeta };
+export default paradedbExtensionDescriptor;

package/src/exports/operation-types.ts

@@ -0,0 +1 @@
+export type { QueryOperationTypes } from '../types/operation-types';

package/src/exports/runtime.ts

@@ -0,0 +1,20 @@
+import type { SqlRuntimeExtensionDescriptor } from '@prisma-next/sql-runtime';
+import { paradedbPackMeta, paradedbQueryOperations } from '../core/descriptor-meta';
+
+const paradedbRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
+  kind: 'extension' as const,
+  id: paradedbPackMeta.id,
+  version: paradedbPackMeta.version,
+  familyId: 'sql' as const,
+  targetId: 'postgres' as const,
+  codecs: () => [],
+  queryOperations: () => paradedbQueryOperations(),
+  create() {
+    return {
+      familyId: 'sql' as const,
+      targetId: 'postgres' as const,
+    };
+  },
+};
+
+export default paradedbRuntimeDescriptor;

package/src/types/operation-types.ts

@@ -0,0 +1,84 @@
+import type { SqlQueryOperationTypes } from '@prisma-next/sql-contract/types';
+import type { CodecExpression, Expression } from '@prisma-next/sql-relational-core/expression';
+import type { ParadeDbProximityChain } from '../core/proximity-chain';
+
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export type QueryOperationTypes<CT extends CodecTypesBase> = SqlQueryOperationTypes<
+  CT,
+  {
+    readonly paradeDbMatch: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbMatchAny: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbMatchAll: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbTerm: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbPhrase: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        query: CodecExpression<'pg/text@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/bool@1'; nullable: false }>;
+    };
+    readonly paradeDbScore: {
+      readonly self: { readonly codecId: 'pg/int4@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/int4@1', boolean, CT>,
+      ) => Expression<{ codecId: 'pg/float4@1'; nullable: false }>;
+    };
+    readonly paradeDbFuzzy: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        distance: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbBoost: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        weight: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbConst: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        value: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbSlop: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (
+        self: CodecExpression<'pg/text@1', boolean, CT>,
+        slop: number,
+      ) => Expression<{ codecId: 'pg/text@1'; nullable: false }>;
+    };
+    readonly paradeDbProximity: {
+      readonly self: { readonly codecId: 'pg/text@1' };
+      readonly impl: (start: CodecExpression<'pg/text@1', boolean, CT>) => ParadeDbProximityChain;
+    };
+  }
+>;

package/dist/descriptor-meta-BF_fQseQ.mjs

@@ -1,16 +0,0 @@
-import { t as paradedbIndexTypes } from "./index-types-BWFfNqUb.mjs";
-//#endregion
-//#region src/core/descriptor-meta.ts
-const paradedbPackMeta = {
-	kind: "extension",
-	id: "paradedb",
-	familyId: "sql",
-	targetId: "postgres",
-	version: "0.0.1",
-	capabilities: { postgres: { "paradedb/bm25": true } },
-	indexTypes: paradedbIndexTypes
-};
-//#endregion
-export { paradedbPackMeta as t };
-
-//# sourceMappingURL=descriptor-meta-BF_fQseQ.mjs.map

package/dist/descriptor-meta-BF_fQseQ.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-BF_fQseQ.mjs","names":[],"sources":["../src/core/constants.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["/**\n * Extension ID for ParadeDB pg_search.\n */\nexport const PARADEDB_EXTENSION_ID = 'paradedb' as const;\n","import { paradedbIndexTypes } from '../types/index-types';\nimport { PARADEDB_EXTENSION_ID } from './constants';\n\nexport const paradedbPackMeta = {\n  kind: 'extension',\n  id: PARADEDB_EXTENSION_ID,\n  familyId: 'sql',\n  targetId: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      'paradedb/bm25': true,\n    },\n  },\n  indexTypes: paradedbIndexTypes,\n} as const;\n"],"mappings":";;;ACGA,MAAa,mBAAmB;CAC9B,MAAM;CACN,IAAI;CACJ,UAAU;CACV,UAAU;CACV,SAAS;CACT,cAAc,EACZ,UAAU,EACR,iBAAiB,MAClB,EACF;CACD,YAAY;CACb"}