prisma-ltree 0.0.1 → 0.1.1

package/dist/descriptor-meta-B84muAZG.mjs

@@ -0,0 +1,345 @@
+import { a as LTREE_ARRAY_CODEC_ID, c as LTREE_MAX_LABEL_LENGTH, o as LTREE_CODEC_ID, r as LTREE_NATIVE_TYPE, s as LTREE_MAX_LABELS, t as LTREE_ARRAY_NATIVE_TYPE } from "./contract-space-constants-Da9EC668.mjs";
+import { buildOperation, codecOf, toExpr } from "@prisma-next/sql-relational-core/expression";
+import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
+import { CodecDescriptorImpl, CodecImpl, voidParamsSchema } from "@prisma-next/framework-components/codec";
+//#region src/core/authoring.ts
+const ltreeAuthoringTypes = { ltree: {
+	Ltree: {
+		kind: "typeConstructor",
+		output: {
+			codecId: LTREE_CODEC_ID,
+			nativeType: LTREE_NATIVE_TYPE
+		}
+	},
+	LtreeArray: {
+		kind: "typeConstructor",
+		output: {
+			codecId: LTREE_ARRAY_CODEC_ID,
+			nativeType: LTREE_ARRAY_NATIVE_TYPE
+		}
+	}
+} };
+//#endregion
+//#region src/core/codecs.ts
+const LABEL_PATTERN = /^[A-Za-z0-9_-]+$/;
+function assertValidLtree(value) {
+	if (typeof value !== "string") throw new Error("ltree value must be a string");
+	if (value.length === 0) throw new Error("ltree value must not be empty");
+	const labels = value.split(".");
+	if (labels.length > 65535) throw new Error(`ltree path exceeds max labels: got ${labels.length}, max ${LTREE_MAX_LABELS}`);
+	for (const label of labels) {
+		if (label.length === 0) throw new Error(`ltree label must not be empty in path "${value}"`);
+		if (label.length > 1e3) throw new Error(`ltree label exceeds max length: got ${label.length}, max ${LTREE_MAX_LABEL_LENGTH}`);
+		if (!LABEL_PATTERN.test(label)) throw new Error(`ltree label "${label}" contains invalid characters; allowed: alphanumeric, underscore, hyphen`);
+	}
+}
+var LtreeCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		assertValidLtree(value);
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		assertValidLtree(value);
+		return value;
+	}
+	decodeJson(json) {
+		assertValidLtree(json);
+		return json;
+	}
+};
+const LTREE_META = { db: { sql: { postgres: { nativeType: LTREE_NATIVE_TYPE } } } };
+var LtreeDescriptor = class extends CodecDescriptorImpl {
+	codecId = LTREE_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = [LTREE_NATIVE_TYPE];
+	meta = LTREE_META;
+	paramsSchema = voidParamsSchema;
+	renderOutputType() {
+		return "string";
+	}
+	factory() {
+		const shared = new LtreeCodec(this);
+		return () => shared;
+	}
+};
+const ltreeDescriptor = new LtreeDescriptor();
+const LTREE_ARRAY_META = { db: { sql: { postgres: { nativeType: LTREE_ARRAY_NATIVE_TYPE } } } };
+var LtreeArrayCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		for (const entry of value) assertValidLtree(entry);
+		return value;
+	}
+	async decode(wire, _ctx) {
+		return wire;
+	}
+	encodeJson(value) {
+		for (const entry of value) assertValidLtree(entry);
+		return [...value];
+	}
+	decodeJson(json) {
+		if (!Array.isArray(json)) return [];
+		return json.map((entry) => {
+			assertValidLtree(entry);
+			return String(entry);
+		});
+	}
+};
+var LtreeArrayDescriptor = class extends CodecDescriptorImpl {
+	codecId = LTREE_ARRAY_CODEC_ID;
+	traits = ["equality"];
+	targetTypes = [LTREE_ARRAY_NATIVE_TYPE];
+	meta = LTREE_ARRAY_META;
+	paramsSchema = voidParamsSchema;
+	renderOutputType() {
+		return "readonly string[]";
+	}
+	factory() {
+		const shared = new LtreeArrayCodec(this);
+		return () => shared;
+	}
+};
+const codecDescriptorMap = {
+	ltree: ltreeDescriptor,
+	ltreeArray: new LtreeArrayDescriptor()
+};
+//#endregion
+//#region src/core/registry.ts
+const ltreeCodecRegistry = buildCodecDescriptorRegistry(Object.values(codecDescriptorMap));
+//#endregion
+//#region src/core/descriptor-meta.ts
+const BOOL_RETURN = {
+	codecId: "pg/bool@1",
+	nullable: false
+};
+const LTREE_RETURN = {
+	codecId: "pg/ltree@1",
+	nullable: false
+};
+const INT_RETURN = {
+	codecId: "pg/int4@1",
+	nullable: false
+};
+const TEXT_RETURN = {
+	codecId: "pg/text@1",
+	nullable: false
+};
+const TEXT_CODEC_ID = "pg/text@1";
+const TEXT_ARRAY_CODEC_ID = "pg/text-array@1";
+const INT_CODEC_ID = "pg/int4@1";
+/**
+* Build a function-style operation whose SQL is `fnName(self, arg0, arg1, ...)`.
+* The template's placeholder count is derived from the actual argument list, so
+* one helper covers fixed-arity functions (`nlevel`, `subltree`), optional-arg
+* overloads (`subpath`, `index`), and the variadic `lca` (see ADR-001). `args`
+* already carries each value through `toExpr` with its codec; `args[0]` is the
+* `self` receiver.
+*/
+function funcOp(method, fnName, returns, args) {
+	return buildOperation({
+		method,
+		args,
+		returns,
+		lowering: {
+			targetFamily: "sql",
+			strategy: "function",
+			template: `${fnName}(${args.map((_, i) => i === 0 ? "{{self}}" : `{{arg${i - 1}}}`).join(", ")})`
+		}
+	});
+}
+function ltreeQueryOperations() {
+	const hierarchyOp = (method, operator, self, other) => {
+		const selfCodec = codecOf(self);
+		return buildOperation({
+			method,
+			args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],
+			returns: BOOL_RETURN,
+			lowering: {
+				targetFamily: "sql",
+				strategy: "function",
+				template: `{{self}} ${operator} {{arg0}}`
+			}
+		});
+	};
+	const patternOp = (method, operator, castType, argCodecId, self, arg) => {
+		return buildOperation({
+			method,
+			args: [toExpr(self, codecOf(self)), toExpr(arg, { codecId: argCodecId })],
+			returns: BOOL_RETURN,
+			lowering: {
+				targetFamily: "sql",
+				strategy: "function",
+				template: `{{self}} ${operator} ({{arg0}})::${castType}`
+			}
+		});
+	};
+	const concatOp = (method, template, args) => buildOperation({
+		method,
+		args,
+		returns: LTREE_RETURN,
+		lowering: {
+			targetFamily: "sql",
+			strategy: "function",
+			template
+		}
+	});
+	const firstMatchOp = (method, operator, self, arg, argCodecId, castType) => {
+		const selfCodec = codecOf(self);
+		const template = castType ? `{{self}} ${operator} ({{arg0}})::${castType}` : `{{self}} ${operator} {{arg0}}`;
+		return buildOperation({
+			method,
+			args: [toExpr(self, selfCodec), toExpr(arg, { codecId: argCodecId })],
+			returns: LTREE_RETURN,
+			lowering: {
+				targetFamily: "sql",
+				strategy: "function",
+				template
+			}
+		});
+	};
+	return {
+		isAncestorOf: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, other) => hierarchyOp("isAncestorOf", "@>", self, other)
+		},
+		isDescendantOf: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, other) => hierarchyOp("isDescendantOf", "<@", self, other)
+		},
+		matchesLquery: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, pattern) => patternOp("matchesLquery", "~", "lquery", TEXT_CODEC_ID, self, pattern)
+		},
+		matchesLqueryArray: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, patterns) => patternOp("matchesLqueryArray", "?", "lquery[]", TEXT_ARRAY_CODEC_ID, self, patterns)
+		},
+		matchesLtxtquery: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, query) => patternOp("matchesLtxtquery", "@", "ltxtquery", TEXT_CODEC_ID, self, query)
+		},
+		nlevel: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self) => funcOp("nlevel", "nlevel", INT_RETURN, [toExpr(self, codecOf(self))])
+		},
+		subltree: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, start, end) => funcOp("subltree", "subltree", LTREE_RETURN, [
+				toExpr(self, codecOf(self)),
+				toExpr(start, { codecId: INT_CODEC_ID }),
+				toExpr(end, { codecId: INT_CODEC_ID })
+			])
+		},
+		subpath: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, offset, len) => {
+				const head = [toExpr(self, codecOf(self)), toExpr(offset, { codecId: INT_CODEC_ID })];
+				return funcOp("subpath", "subpath", LTREE_RETURN, len === void 0 ? head : [...head, toExpr(len, { codecId: INT_CODEC_ID })]);
+			}
+		},
+		indexOf: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, other, offset) => {
+				const selfCodec = codecOf(self);
+				const head = [toExpr(self, selfCodec), toExpr(other, selfCodec)];
+				return funcOp("indexOf", "index", INT_RETURN, offset === void 0 ? head : [...head, toExpr(offset, { codecId: INT_CODEC_ID })]);
+			}
+		},
+		lca: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, other, ...rest) => {
+				const selfCodec = codecOf(self);
+				return funcOp("lca", "lca", LTREE_RETURN, [
+					toExpr(self, selfCodec),
+					toExpr(other, selfCodec),
+					...rest.map((p) => toExpr(p, selfCodec))
+				]);
+			}
+		},
+		concat: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, other) => {
+				const selfCodec = codecOf(self);
+				return concatOp("concat", "{{self}} || {{arg0}}", [toExpr(self, selfCodec), toExpr(other, selfCodec)]);
+			}
+		},
+		concatText: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, label) => concatOp("concatText", "{{self}} || ({{arg0}})::text", [toExpr(self, codecOf(self)), toExpr(label, { codecId: TEXT_CODEC_ID })])
+		},
+		prependText: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self, prefix) => concatOp("prependText", "({{arg0}})::text || {{self}}", [toExpr(self, codecOf(self)), toExpr(prefix, { codecId: TEXT_CODEC_ID })])
+		},
+		toText: {
+			self: { codecId: LTREE_CODEC_ID },
+			impl: (self) => funcOp("toText", "ltree2text", TEXT_RETURN, [toExpr(self, codecOf(self))])
+		},
+		toLtree: {
+			self: { codecId: TEXT_CODEC_ID },
+			impl: (self) => funcOp("toLtree", "text2ltree", LTREE_RETURN, [toExpr(self, codecOf(self))])
+		},
+		firstAncestorOf: {
+			self: { codecId: LTREE_ARRAY_CODEC_ID },
+			impl: (self, other) => firstMatchOp("firstAncestorOf", "?@>", self, other, LTREE_CODEC_ID)
+		},
+		firstDescendantOf: {
+			self: { codecId: LTREE_ARRAY_CODEC_ID },
+			impl: (self, other) => firstMatchOp("firstDescendantOf", "?<@", self, other, LTREE_CODEC_ID)
+		},
+		firstMatchLquery: {
+			self: { codecId: LTREE_ARRAY_CODEC_ID },
+			impl: (self, pattern) => firstMatchOp("firstMatchLquery", "?~", self, pattern, TEXT_CODEC_ID, "lquery")
+		},
+		firstMatchLtxtquery: {
+			self: { codecId: LTREE_ARRAY_CODEC_ID },
+			impl: (self, query) => firstMatchOp("firstMatchLtxtquery", "?@", self, query, TEXT_CODEC_ID, "ltxtquery")
+		}
+	};
+}
+const ltreePackMeta = {
+	kind: "extension",
+	id: "ltree",
+	familyId: "sql",
+	targetId: "postgres",
+	version: "0.1.0",
+	capabilities: { postgres: { "ltree.path": true } },
+	authoring: { type: ltreeAuthoringTypes },
+	types: {
+		codecTypes: {
+			codecDescriptors: Array.from(ltreeCodecRegistry.values()),
+			import: {
+				package: "prisma-ltree/codec-types",
+				named: "CodecTypes",
+				alias: "LtreeTypes"
+			},
+			typeImports: [{
+				package: "prisma-ltree/codec-types",
+				named: "Ltree",
+				alias: "Ltree"
+			}]
+		},
+		queryOperationTypes: { import: {
+			package: "prisma-ltree/operation-types",
+			named: "QueryOperationTypes",
+			alias: "LtreeQueryOperationTypes"
+		} },
+		storage: [{
+			typeId: LTREE_CODEC_ID,
+			familyId: "sql",
+			targetId: "postgres",
+			nativeType: LTREE_NATIVE_TYPE
+		}, {
+			typeId: LTREE_ARRAY_CODEC_ID,
+			familyId: "sql",
+			targetId: "postgres",
+			nativeType: LTREE_ARRAY_NATIVE_TYPE
+		}]
+	}
+};
+//#endregion
+export { ltreeQueryOperations as n, ltreeCodecRegistry as r, ltreePackMeta as t };
+
+//# sourceMappingURL=descriptor-meta-B84muAZG.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-B84muAZG.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/codecs.ts","../src/core/registry.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import type { AuthoringTypeNamespace } from \"@prisma-next/framework-components/authoring\";\nimport { LTREE_ARRAY_CODEC_ID, LTREE_CODEC_ID } from \"./constants\";\nimport { LTREE_ARRAY_NATIVE_TYPE, LTREE_NATIVE_TYPE } from \"./contract-space-constants\";\n\nexport const ltreeAuthoringTypes = {\n  ltree: {\n    Ltree: {\n      kind: \"typeConstructor\",\n      output: {\n        codecId: LTREE_CODEC_ID,\n        nativeType: LTREE_NATIVE_TYPE,\n      },\n    },\n    LtreeArray: {\n      kind: \"typeConstructor\",\n      output: {\n        codecId: LTREE_ARRAY_CODEC_ID,\n        nativeType: LTREE_ARRAY_NATIVE_TYPE,\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\n","import type { JsonValue } from \"@prisma-next/contract/types\";\nimport {\n  type AnyCodecDescriptor,\n  type CodecCallContext,\n  CodecDescriptorImpl,\n  CodecImpl,\n  type CodecInstanceContext,\n  type ColumnHelperFor,\n  type ColumnHelperForStrict,\n  column,\n  voidParamsSchema,\n} from \"@prisma-next/framework-components/codec\";\nimport type { ExtractCodecTypes } from \"@prisma-next/sql-relational-core/ast\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport {\n  LTREE_ARRAY_CODEC_ID,\n  LTREE_CODEC_ID,\n  LTREE_MAX_LABEL_LENGTH,\n  LTREE_MAX_LABELS,\n} from \"./constants\";\nimport { LTREE_ARRAY_NATIVE_TYPE, LTREE_NATIVE_TYPE } from \"./contract-space-constants\";\n\nconst LABEL_PATTERN = /^[A-Za-z0-9_-]+$/;\n\nexport function assertValidLtree(value: unknown): asserts value is string {\n  if (typeof value !== \"string\") {\n    throw new Error(\"ltree value must be a string\");\n  }\n  if (value.length === 0) {\n    throw new Error(\"ltree value must not be empty\");\n  }\n  const labels = value.split(\".\");\n  if (labels.length > LTREE_MAX_LABELS) {\n    throw new Error(`ltree path exceeds max labels: got ${labels.length}, max ${LTREE_MAX_LABELS}`);\n  }\n  for (const label of labels) {\n    if (label.length === 0) {\n      throw new Error(`ltree label must not be empty in path \"${value}\"`);\n    }\n    if (label.length > LTREE_MAX_LABEL_LENGTH) {\n      throw new Error(\n        `ltree label exceeds max length: got ${label.length}, max ${LTREE_MAX_LABEL_LENGTH}`,\n      );\n    }\n    if (!LABEL_PATTERN.test(label)) {\n      throw new Error(\n        `ltree label \"${label}\" contains invalid characters; allowed: alphanumeric, underscore, hyphen`,\n      );\n    }\n  }\n}\n\nexport class LtreeCodec extends CodecImpl<\n  typeof LTREE_CODEC_ID,\n  readonly [\"equality\", \"order\"],\n  string,\n  string\n> {\n  async encode(value: string, _ctx: CodecCallContext): Promise<string> {\n    assertValidLtree(value);\n    return value;\n  }\n\n  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {\n    return wire;\n  }\n\n  encodeJson(value: string): JsonValue {\n    assertValidLtree(value);\n    return value;\n  }\n\n  decodeJson(json: JsonValue): string {\n    assertValidLtree(json);\n    return json;\n  }\n}\n\nconst LTREE_META = { db: { sql: { postgres: { nativeType: LTREE_NATIVE_TYPE } } } } as const;\n\nexport class LtreeDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = LTREE_CODEC_ID;\n  override readonly traits = [\"equality\", \"order\"] as const;\n  override readonly targetTypes = [LTREE_NATIVE_TYPE] as const;\n  override readonly meta = LTREE_META;\n  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n  override renderOutputType(): string {\n    return \"string\";\n  }\n  override factory(): (ctx: CodecInstanceContext) => LtreeCodec {\n    const shared = new LtreeCodec(this);\n    return () => shared;\n  }\n}\n\nexport const ltreeDescriptor = new LtreeDescriptor();\n\nexport const ltree = () =>\n  column(ltreeDescriptor.factory(), ltreeDescriptor.codecId, undefined, LTREE_NATIVE_TYPE);\n\nltree satisfies ColumnHelperFor<LtreeDescriptor>;\nltree satisfies ColumnHelperForStrict<LtreeDescriptor>;\n\nconst LTREE_ARRAY_META = {\n  db: { sql: { postgres: { nativeType: LTREE_ARRAY_NATIVE_TYPE } } },\n} as const;\n\nexport class LtreeArrayCodec extends CodecImpl<\n  typeof LTREE_ARRAY_CODEC_ID,\n  readonly [\"equality\"],\n  readonly string[],\n  readonly string[]\n> {\n  async encode(value: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]> {\n    for (const entry of value) {\n      assertValidLtree(entry);\n    }\n    return value;\n  }\n\n  async decode(wire: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]> {\n    return wire;\n  }\n\n  encodeJson(value: readonly string[]): JsonValue {\n    for (const entry of value) {\n      assertValidLtree(entry);\n    }\n    return [...value];\n  }\n\n  decodeJson(json: JsonValue): readonly string[] {\n    if (!Array.isArray(json)) {\n      return [];\n    }\n    return json.map((entry) => {\n      assertValidLtree(entry);\n      return String(entry);\n    });\n  }\n}\n\nexport class LtreeArrayDescriptor extends CodecDescriptorImpl<void> {\n  override readonly codecId = LTREE_ARRAY_CODEC_ID;\n  override readonly traits = [\"equality\"] as const;\n  override readonly targetTypes = [LTREE_ARRAY_NATIVE_TYPE] as const;\n  override readonly meta = LTREE_ARRAY_META;\n  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;\n  override renderOutputType(): string {\n    return \"readonly string[]\";\n  }\n  override factory(): (ctx: CodecInstanceContext) => LtreeArrayCodec {\n    const shared = new LtreeArrayCodec(this);\n    return () => shared;\n  }\n}\n\nexport const ltreeArrayDescriptor = new LtreeArrayDescriptor();\n\nexport const ltreeArray = () =>\n  column(\n    ltreeArrayDescriptor.factory(),\n    ltreeArrayDescriptor.codecId,\n    undefined,\n    LTREE_ARRAY_NATIVE_TYPE,\n  );\n\nltreeArray satisfies ColumnHelperFor<LtreeArrayDescriptor>;\nltreeArray satisfies ColumnHelperForStrict<LtreeArrayDescriptor>;\n\nconst codecDescriptorMap = {\n  ltree: ltreeDescriptor,\n  ltreeArray: ltreeArrayDescriptor,\n} as const;\n\nexport type CodecTypes = ExtractCodecTypes<typeof codecDescriptorMap>;\n\nexport const codecDescriptors: readonly AnyCodecDescriptor[] = Object.values(codecDescriptorMap);\n","import { buildCodecDescriptorRegistry } from \"@prisma-next/sql-relational-core/codec-descriptor-registry\";\nimport type { CodecDescriptorRegistry } from \"@prisma-next/sql-relational-core/query-lane-context\";\nimport { codecDescriptors } from \"./codecs\";\n\nexport const ltreeCodecRegistry: CodecDescriptorRegistry =\n  buildCodecDescriptorRegistry(codecDescriptors);\n","import type { AnyExpression } from \"@prisma-next/sql-relational-core/ast\";\nimport {\n  buildOperation,\n  type CodecExpression,\n  codecOf,\n  type Expression,\n  toExpr,\n} from \"@prisma-next/sql-relational-core/expression\";\nimport type { CodecTypes } from \"../types/codec-types\";\nimport type { QueryOperationTypes } from \"../types/operation-types\";\nimport { ltreeAuthoringTypes } from \"./authoring\";\nimport { LTREE_ARRAY_CODEC_ID, LTREE_CODEC_ID } from \"./constants\";\nimport { LTREE_ARRAY_NATIVE_TYPE, LTREE_NATIVE_TYPE } from \"./contract-space-constants\";\nimport { ltreeCodecRegistry } from \"./registry\";\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\ntype BoolReturn = Expression<{ readonly codecId: \"pg/bool@1\"; readonly nullable: false }>;\ntype LtreeReturn = Expression<{ readonly codecId: \"pg/ltree@1\"; readonly nullable: false }>;\ntype IntReturn = Expression<{ readonly codecId: \"pg/int4@1\"; readonly nullable: false }>;\ntype TextReturn = Expression<{ readonly codecId: \"pg/text@1\"; readonly nullable: false }>;\n\nconst BOOL_RETURN = { codecId: \"pg/bool@1\", nullable: false } as const;\nconst LTREE_RETURN = { codecId: \"pg/ltree@1\", nullable: false } as const;\nconst INT_RETURN = { codecId: \"pg/int4@1\", nullable: false } as const;\nconst TEXT_RETURN = { codecId: \"pg/text@1\", nullable: false } as const;\nconst TEXT_CODEC_ID = \"pg/text@1\" as const;\nconst TEXT_ARRAY_CODEC_ID = \"pg/text-array@1\" as const;\nconst INT_CODEC_ID = \"pg/int4@1\" as const;\n\n/**\n * Build a function-style operation whose SQL is `fnName(self, arg0, arg1, ...)`.\n * The template's placeholder count is derived from the actual argument list, so\n * one helper covers fixed-arity functions (`nlevel`, `subltree`), optional-arg\n * overloads (`subpath`, `index`), and the variadic `lca` (see ADR-001). `args`\n * already carries each value through `toExpr` with its codec; `args[0]` is the\n * `self` receiver.\n */\nfunction funcOp<C extends string>(\n  method: string,\n  fnName: string,\n  returns: { readonly codecId: C; readonly nullable: false },\n  args: readonly [AnyExpression, ...AnyExpression[]],\n): Expression<{ readonly codecId: C; readonly nullable: false }> {\n  const placeholders = args.map((_, i) => (i === 0 ? \"{{self}}\" : `{{arg${i - 1}}}`)).join(\", \");\n  return buildOperation({\n    method,\n    args,\n    returns,\n    lowering: {\n      targetFamily: \"sql\",\n      strategy: \"function\",\n      template: `${fnName}(${placeholders})`,\n    },\n  });\n}\n\nexport function ltreeQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {\n  // Hierarchy operators compare two `ltree` values; the user argument shares the\n  // column's `pg/ltree@1` codec. Pattern-match operators take a query/pattern\n  // string (or `string[]`) that is NOT an ltree — it is bound as text and cast\n  // in-template to `lquery` / `lquery[]` / `ltxtquery` (the validated-string-param\n  // approach; verified executable under PGlite).\n  const hierarchyOp = (\n    method: string,\n    operator: string,\n    self: CodecExpression<typeof LTREE_CODEC_ID, boolean, CT>,\n    other: CodecExpression<typeof LTREE_CODEC_ID, boolean, CT>,\n  ): BoolReturn => {\n    const selfCodec = codecOf(self);\n    return buildOperation({\n      method,\n      args: [toExpr(self, selfCodec), toExpr(other, selfCodec)],\n      returns: BOOL_RETURN,\n      lowering: {\n        targetFamily: \"sql\",\n        strategy: \"function\",\n        template: `{{self}} ${operator} {{arg0}}`,\n      },\n    });\n  };\n\n  const patternOp = (\n    method: string,\n    operator: string,\n    castType: string,\n    argCodecId: typeof TEXT_CODEC_ID | typeof TEXT_ARRAY_CODEC_ID,\n    self: CodecExpression<typeof LTREE_CODEC_ID, boolean, CT>,\n    arg: unknown,\n  ): BoolReturn => {\n    const selfCodec = codecOf(self);\n    return buildOperation({\n      method,\n      args: [toExpr(self, selfCodec), toExpr(arg, { codecId: argCodecId })],\n      returns: BOOL_RETURN,\n      lowering: {\n        targetFamily: \"sql\",\n        strategy: \"function\",\n        template: `{{self}} ${operator} ({{arg0}})::${castType}`,\n      },\n    });\n  };\n\n  // Concatenation operators produce a new ltree. `concat` joins two ltree paths\n  // (`{{self}} || {{arg0}}`); `concatText`/`prependText` splice a text label onto\n  // the right/left. The text operand binds as `pg/text@1` and is cast in-template\n  // (PG resolves the `||` overload from the cast). `prependText` places `{{self}}`\n  // second because the ltree receiver is the RIGHT operand of `text || ltree`;\n  // `args[0]` is still `self` (the renderer binds by placeholder name, not order).\n  const concatOp = (\n    method: string,\n    template: string,\n    args: readonly [AnyExpression, ...AnyExpression[]],\n  ): LtreeReturn =>\n    buildOperation({\n      method,\n      args,\n      returns: LTREE_RETURN,\n      lowering: { targetFamily: \"sql\", strategy: \"function\", template },\n    });\n\n  // Tier 3 — first-match operators on an `ltree[]` receiver (ADR-003).\n  const firstMatchOp = (\n    method: string,\n    operator: string,\n    self: CodecExpression<typeof LTREE_ARRAY_CODEC_ID, boolean, CT>,\n    arg: unknown,\n    argCodecId: typeof LTREE_CODEC_ID | typeof TEXT_CODEC_ID,\n    castType?: string,\n  ): LtreeReturn => {\n    const selfCodec = codecOf(self);\n    const template = castType\n      ? `{{self}} ${operator} ({{arg0}})::${castType}`\n      : `{{self}} ${operator} {{arg0}}`;\n    return buildOperation({\n      method,\n      args: [toExpr(self, selfCodec), toExpr(arg, { codecId: argCodecId })],\n      returns: LTREE_RETURN,\n      lowering: { targetFamily: \"sql\", strategy: \"function\", template },\n    });\n  };\n\n  return {\n    isAncestorOf: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, other) => hierarchyOp(\"isAncestorOf\", \"@>\", self, other),\n    },\n    isDescendantOf: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, other) => hierarchyOp(\"isDescendantOf\", \"<@\", self, other),\n    },\n    matchesLquery: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, pattern) =>\n        patternOp(\"matchesLquery\", \"~\", \"lquery\", TEXT_CODEC_ID, self, pattern),\n    },\n    matchesLqueryArray: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, patterns) =>\n        patternOp(\"matchesLqueryArray\", \"?\", \"lquery[]\", TEXT_ARRAY_CODEC_ID, self, patterns),\n    },\n    matchesLtxtquery: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, query) =>\n        patternOp(\"matchesLtxtquery\", \"@\", \"ltxtquery\", TEXT_CODEC_ID, self, query),\n    },\n    nlevel: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self): IntReturn =>\n        funcOp(\"nlevel\", \"nlevel\", INT_RETURN, [toExpr(self, codecOf(self))]),\n    },\n    subltree: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, start, end): LtreeReturn =>\n        funcOp(\"subltree\", \"subltree\", LTREE_RETURN, [\n          toExpr(self, codecOf(self)),\n          toExpr(start, { codecId: INT_CODEC_ID }),\n          toExpr(end, { codecId: INT_CODEC_ID }),\n        ]),\n    },\n    // `subpath(self, offset, len?)` — `len` omitted lowers to the 2-arg overload.\n    subpath: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, offset, len): LtreeReturn => {\n        const head: readonly [AnyExpression, AnyExpression] = [\n          toExpr(self, codecOf(self)),\n          toExpr(offset, { codecId: INT_CODEC_ID }),\n        ];\n        return funcOp(\n          \"subpath\",\n          \"subpath\",\n          LTREE_RETURN,\n          len === undefined ? head : [...head, toExpr(len, { codecId: INT_CODEC_ID })],\n        );\n      },\n    },\n    // `index(self, other, offset?)` — `offset` omitted lowers to the 2-arg overload.\n    indexOf: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, other, offset): IntReturn => {\n        const selfCodec = codecOf(self);\n        const head: readonly [AnyExpression, AnyExpression] = [\n          toExpr(self, selfCodec),\n          toExpr(other, selfCodec),\n        ];\n        return funcOp(\n          \"indexOf\",\n          \"index\",\n          INT_RETURN,\n          offset === undefined ? head : [...head, toExpr(offset, { codecId: INT_CODEC_ID })],\n        );\n      },\n    },\n    // `lca(self, other, ...rest)` — variadic longest-common-ancestor (ADR-001).\n    // PostgreSQL has no single-arg `lca`, so `other` is required (2–8 paths).\n    lca: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, other, ...rest): LtreeReturn => {\n        const selfCodec = codecOf(self);\n        return funcOp(\"lca\", \"lca\", LTREE_RETURN, [\n          toExpr(self, selfCodec),\n          toExpr(other, selfCodec),\n          ...rest.map((p) => toExpr(p, selfCodec)),\n        ]);\n      },\n    },\n    // Tier 2 — concatenation (`||`).\n    concat: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, other): LtreeReturn => {\n        const selfCodec = codecOf(self);\n        return concatOp(\"concat\", \"{{self}} || {{arg0}}\", [\n          toExpr(self, selfCodec),\n          toExpr(other, selfCodec),\n        ]);\n      },\n    },\n    concatText: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, label): LtreeReturn =>\n        concatOp(\"concatText\", \"{{self}} || ({{arg0}})::text\", [\n          toExpr(self, codecOf(self)),\n          toExpr(label, { codecId: TEXT_CODEC_ID }),\n        ]),\n    },\n    // `text || ltree` — the ltree receiver is the right operand (ADR-002).\n    prependText: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self, prefix): LtreeReturn =>\n        concatOp(\"prependText\", \"({{arg0}})::text || {{self}}\", [\n          toExpr(self, codecOf(self)),\n          toExpr(prefix, { codecId: TEXT_CODEC_ID }),\n        ]),\n    },\n    // Tier 2 — conversion.\n    toText: {\n      self: { codecId: LTREE_CODEC_ID },\n      impl: (self): TextReturn =>\n        funcOp(\"toText\", \"ltree2text\", TEXT_RETURN, [toExpr(self, codecOf(self))]),\n    },\n    // `text2ltree(text)` — rooted on `pg/text@1` (the only reachable form of the\n    // free-function `text2ltree`; see ADR-002). Surfaces as `.toLtree()` on text.\n    toLtree: {\n      self: { codecId: TEXT_CODEC_ID },\n      impl: (self): LtreeReturn =>\n        funcOp(\"toLtree\", \"text2ltree\", LTREE_RETURN, [toExpr(self, codecOf(self))]),\n    },\n    // Tier 3 — array first-match operators (ADR-003).\n    firstAncestorOf: {\n      self: { codecId: LTREE_ARRAY_CODEC_ID },\n      impl: (self, other) => firstMatchOp(\"firstAncestorOf\", \"?@>\", self, other, LTREE_CODEC_ID),\n    },\n    firstDescendantOf: {\n      self: { codecId: LTREE_ARRAY_CODEC_ID },\n      impl: (self, other) => firstMatchOp(\"firstDescendantOf\", \"?<@\", self, other, LTREE_CODEC_ID),\n    },\n    firstMatchLquery: {\n      self: { codecId: LTREE_ARRAY_CODEC_ID },\n      impl: (self, pattern) =>\n        firstMatchOp(\"firstMatchLquery\", \"?~\", self, pattern, TEXT_CODEC_ID, \"lquery\"),\n    },\n    firstMatchLtxtquery: {\n      self: { codecId: LTREE_ARRAY_CODEC_ID },\n      impl: (self, query) =>\n        firstMatchOp(\"firstMatchLtxtquery\", \"?@\", self, query, TEXT_CODEC_ID, \"ltxtquery\"),\n    },\n  };\n}\n\nconst ltreePackMetaBase = {\n  kind: \"extension\",\n  id: \"ltree\",\n  familyId: \"sql\",\n  targetId: \"postgres\",\n  version: \"0.1.0\",\n  capabilities: {\n    postgres: {\n      \"ltree.path\": true,\n    },\n  },\n  authoring: {\n    type: ltreeAuthoringTypes,\n  },\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(ltreeCodecRegistry.values()),\n      import: {\n        package: \"prisma-ltree/codec-types\",\n        named: \"CodecTypes\",\n        alias: \"LtreeTypes\",\n      },\n      typeImports: [\n        {\n          package: \"prisma-ltree/codec-types\",\n          named: \"Ltree\",\n          alias: \"Ltree\",\n        },\n      ],\n    },\n    queryOperationTypes: {\n      import: {\n        package: \"prisma-ltree/operation-types\",\n        named: \"QueryOperationTypes\",\n        alias: \"LtreeQueryOperationTypes\",\n      },\n    },\n    storage: [\n      {\n        typeId: LTREE_CODEC_ID,\n        familyId: \"sql\",\n        targetId: \"postgres\",\n        nativeType: LTREE_NATIVE_TYPE,\n      },\n      {\n        typeId: LTREE_ARRAY_CODEC_ID,\n        familyId: \"sql\",\n        targetId: \"postgres\",\n        nativeType: LTREE_ARRAY_NATIVE_TYPE,\n      },\n    ],\n  },\n} as const;\n\nexport const ltreePackMeta: typeof ltreePackMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = ltreePackMetaBase;\n"],"mappings":";;;;;AAIA,MAAa,sBAAsB,EACjC,OAAO;CACL,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,YAAY;EACV,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;AACF,EACF;;;ACCA,MAAM,gBAAgB;AAEtB,SAAgB,iBAAiB,OAAyC;CACxE,IAAI,OAAO,UAAU,UACnB,MAAM,IAAI,MAAM,8BAA8B;CAEhD,IAAI,MAAM,WAAW,GACnB,MAAM,IAAI,MAAM,+BAA+B;CAEjD,MAAM,SAAS,MAAM,MAAM,GAAG;CAC9B,IAAI,OAAO,SAAA,OACT,MAAM,IAAI,MAAM,sCAAsC,OAAO,OAAO,QAAQ,kBAAkB;CAEhG,KAAK,MAAM,SAAS,QAAQ;EAC1B,IAAI,MAAM,WAAW,GACnB,MAAM,IAAI,MAAM,0CAA0C,MAAM,EAAE;EAEpE,IAAI,MAAM,SAAA,KACR,MAAM,IAAI,MACR,uCAAuC,MAAM,OAAO,QAAQ,wBAC9D;EAEF,IAAI,CAAC,cAAc,KAAK,KAAK,GAC3B,MAAM,IAAI,MACR,gBAAgB,MAAM,yEACxB;CAEJ;AACF;AAEA,IAAa,aAAb,cAAgC,UAK9B;CACA,MAAM,OAAO,OAAe,MAAyC;EACnE,iBAAiB,KAAK;EACtB,OAAO;CACT;CAEA,MAAM,OAAO,MAAc,MAAyC;EAClE,OAAO;CACT;CAEA,WAAW,OAA0B;EACnC,iBAAiB,KAAK;EACtB,OAAO;CACT;CAEA,WAAW,MAAyB;EAClC,iBAAiB,IAAI;EACrB,OAAO;CACT;AACF;AAEA,MAAM,aAAa,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,kBAAkB,EAAE,EAAE,EAAE;AAElF,IAAa,kBAAb,cAAqC,oBAA0B;CAC7D,UAA4B;CAC5B,SAA2B,CAAC,YAAY,OAAO;CAC/C,cAAgC,CAAC,iBAAiB;CAClD,OAAyB;CACzB,eAAyD;CACzD,mBAAoC;EAClC,OAAO;CACT;CACA,UAA8D;EAC5D,MAAM,SAAS,IAAI,WAAW,IAAI;EAClC,aAAa;CACf;AACF;AAEA,MAAa,kBAAkB,IAAI,gBAAgB;AAQnD,MAAM,mBAAmB,EACvB,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,wBAAwB,EAAE,EAAE,EACnE;AAEA,IAAa,kBAAb,cAAqC,UAKnC;CACA,MAAM,OAAO,OAA0B,MAAoD;EACzF,KAAK,MAAM,SAAS,OAClB,iBAAiB,KAAK;EAExB,OAAO;CACT;CAEA,MAAM,OAAO,MAAyB,MAAoD;EACxF,OAAO;CACT;CAEA,WAAW,OAAqC;EAC9C,KAAK,MAAM,SAAS,OAClB,iBAAiB,KAAK;EAExB,OAAO,CAAC,GAAG,KAAK;CAClB;CAEA,WAAW,MAAoC;EAC7C,IAAI,CAAC,MAAM,QAAQ,IAAI,GACrB,OAAO,CAAC;EAEV,OAAO,KAAK,KAAK,UAAU;GACzB,iBAAiB,KAAK;GACtB,OAAO,OAAO,KAAK;EACrB,CAAC;CACH;AACF;AAEA,IAAa,uBAAb,cAA0C,oBAA0B;CAClE,UAA4B;CAC5B,SAA2B,CAAC,UAAU;CACtC,cAAgC,CAAC,uBAAuB;CACxD,OAAyB;CACzB,eAAyD;CACzD,mBAAoC;EAClC,OAAO;CACT;CACA,UAAmE;EACjE,MAAM,SAAS,IAAI,gBAAgB,IAAI;EACvC,aAAa;CACf;AACF;AAeA,MAAM,qBAAqB;CACzB,OAAO;CACP,YAAY,IAf0B,qBAe1B;AACd;;;ACzKA,MAAa,qBACX,6BD4K6D,OAAO,OAAO,kBC5K9C,CAAgB;;;ACiB/C,MAAM,cAAc;CAAE,SAAS;CAAa,UAAU;AAAM;AAC5D,MAAM,eAAe;CAAE,SAAS;CAAc,UAAU;AAAM;AAC9D,MAAM,aAAa;CAAE,SAAS;CAAa,UAAU;AAAM;AAC3D,MAAM,cAAc;CAAE,SAAS;CAAa,UAAU;AAAM;AAC5D,MAAM,gBAAgB;AACtB,MAAM,sBAAsB;AAC5B,MAAM,eAAe;;;;;;;;;AAUrB,SAAS,OACP,QACA,QACA,SACA,MAC+D;CAE/D,OAAO,eAAe;EACpB;EACA;EACA;EACA,UAAU;GACR,cAAc;GACd,UAAU;GACV,UAAU,GAAG,OAAO,GARH,KAAK,KAAK,GAAG,MAAO,MAAM,IAAI,aAAa,QAAQ,IAAI,EAAE,GAAI,EAAE,KAAK,IAQnD,EAAE;EACtC;CACF,CAAC;AACH;AAEA,SAAgB,uBAA2E;CAMzF,MAAM,eACJ,QACA,UACA,MACA,UACe;EACf,MAAM,YAAY,QAAQ,IAAI;EAC9B,OAAO,eAAe;GACpB;GACA,MAAM,CAAC,OAAO,MAAM,SAAS,GAAG,OAAO,OAAO,SAAS,CAAC;GACxD,SAAS;GACT,UAAU;IACR,cAAc;IACd,UAAU;IACV,UAAU,YAAY,SAAS;GACjC;EACF,CAAC;CACH;CAEA,MAAM,aACJ,QACA,UACA,UACA,YACA,MACA,QACe;EAEf,OAAO,eAAe;GACpB;GACA,MAAM,CAAC,OAAO,MAHE,QAAQ,IAGI,CAAC,GAAG,OAAO,KAAK,EAAE,SAAS,WAAW,CAAC,CAAC;GACpE,SAAS;GACT,UAAU;IACR,cAAc;IACd,UAAU;IACV,UAAU,YAAY,SAAS,eAAe;GAChD;EACF,CAAC;CACH;CAQA,MAAM,YACJ,QACA,UACA,SAEA,eAAe;EACb;EACA;EACA,SAAS;EACT,UAAU;GAAE,cAAc;GAAO,UAAU;GAAY;EAAS;CAClE,CAAC;CAGH,MAAM,gBACJ,QACA,UACA,MACA,KACA,YACA,aACgB;EAChB,MAAM,YAAY,QAAQ,IAAI;EAC9B,MAAM,WAAW,WACb,YAAY,SAAS,eAAe,aACpC,YAAY,SAAS;EACzB,OAAO,eAAe;GACpB;GACA,MAAM,CAAC,OAAO,MAAM,SAAS,GAAG,OAAO,KAAK,EAAE,SAAS,WAAW,CAAC,CAAC;GACpE,SAAS;GACT,UAAU;IAAE,cAAc;IAAO,UAAU;IAAY;GAAS;EAClE,CAAC;CACH;CAEA,OAAO;EACL,cAAc;GACZ,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,UAAU,YAAY,gBAAgB,MAAM,MAAM,KAAK;EACtE;EACA,gBAAgB;GACd,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,UAAU,YAAY,kBAAkB,MAAM,MAAM,KAAK;EACxE;EACA,eAAe;GACb,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,YACX,UAAU,iBAAiB,KAAK,UAAU,eAAe,MAAM,OAAO;EAC1E;EACA,oBAAoB;GAClB,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,aACX,UAAU,sBAAsB,KAAK,YAAY,qBAAqB,MAAM,QAAQ;EACxF;EACA,kBAAkB;GAChB,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,UACX,UAAU,oBAAoB,KAAK,aAAa,eAAe,MAAM,KAAK;EAC9E;EACA,QAAQ;GACN,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,SACL,OAAO,UAAU,UAAU,YAAY,CAAC,OAAO,MAAM,QAAQ,IAAI,CAAC,CAAC,CAAC;EACxE;EACA,UAAU;GACR,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,OAAO,QAClB,OAAO,YAAY,YAAY,cAAc;IAC3C,OAAO,MAAM,QAAQ,IAAI,CAAC;IAC1B,OAAO,OAAO,EAAE,SAAS,aAAa,CAAC;IACvC,OAAO,KAAK,EAAE,SAAS,aAAa,CAAC;GACvC,CAAC;EACL;EAEA,SAAS;GACP,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,QAAQ,QAAqB;IACxC,MAAM,OAAgD,CACpD,OAAO,MAAM,QAAQ,IAAI,CAAC,GAC1B,OAAO,QAAQ,EAAE,SAAS,aAAa,CAAC,CAC1C;IACA,OAAO,OACL,WACA,WACA,cACA,QAAQ,KAAA,IAAY,OAAO,CAAC,GAAG,MAAM,OAAO,KAAK,EAAE,SAAS,aAAa,CAAC,CAAC,CAC7E;GACF;EACF;EAEA,SAAS;GACP,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,OAAO,WAAsB;IACxC,MAAM,YAAY,QAAQ,IAAI;IAC9B,MAAM,OAAgD,CACpD,OAAO,MAAM,SAAS,GACtB,OAAO,OAAO,SAAS,CACzB;IACA,OAAO,OACL,WACA,SACA,YACA,WAAW,KAAA,IAAY,OAAO,CAAC,GAAG,MAAM,OAAO,QAAQ,EAAE,SAAS,aAAa,CAAC,CAAC,CACnF;GACF;EACF;EAGA,KAAK;GACH,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,OAAO,GAAG,SAAsB;IAC3C,MAAM,YAAY,QAAQ,IAAI;IAC9B,OAAO,OAAO,OAAO,OAAO,cAAc;KACxC,OAAO,MAAM,SAAS;KACtB,OAAO,OAAO,SAAS;KACvB,GAAG,KAAK,KAAK,MAAM,OAAO,GAAG,SAAS,CAAC;IACzC,CAAC;GACH;EACF;EAEA,QAAQ;GACN,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,UAAuB;IAClC,MAAM,YAAY,QAAQ,IAAI;IAC9B,OAAO,SAAS,UAAU,wBAAwB,CAChD,OAAO,MAAM,SAAS,GACtB,OAAO,OAAO,SAAS,CACzB,CAAC;GACH;EACF;EACA,YAAY;GACV,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,UACX,SAAS,cAAc,gCAAgC,CACrD,OAAO,MAAM,QAAQ,IAAI,CAAC,GAC1B,OAAO,OAAO,EAAE,SAAS,cAAc,CAAC,CAC1C,CAAC;EACL;EAEA,aAAa;GACX,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,MAAM,WACX,SAAS,eAAe,gCAAgC,CACtD,OAAO,MAAM,QAAQ,IAAI,CAAC,GAC1B,OAAO,QAAQ,EAAE,SAAS,cAAc,CAAC,CAC3C,CAAC;EACL;EAEA,QAAQ;GACN,MAAM,EAAE,SAAS,eAAe;GAChC,OAAO,SACL,OAAO,UAAU,cAAc,aAAa,CAAC,OAAO,MAAM,QAAQ,IAAI,CAAC,CAAC,CAAC;EAC7E;EAGA,SAAS;GACP,MAAM,EAAE,SAAS,cAAc;GAC/B,OAAO,SACL,OAAO,WAAW,cAAc,cAAc,CAAC,OAAO,MAAM,QAAQ,IAAI,CAAC,CAAC,CAAC;EAC/E;EAEA,iBAAiB;GACf,MAAM,EAAE,SAAS,qBAAqB;GACtC,OAAO,MAAM,UAAU,aAAa,mBAAmB,OAAO,MAAM,OAAO,cAAc;EAC3F;EACA,mBAAmB;GACjB,MAAM,EAAE,SAAS,qBAAqB;GACtC,OAAO,MAAM,UAAU,aAAa,qBAAqB,OAAO,MAAM,OAAO,cAAc;EAC7F;EACA,kBAAkB;GAChB,MAAM,EAAE,SAAS,qBAAqB;GACtC,OAAO,MAAM,YACX,aAAa,oBAAoB,MAAM,MAAM,SAAS,eAAe,QAAQ;EACjF;EACA,qBAAqB;GACnB,MAAM,EAAE,SAAS,qBAAqB;GACtC,OAAO,MAAM,UACX,aAAa,uBAAuB,MAAM,MAAM,OAAO,eAAe,WAAW;EACrF;CACF;AACF;AAwDA,MAAa,gBAET;CAvDF,MAAM;CACN,IAAI;CACJ,UAAU;CACV,UAAU;CACV,SAAS;CACT,cAAc,EACZ,UAAU,EACR,cAAc,KAChB,EACF;CACA,WAAW,EACT,MAAM,oBACR;CACA,OAAO;EACL,YAAY;GACV,kBAAkB,MAAM,KAAK,mBAAmB,OAAO,CAAC;GACxD,QAAQ;IACN,SAAS;IACT,OAAO;IACP,OAAO;GACT;GACA,aAAa,CACX;IACE,SAAS;IACT,OAAO;IACP,OAAO;GACT,CACF;EACF;EACA,qBAAqB,EACnB,QAAQ;GACN,SAAS;GACT,OAAO;GACP,OAAO;EACT,EACF;EACA,SAAS,CACP;GACE,QAAQ;GACR,UAAU;GACV,UAAU;GACV,YAAY;EACd,GACA;GACE,QAAQ;GACR,UAAU;GACV,UAAU;GACV,YAAY;EACd,CACF;CACF;AAKE"}

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

@@ -0,0 +1,184 @@
+import { CodecExpression, Expression } from "@prisma-next/sql-relational-core/expression";
+import { SqlQueryOperationTypes } from "@prisma-next/sql-contract/types";
+
+//#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 isAncestorOf: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, other: CodecExpression<"pg/ltree@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/bool@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly isDescendantOf: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, other: CodecExpression<"pg/ltree@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/bool@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly matchesLquery: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, pattern: CodecExpression<"pg/text@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/bool@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly matchesLqueryArray: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, patterns: CodecExpression<"pg/text-array@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/bool@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly matchesLtxtquery: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, query: CodecExpression<"pg/text@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/bool@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly nlevel: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/int4@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly subltree: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, start: CodecExpression<"pg/int4@1", boolean, CT>, end: CodecExpression<"pg/int4@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly subpath: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, offset: CodecExpression<"pg/int4@1", boolean, CT>, len?: CodecExpression<"pg/int4@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly indexOf: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, other: CodecExpression<"pg/ltree@1", boolean, CT>, offset?: CodecExpression<"pg/int4@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/int4@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly lca: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, other: CodecExpression<"pg/ltree@1", boolean, CT>, ...rest: ReadonlyArray<CodecExpression<"pg/ltree@1", boolean, CT>>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly concat: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, other: CodecExpression<"pg/ltree@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly concatText: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, label: CodecExpression<"pg/text@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly prependText: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>, prefix: CodecExpression<"pg/text@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly toText: {
+    readonly self: {
+      readonly codecId: "pg/ltree@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/text@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly toLtree: {
+    readonly self: {
+      readonly codecId: "pg/text@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/text@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly firstAncestorOf: {
+    readonly self: {
+      readonly codecId: "pg/ltree-array@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree-array@1", boolean, CT>, other: CodecExpression<"pg/ltree@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly firstDescendantOf: {
+    readonly self: {
+      readonly codecId: "pg/ltree-array@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree-array@1", boolean, CT>, other: CodecExpression<"pg/ltree@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly firstMatchLquery: {
+    readonly self: {
+      readonly codecId: "pg/ltree-array@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree-array@1", boolean, CT>, pattern: CodecExpression<"pg/text@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+  readonly firstMatchLtxtquery: {
+    readonly self: {
+      readonly codecId: "pg/ltree-array@1";
+    };
+    readonly impl: (self: CodecExpression<"pg/ltree-array@1", boolean, CT>, query: CodecExpression<"pg/text@1", boolean, CT>) => Expression<{
+      readonly codecId: "pg/ltree@1";
+      readonly nullable: false;
+    }>;
+  };
+}>;
+//#endregion
+export { QueryOperationTypes as t };
+//# sourceMappingURL=operation-types-CP6jqHAZ.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operation-types-CP6jqHAZ.d.mts","names":[],"sources":["../src/types/operation-types.ts"],"mappings":"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"}

package/dist/operation-types.d.mts

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

package/dist/operation-types.mjs

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

package/dist/pack.d.mts

@@ -0,0 +1,73 @@
+import { t as CodecTypes } from "./codec-types-mZn-cIh9.mjs";
+//#region src/core/descriptor-meta.d.ts
+declare const ltreePackMetaBase: {
+  readonly kind: "extension";
+  readonly id: "ltree";
+  readonly familyId: "sql";
+  readonly targetId: "postgres";
+  readonly version: "0.1.0";
+  readonly capabilities: {
+    readonly postgres: {
+      readonly "ltree.path": true;
+    };
+  };
+  readonly authoring: {
+    readonly type: {
+      readonly ltree: {
+        readonly Ltree: {
+          readonly kind: "typeConstructor";
+          readonly output: {
+            readonly codecId: "pg/ltree@1";
+            readonly nativeType: "ltree";
+          };
+        };
+        readonly LtreeArray: {
+          readonly kind: "typeConstructor";
+          readonly output: {
+            readonly codecId: "pg/ltree-array@1";
+            readonly nativeType: "ltree[]";
+          };
+        };
+      };
+    };
+  };
+  readonly types: {
+    readonly codecTypes: {
+      readonly codecDescriptors: import("@prisma-next/framework-components/codec").CodecDescriptor<unknown>[];
+      readonly import: {
+        readonly package: "prisma-ltree/codec-types";
+        readonly named: "CodecTypes";
+        readonly alias: "LtreeTypes";
+      };
+      readonly typeImports: readonly [{
+        readonly package: "prisma-ltree/codec-types";
+        readonly named: "Ltree";
+        readonly alias: "Ltree";
+      }];
+    };
+    readonly queryOperationTypes: {
+      readonly import: {
+        readonly package: "prisma-ltree/operation-types";
+        readonly named: "QueryOperationTypes";
+        readonly alias: "LtreeQueryOperationTypes";
+      };
+    };
+    readonly storage: readonly [{
+      readonly typeId: "pg/ltree@1";
+      readonly familyId: "sql";
+      readonly targetId: "postgres";
+      readonly nativeType: "ltree";
+    }, {
+      readonly typeId: "pg/ltree-array@1";
+      readonly familyId: "sql";
+      readonly targetId: "postgres";
+      readonly nativeType: "ltree[]";
+    }];
+  };
+};
+declare const ltreePackMeta: typeof ltreePackMetaBase & {
+  readonly __codecTypes?: CodecTypes;
+};
+//#endregion
+export { ltreePackMeta as default };
+//# sourceMappingURL=pack.d.mts.map