prisma-ltree 0.5.0 → 0.6.0

package/README.md

@@ -30,16 +30,16 @@ for what is supported, planned, or out of scope.
 pnpm add prisma-ltree
 ```
 
-Requires Node `>=24`. This pack exact-pins `@prisma/orm-*` to **`8.0.0-rc.16`**.
+Requires Node `>=24`. This pack exact-pins `@prisma/orm-*` to **`8.0.0-rc.23`**.
 `prisma-ltree` itself stays on independent `0.x` semver: install it with a caret.
-You do not need `prisma-ltree@8.0.0-rc.16`. See
+You do not need `prisma-ltree@8.0.0-rc.23`. See
 [versioning and compatibility](https://github.com/slovakian/prisma-ltree/blob/main/docs/prisma-next/versioning-and-compatibility.md).
 
 Consumer apps also depend on the Postgres facade at the same SPI version, plus the
 `prisma` CLI:
 
 ```bash
-pnpm add @prisma/orm-postgres@8.0.0-rc.16 prisma-ltree
+pnpm add @prisma/orm-postgres@8.0.0-rc.23 prisma-ltree
 pnpm add -D prisma
 ```
 
@@ -98,7 +98,7 @@ types {
 }
 
 model Page {
-  id          String @id @default(uuid())
+  id          String @id @onCreate(uuid())
   path        Path
   breadcrumbs Paths
 
@@ -110,7 +110,7 @@ model Page {
 
 ```prisma
 model Page {
-  id   String @id @default(uuid())
+  id   String @id @onCreate(uuid())
   path Path
 
   @@index([path], type: "gist")
@@ -134,12 +134,12 @@ export const contract = defineContract(
   {
     extensions: { ltree: ltreePack },
   },
-  ({ field, model }) => ({
+  ({ field, model, type }) => ({
     models: {
       Category: model("Category", {
         fields: {
-          id: field.id.int(),
-          name: field.string(),
+          id: field.column(type.Int()).id(),
+          name: field.column(type.String()),
           path: field.column(ltree()),
         },
       }).sql({ table: "category" }),

package/dist/{codec-types-BJE-5cwk.d.mts → codec-types-Ba5cQ3bc.d.mts}

@@ -1,7 +1,6 @@
-import { CodecCallContext, CodecImpl, CodecInstanceContext } from "@prisma/orm-framework/components/codec";
-import { PostgresCodecDescriptor } from "@prisma/orm-target-postgres/target/codec-descriptor";
-import { JsonValue } from "@prisma/orm-framework/contract/types";
+import { AnyCodecDescriptor, CodecCallContext, CodecImpl, CodecInstanceContext, DataTypeValue } from "@prisma/orm-framework/components/codec";
 import { ExtractCodecTypes, ProjectionExpr } from "@prisma/orm-family-sql/relational-core/ast";
+import { PostgresCodecDescriptor } from "@prisma/orm-target-postgres/target/codec-descriptor";
 
 //#region src/core/constants.d.ts
 declare const LTREE_CODEC_ID: "pg/ltree@1";
@@ -9,12 +8,14 @@ declare const LTREE_ARRAY_CODEC_ID: "pg/ltree-array@1";
 //#endregion
 //#region src/core/codecs.d.ts
 declare class LtreeCodec extends CodecImpl<typeof LTREE_CODEC_ID, readonly ["equality", "order"], string, string> {
-  encode(value: string, _ctx: CodecCallContext): Promise<string>;
-  decode(wire: string, _ctx: CodecCallContext): Promise<string>;
-  encodeJson(value: string): JsonValue;
-  decodeJson(json: JsonValue): string;
+  constructor(descriptor: AnyCodecDescriptor);
+  toWire(value: string, _ctx: CodecCallContext): Promise<string>;
+  fromWire(wire: string, _ctx: CodecCallContext): Promise<string>;
+  toDataTypeValue(value: string): DataTypeValue;
+  fromDataTypeValue(value: DataTypeValue): string;
 }
 declare class LtreeDescriptor extends PostgresCodecDescriptor<void> {
+  readonly jsonType: "string";
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "pg/ltree@1";
@@ -24,12 +25,14 @@ declare class LtreeDescriptor extends PostgresCodecDescriptor<void> {
   factory(): (ctx: CodecInstanceContext) => LtreeCodec;
 }
 declare class LtreeArrayCodec extends CodecImpl<typeof LTREE_ARRAY_CODEC_ID, readonly ["equality"], readonly string[], readonly string[]> {
-  encode(value: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]>;
-  decode(wire: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]>;
-  encodeJson(value: readonly string[]): JsonValue;
-  decodeJson(json: JsonValue): readonly string[];
+  constructor(descriptor: AnyCodecDescriptor);
+  toWire(value: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]>;
+  fromWire(wire: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]>;
+  toDataTypeValue(value: readonly string[]): DataTypeValue;
+  fromDataTypeValue(value: DataTypeValue): readonly string[];
 }
 declare class LtreeArrayDescriptor extends PostgresCodecDescriptor<void> {
+  readonly jsonType: "array";
   protected jsonProjection(expression: ProjectionExpr): ProjectionExpr;
   readonly dataType: import("@prisma/orm-framework/components/codec").DataTypeId;
   readonly codecId: "pg/ltree-array@1";
@@ -54,4 +57,4 @@ type LtreeArray = readonly string[] & {
 type CodecTypes = CodecTypes$1;
 //#endregion
 export { Ltree as n, LtreeArray as r, CodecTypes as t };
-//# sourceMappingURL=codec-types-BJE-5cwk.d.mts.map
+//# sourceMappingURL=codec-types-Ba5cQ3bc.d.mts.map

package/dist/codec-types-Ba5cQ3bc.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-Ba5cQ3bc.d.mts","names":[],"sources":["../src/core/constants.ts","../src/core/codecs.ts","../src/types/codec-types.ts"],"mappings":";;;;;cAAa,cAAA;AAAA,cAEA,oBAAA;;;cCoBA,UAAA,SAAmB,SAAA,QACvB,cAAA;EAKP,WAAA,CAAY,UAAA,EAAY,kBAAA;EAIlB,MAAA,CAAO,KAAA,UAAe,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAK/C,QAAA,CAAS,IAAA,UAAc,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAItD,eAAA,CAAgB,KAAA,WAAgB,aAAA;EAKhC,iBAAA,CAAkB,KAAA,EAAO,aAAA;AAAA;AAAA,cAKd,eAAA,SAAwB,uBAAA;EAAA,SACjB,QAAA;EAAA,UACC,cAAA,CAAe,UAAA,EAAY,cAAA,GAAiB,cAAA;EAAA,SAI7C,QAAA,mDAAQ,UAAA;EAAA,SACR,OAAA;EAAA,SACA,MAAA;EAAA,SACA,YAAA;EACT,gBAAA;EAGA,OAAA,KAAY,GAAA,EAAK,oBAAA,KAAyB,UAAA;AAAA;AAAA,cAaxC,eAAA,SAAwB,SAAA,QAC5B,oBAAA;EAKP,WAAA,CAAY,UAAA,EAAY,kBAAA;EAIlB,MAAA,CAAO,KAAA,qBAA0B,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAO1D,QAAA,CAAS,IAAA,qBAAyB,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAIjE,eAAA,CAAgB,KAAA,sBAA2B,aAAA;EAO3C,iBAAA,CAAkB,KAAA,EAAO,aAAA;AAAA;AAAA,cASd,oBAAA,SAA6B,uBAAA;EAAA,SACtB,QAAA;EAAA,UACC,cAAA,CAAe,UAAA,EAAY,cAAA,GAAiB,cAAA;EAAA,SAI7C,QAAA,mDAAQ,UAAA;EAAA,SACR,OAAA;EAAA,SACA,MAAA;EAAA,SACA,YAAA;EACT,gBAAA;EAGA,OAAA,KAAY,GAAA,EAAK,oBAAA,KAAyB,eAAA;AAAA;AAAA,cAc/C,kBAAA;EAAA,SACJ,KAAA,EAAK,eAAA;EAAA,SACL,UAAA,EAAU,oBAAA;AAAA;AAAA,KAGA,YAAA,GAAa,iBAAiB,QAAQ,kBAAA;;;KChJtC,KAAA;EAAA,SAA4B,OAAO;AAAA;AAAA,KAEnC,UAAA;EAAA,SAA4C,YAAY;AAAA;AAAA,KAExD,UAAA,GAAa,YAAc"}

package/dist/codec-types.d.mts

@@ -1,2 +1,2 @@
-import { n as Ltree, r as LtreeArray, t as CodecTypes } from "./codec-types-BJE-5cwk.mjs";
+import { n as Ltree, r as LtreeArray, t as CodecTypes } from "./codec-types-Ba5cQ3bc.mjs";
 export type { CodecTypes, Ltree, LtreeArray };

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;;cA+BM,wBAAA,EAA0B,6BAA6B"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;;cAkEM,wBAAA,EAA0B,6BAA6B"}

package/dist/control.mjs

@@ -1,8 +1,8 @@
 import { n as LTREE_CODEC_ID, t as LTREE_ARRAY_CODEC_ID } from "./constants-Dfknw-h5.mjs";
-import { n as ltreeQueryOperations, t as ltreePackMeta } from "./descriptor-meta-2In8FI1I.mjs";
+import { n as ltreeQueryOperations, t as ltreePackMeta } from "./descriptor-meta-Cc6tmP54.mjs";
 import { contractSpaceFromJson } from "@prisma/orm-toolchain/migration-tools/spaces";
 //#region migrations/20260619T2142_install_ltree/migration.json
-var migration_default = {
+var migration_default$4 = {
 	from: null,
 	to: "5842622c2779cd02acd640ab4a5c8979fc94a2af8ed034222391fbd4f7cb3706",
 	providedInvariants: ["ltree:install-ltree-v1"],
@@ -11,7 +11,7 @@ var migration_default = {
 };
 //#endregion
 //#region migrations/20260619T2142_install_ltree/ops.json
-var ops_default = [{
+var ops_default$4 = [{
 	"id": "ltree.install-ltree-extension",
 	"label": "Enable extension \"ltree\"",
 	"operationClass": "additive",
@@ -40,10 +40,183 @@ var ops_default = [{
 	}]
 }];
 //#endregion
+//#region migrations/20261111T1904_create_ltree_extension/migration.json
+var migration_default$3 = {
+	from: null,
+	to: "150f76958e7b1802cb3fb17b2792759d19e6aedf01f5fffa5f77565a2afe4582",
+	providedInvariants: [],
+	createdAt: "2026-11-11T19:04:24.423Z",
+	migrationHash: "1be2450ab00d5969e0a9f0fdb50daabcbf62f6768ea3a6ee92ef3a4dd6982d1c"
+};
+//#endregion
+//#region migrations/20261111T1904_create_ltree_extension/ops.json
+var ops_default$3 = [{
+	"id": "schema.public",
+	"label": "Create schema \"public\"",
+	"operationClass": "additive",
+	"target": { "id": "postgres" },
+	"precheck": [],
+	"execute": [{
+		"description": "Create schema \"public\"",
+		"sql": "CREATE SCHEMA IF NOT EXISTS \"public\"",
+		"params": []
+	}],
+	"postcheck": []
+}, {
+	"id": "extension.ltree",
+	"label": "Create extension \"ltree\"",
+	"operationClass": "additive",
+	"target": {
+		"id": "postgres",
+		"details": {
+			"schema": "public",
+			"objectType": "dependency",
+			"name": "ltree"
+		}
+	},
+	"precheck": [{
+		"description": "verify extension \"ltree\" is not installed",
+		"sql": "SELECT NOT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"],
+		"expectation": {
+			"expects": "absent",
+			"object": "extension \"ltree\""
+		}
+	}],
+	"execute": [{
+		"description": "create extension \"ltree\"",
+		"sql": "CREATE EXTENSION IF NOT EXISTS \"ltree\" WITH SCHEMA \"public\""
+	}],
+	"postcheck": [{
+		"description": "confirm extension \"ltree\" is installed",
+		"sql": "SELECT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"],
+		"expectation": {
+			"expects": "present",
+			"object": "extension \"ltree\""
+		}
+	}]
+}];
+//#endregion
+//#region migrations/20261111T1905_declare_ltree_extension/migration.json
+var migration_default$2 = {
+	from: "5842622c2779cd02acd640ab4a5c8979fc94a2af8ed034222391fbd4f7cb3706",
+	to: "150f76958e7b1802cb3fb17b2792759d19e6aedf01f5fffa5f77565a2afe4582",
+	providedInvariants: [],
+	createdAt: "2026-11-11T19:05:51.283Z",
+	migrationHash: "28790448876216e19e6aa7b6648ec0f101686dfdc604c377f3584f1f1588c874"
+};
+//#endregion
+//#region migrations/20261111T1905_declare_ltree_extension/ops.json
+var ops_default$2 = [{
+	"id": "extension.ltree",
+	"label": "Create extension \"ltree\"",
+	"operationClass": "additive",
+	"target": {
+		"id": "postgres",
+		"details": {
+			"schema": "public",
+			"objectType": "dependency",
+			"name": "ltree"
+		}
+	},
+	"precheck": [{
+		"description": "verify extension \"ltree\" is not installed",
+		"sql": "SELECT NOT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"],
+		"expectation": {
+			"expects": "absent",
+			"object": "extension \"ltree\""
+		}
+	}],
+	"execute": [{
+		"description": "create extension \"ltree\"",
+		"sql": "CREATE EXTENSION IF NOT EXISTS \"ltree\" WITH SCHEMA \"public\""
+	}],
+	"postcheck": [{
+		"description": "confirm extension \"ltree\" is installed",
+		"sql": "SELECT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"],
+		"expectation": {
+			"expects": "present",
+			"object": "extension \"ltree\""
+		}
+	}]
+}];
+//#endregion
+//#region migrations/20261111T1908_find_ltree_on_search_path/migration.json
+var migration_default$1 = {
+	from: "150f76958e7b1802cb3fb17b2792759d19e6aedf01f5fffa5f77565a2afe4582",
+	to: "6db18d99f118ef4e7fd359cf8bc472b9335bf3edeeefa8a15ee11eaf7742f9fb",
+	providedInvariants: [],
+	createdAt: "2026-11-11T19:08:52.615Z",
+	migrationHash: "3ee496921e534f39e639e5d3745d87f003a238809eda1453afc798f404f71d8d"
+};
+//#endregion
+//#region migrations/20261111T1908_find_ltree_on_search_path/ops.json
+var ops_default$1 = [];
+//#endregion
+//#region migrations/20261111T1908_install_ltree_on_search_path/migration.json
+var migration_default = {
+	from: null,
+	to: "6db18d99f118ef4e7fd359cf8bc472b9335bf3edeeefa8a15ee11eaf7742f9fb",
+	providedInvariants: [],
+	createdAt: "2026-11-11T19:08:53.983Z",
+	migrationHash: "29296a0599924fcb56de5a181f441206320676249c7d2cb4db1b3a1e6c160555"
+};
+//#endregion
+//#region migrations/20261111T1908_install_ltree_on_search_path/ops.json
+var ops_default = [{
+	"id": "schema.public",
+	"label": "Create schema \"public\"",
+	"operationClass": "additive",
+	"target": { "id": "postgres" },
+	"precheck": [],
+	"execute": [{
+		"description": "Create schema \"public\"",
+		"sql": "CREATE SCHEMA IF NOT EXISTS \"public\"",
+		"params": []
+	}],
+	"postcheck": []
+}, {
+	"id": "extension.ltree",
+	"label": "Create extension \"ltree\"",
+	"operationClass": "additive",
+	"target": {
+		"id": "postgres",
+		"details": {
+			"objectType": "dependency",
+			"name": "ltree"
+		}
+	},
+	"precheck": [{
+		"description": "verify extension \"ltree\" is not installed",
+		"sql": "SELECT NOT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"],
+		"expectation": {
+			"expects": "absent",
+			"object": "extension \"ltree\""
+		}
+	}],
+	"execute": [{
+		"description": "create extension \"ltree\"",
+		"sql": "CREATE EXTENSION IF NOT EXISTS \"ltree\""
+	}],
+	"postcheck": [{
+		"description": "confirm extension \"ltree\" is installed",
+		"sql": "SELECT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"],
+		"expectation": {
+			"expects": "present",
+			"object": "extension \"ltree\""
+		}
+	}]
+}];
+//#endregion
 //#region migrations/refs/head.json
 var head_default = {
-	hash: "5842622c2779cd02acd640ab4a5c8979fc94a2af8ed034222391fbd4f7cb3706",
-	invariants: ["ltree:install-ltree-v1"]
+	hash: "6db18d99f118ef4e7fd359cf8bc472b9335bf3edeeefa8a15ee11eaf7742f9fb",
+	invariants: []
 };
 //#endregion
 //#region src/contract.json
@@ -55,12 +228,25 @@ var contract_default = {
 	roots: {},
 	domain: { "namespaces": { "public": { "models": {} } } },
 	storage: {
-		"namespaces": { "public": {
-			"entries": { "table": {} },
-			"id": "public",
-			"kind": "postgres-schema"
-		} },
-		"storageHash": "5842622c2779cd02acd640ab4a5c8979fc94a2af8ed034222391fbd4f7cb3706",
+		"namespaces": {
+			"__unbound__": {
+				"entries": {
+					"extension": { "ltree": {
+						"kind": "extension",
+						"name": "ltree"
+					} },
+					"table": {}
+				},
+				"id": "__unbound__",
+				"kind": "postgres-unbound-schema"
+			},
+			"public": {
+				"entries": { "table": {} },
+				"id": "public",
+				"kind": "postgres-schema"
+			}
+		},
+		"storageHash": "6db18d99f118ef4e7fd359cf8bc472b9335bf3edeeefa8a15ee11eaf7742f9fb",
 		"types": {
 			"ltree": {
 				"codecId": "pg/ltree@1",
@@ -77,6 +263,8 @@ var contract_default = {
 	capabilities: {
 		"postgres": {
 			"distinctOn": true,
+			"forKeyShare": true,
+			"forNoKeyUpdate": true,
 			"jsonAgg": true,
 			"lateral": true,
 			"limit": true,
@@ -87,9 +275,15 @@ var contract_default = {
 			"checkConstraint": true,
 			"defaultInInsert": true,
 			"enums": true,
+			"forShare": true,
+			"forUpdate": true,
 			"insertOnConflictSkip": true,
+			"insertOnConflictTarget": true,
 			"insertOnConflictWithoutTarget": true,
 			"lateral": true,
+			"lockNowait": true,
+			"lockOf": true,
+			"lockSkipLocked": true,
 			"returning": true,
 			"scalarList": true
 		}
@@ -106,16 +300,42 @@ var contract_default = {
 //#region src/core/contract-space-constants.ts
 const LTREE_SPACE_ID = "ltree";
 const LTREE_BASELINE_MIGRATION_NAME = "20260619T2142_install_ltree";
+const LTREE_DECLARE_EXTENSION_MIGRATION_NAME = "20261111T1905_declare_ltree_extension";
+const LTREE_CREATE_EXTENSION_MIGRATION_NAME = "20261111T1904_create_ltree_extension";
+const LTREE_SEARCH_PATH_MIGRATION_NAME = "20261111T1908_find_ltree_on_search_path";
+const LTREE_SEARCH_PATH_INSTALL_MIGRATION_NAME = "20261111T1908_install_ltree_on_search_path";
 //#endregion
 //#region src/exports/control.ts
 const ltreeControlPlaneHooks = { resolveIdentityValue: () => null };
 const ltreeContractSpace = contractSpaceFromJson({
 	contractJson: contract_default,
-	migrations: [{
-		dirName: LTREE_BASELINE_MIGRATION_NAME,
-		metadata: migration_default,
-		ops: ops_default
-	}],
+	migrations: [
+		{
+			dirName: LTREE_BASELINE_MIGRATION_NAME,
+			metadata: migration_default$4,
+			ops: ops_default$4
+		},
+		{
+			dirName: LTREE_DECLARE_EXTENSION_MIGRATION_NAME,
+			metadata: migration_default$2,
+			ops: ops_default$2
+		},
+		{
+			dirName: LTREE_CREATE_EXTENSION_MIGRATION_NAME,
+			metadata: migration_default$3,
+			ops: ops_default$3
+		},
+		{
+			dirName: LTREE_SEARCH_PATH_MIGRATION_NAME,
+			metadata: migration_default$1,
+			ops: ops_default$1
+		},
+		{
+			dirName: LTREE_SEARCH_PATH_INSTALL_MIGRATION_NAME,
+			metadata: migration_default,
+			ops: ops_default
+		}
+	],
 	headRef: head_default
 });
 const ltreeExtensionDescriptor = {

package/dist/control.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"control.mjs","names":["baselineMetadata","baselineOps"],"sources":["../migrations/20260619T2142_install_ltree/migration.json","../migrations/20260619T2142_install_ltree/ops.json","../migrations/refs/head.json","../src/contract.json","../src/core/contract-space-constants.ts","../src/exports/control.ts"],"sourcesContent":["","","","","export const LTREE_SPACE_ID = \"ltree\" as const;\n\nexport const LTREE_NATIVE_TYPE = \"ltree\" as const;\n\n/** Contract storage.types key — must be a valid identifier for contract emit. */\nexport const LTREE_ARRAY_STORAGE_TYPE = \"ltreeArray\" as const;\n\nexport const LTREE_BASELINE_MIGRATION_NAME = \"20260619T2142_install_ltree\" as const;\n\nexport const LTREE_INVARIANTS = {\n  installLtree: \"ltree:install-ltree-v1\",\n} as const;\n","import type { Contract } from \"@prisma/orm-framework/contract/types\";\nimport type {\n  CodecControlHooks,\n  SqlControlExtensionDescriptor,\n} from \"@prisma/orm-family-sql/family/control\";\nimport { contractSpaceFromJson } from \"@prisma/orm-toolchain/migration-tools/spaces\";\nimport type { SqlStorage } from \"@prisma/orm-family-sql/contract/types\";\nimport baselineMetadata from \"../../migrations/20260619T2142_install_ltree/migration.json\" with { type: \"json\" };\nimport baselineOps from \"../../migrations/20260619T2142_install_ltree/ops.json\" with { type: \"json\" };\nimport headRef from \"../../migrations/refs/head.json\" with { type: \"json\" };\nimport contractJson from \"../contract.json\" with { type: \"json\" };\nimport { LTREE_ARRAY_CODEC_ID, LTREE_CODEC_ID } from \"../core/constants\";\nimport { LTREE_SPACE_ID, LTREE_BASELINE_MIGRATION_NAME } from \"../core/contract-space-constants\";\nimport { ltreePackMeta, ltreeQueryOperations } from \"../core/descriptor-meta\";\n\nconst ltreeControlPlaneHooks: CodecControlHooks = {\n  resolveIdentityValue: () => null,\n};\n\nconst ltreeContractSpace = contractSpaceFromJson<Contract<SqlStorage>>({\n  contractJson,\n  migrations: [\n    {\n      dirName: LTREE_BASELINE_MIGRATION_NAME,\n      metadata: baselineMetadata,\n      ops: baselineOps,\n    },\n  ],\n  headRef,\n});\n\nconst ltreeExtensionDescriptor: SqlControlExtensionDescriptor<\"postgres\"> = {\n  ...ltreePackMeta,\n  id: LTREE_SPACE_ID,\n  contractSpace: ltreeContractSpace,\n  types: {\n    ...ltreePackMeta.types,\n    codecTypes: {\n      ...ltreePackMeta.types.codecTypes,\n      controlPlaneHooks: {\n        [LTREE_CODEC_ID]: ltreeControlPlaneHooks,\n        [LTREE_ARRAY_CODEC_ID]: ltreeControlPlaneHooks,\n      },\n    },\n  },\n  queryOperations: () => ltreeQueryOperations(),\n  create: () => ({\n    familyId: \"sql\" as const,\n    targetId: \"postgres\" as const,\n  }),\n};\n\nexport { ltreeExtensionDescriptor };\nexport default ltreeExtensionDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AIAA,MAAa,iBAAiB;AAO9B,MAAa,gCAAgC;;;ACQ7C,MAAM,yBAA4C,EAChD,4BAA4B,KAC9B;AAEA,MAAM,qBAAqB,sBAA4C;CACrE,cAAA;CACA,YAAY,CACV;EACE,SAAS;EACT,UAAUA;EACV,KAAKC;CACP,CACF;CACA,SAAA;AACF,CAAC;AAED,MAAM,2BAAsE;CAC1E,GAAG;CACH,IAAI;CACJ,eAAe;CACf,OAAO;EACL,GAAG,cAAc;EACjB,YAAY;GACV,GAAG,cAAc,MAAM;GACvB,mBAAmB;KAChB,iBAAiB;KACjB,uBAAuB;GAC1B;EACF;CACF;CACA,uBAAuB,qBAAqB;CAC5C,eAAe;EACb,UAAU;EACV,UAAU;CACZ;AACF"}
+{"version":3,"file":"control.mjs","names":["baselineMetadata","baselineOps","declareMetadata","declareOps","createMetadata","createOps","searchPathMetadata","searchPathOps","searchPathInstallMetadata","searchPathInstallOps"],"sources":["../migrations/20260619T2142_install_ltree/migration.json","../migrations/20260619T2142_install_ltree/ops.json","../migrations/20261111T1904_create_ltree_extension/migration.json","../migrations/20261111T1904_create_ltree_extension/ops.json","../migrations/20261111T1905_declare_ltree_extension/migration.json","../migrations/20261111T1905_declare_ltree_extension/ops.json","../migrations/20261111T1908_find_ltree_on_search_path/migration.json","../migrations/20261111T1908_find_ltree_on_search_path/ops.json","../migrations/20261111T1908_install_ltree_on_search_path/migration.json","../migrations/20261111T1908_install_ltree_on_search_path/ops.json","../migrations/refs/head.json","../src/contract.json","../src/core/contract-space-constants.ts","../src/exports/control.ts"],"sourcesContent":["","","","","","","","","","","","","export const LTREE_SPACE_ID = \"ltree\" as const;\n\nexport const LTREE_NATIVE_TYPE = \"ltree\" as const;\n\n/** Contract storage.types key — must be a valid identifier for contract emit. */\nexport const LTREE_ARRAY_STORAGE_TYPE = \"ltreeArray\" as const;\n\nexport const LTREE_BASELINE_MIGRATION_NAME = \"20260619T2142_install_ltree\" as const;\n\nexport const LTREE_DECLARE_EXTENSION_MIGRATION_NAME =\n  \"20261111T1905_declare_ltree_extension\" as const;\n\nexport const LTREE_CREATE_EXTENSION_MIGRATION_NAME =\n  \"20261111T1904_create_ltree_extension\" as const;\n\nexport const LTREE_SEARCH_PATH_MIGRATION_NAME = \"20261111T1908_find_ltree_on_search_path\" as const;\n\nexport const LTREE_SEARCH_PATH_INSTALL_MIGRATION_NAME =\n  \"20261111T1908_install_ltree_on_search_path\" as const;\n\nexport const LTREE_INVARIANTS = {\n  installLtree: \"ltree:install-ltree-v1\",\n} as const;\n","import type { Contract } from \"@prisma/orm-framework/contract/types\";\nimport type {\n  CodecControlHooks,\n  SqlControlExtensionDescriptor,\n} from \"@prisma/orm-family-sql/family/control\";\nimport { contractSpaceFromJson } from \"@prisma/orm-toolchain/migration-tools/spaces\";\nimport type { SqlStorage } from \"@prisma/orm-family-sql/contract/types\";\nimport baselineMetadata from \"../../migrations/20260619T2142_install_ltree/migration.json\" with { type: \"json\" };\nimport baselineOps from \"../../migrations/20260619T2142_install_ltree/ops.json\" with { type: \"json\" };\nimport createMetadata from \"../../migrations/20261111T1904_create_ltree_extension/migration.json\" with { type: \"json\" };\nimport createOps from \"../../migrations/20261111T1904_create_ltree_extension/ops.json\" with { type: \"json\" };\nimport declareMetadata from \"../../migrations/20261111T1905_declare_ltree_extension/migration.json\" with { type: \"json\" };\nimport declareOps from \"../../migrations/20261111T1905_declare_ltree_extension/ops.json\" with { type: \"json\" };\nimport searchPathMetadata from \"../../migrations/20261111T1908_find_ltree_on_search_path/migration.json\" with { type: \"json\" };\nimport searchPathOps from \"../../migrations/20261111T1908_find_ltree_on_search_path/ops.json\" with { type: \"json\" };\nimport searchPathInstallMetadata from \"../../migrations/20261111T1908_install_ltree_on_search_path/migration.json\" with { type: \"json\" };\nimport searchPathInstallOps from \"../../migrations/20261111T1908_install_ltree_on_search_path/ops.json\" with { type: \"json\" };\nimport headRef from \"../../migrations/refs/head.json\" with { type: \"json\" };\nimport contractJson from \"../contract.json\" with { type: \"json\" };\nimport { LTREE_ARRAY_CODEC_ID, LTREE_CODEC_ID } from \"../core/constants\";\nimport {\n  LTREE_BASELINE_MIGRATION_NAME,\n  LTREE_CREATE_EXTENSION_MIGRATION_NAME,\n  LTREE_DECLARE_EXTENSION_MIGRATION_NAME,\n  LTREE_SEARCH_PATH_INSTALL_MIGRATION_NAME,\n  LTREE_SEARCH_PATH_MIGRATION_NAME,\n  LTREE_SPACE_ID,\n} from \"../core/contract-space-constants\";\nimport { ltreePackMeta, ltreeQueryOperations } from \"../core/descriptor-meta\";\n\nconst ltreeControlPlaneHooks: CodecControlHooks = {\n  resolveIdentityValue: () => null,\n};\n\nconst ltreeContractSpace = contractSpaceFromJson<Contract<SqlStorage>>({\n  contractJson,\n  migrations: [\n    {\n      dirName: LTREE_BASELINE_MIGRATION_NAME,\n      metadata: baselineMetadata,\n      ops: baselineOps,\n    },\n    {\n      dirName: LTREE_DECLARE_EXTENSION_MIGRATION_NAME,\n      metadata: declareMetadata,\n      ops: declareOps,\n    },\n    {\n      dirName: LTREE_CREATE_EXTENSION_MIGRATION_NAME,\n      metadata: createMetadata,\n      ops: createOps,\n    },\n    {\n      dirName: LTREE_SEARCH_PATH_MIGRATION_NAME,\n      metadata: searchPathMetadata,\n      ops: searchPathOps,\n    },\n    {\n      dirName: LTREE_SEARCH_PATH_INSTALL_MIGRATION_NAME,\n      metadata: searchPathInstallMetadata,\n      ops: searchPathInstallOps,\n    },\n  ],\n  headRef,\n});\n\nconst ltreeExtensionDescriptor: SqlControlExtensionDescriptor<\"postgres\"> = {\n  ...ltreePackMeta,\n  id: LTREE_SPACE_ID,\n  contractSpace: ltreeContractSpace,\n  types: {\n    ...ltreePackMeta.types,\n    codecTypes: {\n      ...ltreePackMeta.types.codecTypes,\n      controlPlaneHooks: {\n        [LTREE_CODEC_ID]: ltreeControlPlaneHooks,\n        [LTREE_ARRAY_CODEC_ID]: ltreeControlPlaneHooks,\n      },\n    },\n  },\n  queryOperations: () => ltreeQueryOperations(),\n  create: () => ({\n    familyId: \"sql\" as const,\n    targetId: \"postgres\" as const,\n  }),\n};\n\nexport { ltreeExtensionDescriptor };\nexport default ltreeExtensionDescriptor;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AYAA,MAAa,iBAAiB;AAO9B,MAAa,gCAAgC;AAE7C,MAAa,yCACX;AAEF,MAAa,wCACX;AAEF,MAAa,mCAAmC;AAEhD,MAAa,2CACX;;;ACYF,MAAM,yBAA4C,EAChD,4BAA4B,KAC9B;AAEA,MAAM,qBAAqB,sBAA4C;CACrE,cAAA;CACA,YAAY;EACV;GACE,SAAS;GACT,UAAUA;GACV,KAAKC;EACP;EACA;GACE,SAAS;GACT,UAAUC;GACV,KAAKC;EACP;EACA;GACE,SAAS;GACT,UAAUC;GACV,KAAKC;EACP;EACA;GACE,SAAS;GACT,UAAUC;GACV,KAAKC;EACP;EACA;GACE,SAAS;GACT,UAAUC;GACV,KAAKC;EACP;CACF;CACA,SAAA;AACF,CAAC;AAED,MAAM,2BAAsE;CAC1E,GAAG;CACH,IAAI;CACJ,eAAe;CACf,OAAO;EACL,GAAG,cAAc;EACjB,YAAY;GACV,GAAG,cAAc,MAAM;GACvB,mBAAmB;KAChB,iBAAiB;KACjB,uBAAuB;GAC1B;EACF;CACF;CACA,uBAAuB,qBAAqB;CAC5C,eAAe;EACb,UAAU;EACV,UAAU;CACZ;AACF"}

package/dist/{descriptor-meta-2In8FI1I.mjs → descriptor-meta-Cc6tmP54.mjs}

@@ -1,9 +1,10 @@
 import { i as LTREE_MAX_LABEL_LENGTH, n as LTREE_CODEC_ID, r as LTREE_MAX_LABELS, t as LTREE_ARRAY_CODEC_ID } from "./constants-Dfknw-h5.mjs";
 import { buildOperation, codecOf, toExpr } from "@prisma/orm-family-sql/relational-core/expression";
+import { CodecImpl, refuseJsonValue } from "@prisma/orm-framework/components/codec";
 import { sqlDataType } from "@prisma/orm-family-sql/contract/data-type";
 import { pgText } from "@prisma/orm-target-postgres/target/data-types";
 import { buildCodecDescriptorRegistry } from "@prisma/orm-family-sql/relational-core/codec-descriptor-registry";
-import { CodecImpl } from "@prisma/orm-framework/components/codec";
+import { CastExpr } from "@prisma/orm-family-sql/relational-core/ast";
 import { PostgresCodecDescriptor, definePostgresCodecs } from "@prisma/orm-target-postgres/target/codec-descriptor";
 //#region src/core/authoring.ts
 const ltreeAuthoringTypes = { ltree: {
@@ -19,8 +20,32 @@ const ltreeAuthoringTypes = { ltree: {
 	}
 } };
 //#endregion
+//#region src/core/codecs-validation.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`);
+	}
+}
+//#endregion
 //#region src/core/data-types.ts
+const readLtree = (json) => {
+	if (typeof json !== "string") return refuseJsonValue("ltree/ltree", "an ltree path string", json);
+	try {
+		assertValidLtree(json);
+	} catch {
+		return refuseJsonValue("ltree/ltree", "a valid ltree path string", json);
+	}
+	return json;
+};
 const ltreeDataType = sqlDataType("ltree/ltree", {
+	read: readLtree,
 	texts: [{
 		text: "ltree",
 		written: true,
@@ -28,15 +53,31 @@ const ltreeDataType = sqlDataType("ltree/ltree", {
 	}],
 	casts: { [pgText.id]: (value) => value }
 });
+const readLtreeArray = (json) => {
+	const expected = "an array of ltree path strings";
+	if (!Array.isArray(json)) return refuseJsonValue("ltree/ltree-array", expected, json);
+	for (const entry of json) {
+		if (typeof entry !== "string") return refuseJsonValue("ltree/ltree-array", expected, entry);
+		try {
+			assertValidLtree(entry);
+		} catch {
+			return refuseJsonValue("ltree/ltree-array", expected, entry);
+		}
+	}
+	return json;
+};
 /**
 * `sqlDataType` accepts parentheses in a type name and refuses square brackets.
 * PostgreSQL writes this type as `ltree[]`, and `format_type` reports `ltree[]`.
 * Declare the type first, then set that text so a migration and a catalog check use it.
 */
-const ltreeArrayDeclared = sqlDataType("ltree/ltree-array", { listCast: {
-	of: [pgText.id],
-	cast: (elements) => [...elements]
-} });
+const ltreeArrayDeclared = sqlDataType("ltree/ltree-array", {
+	read: readLtreeArray,
+	listCast: {
+		of: [pgText.id],
+		cast: (elements) => [...elements]
+	}
+});
 const ltreeArrayDataType = {
 	...ltreeArrayDeclared,
 	sql: {
@@ -51,38 +92,29 @@ const ltreeArrayDataType = {
 const ltreeDataTypes = [ltreeDataType, ltreeArrayDataType];
 //#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) {
+	constructor(descriptor) {
+		super(descriptor, ltreeDataType);
+	}
+	async toWire(value, _ctx) {
 		assertValidLtree(value);
 		return value;
 	}
-	async decode(wire, _ctx) {
+	async fromWire(wire, _ctx) {
 		return wire;
 	}
-	encodeJson(value) {
+	toDataTypeValue(value) {
 		assertValidLtree(value);
-		return value;
+		return this.dataTypeValueOf(value);
 	}
-	decodeJson(json) {
-		assertValidLtree(json);
-		return json;
+	fromDataTypeValue(value) {
+		return value.value;
 	}
 };
 var LtreeDescriptor = class extends PostgresCodecDescriptor {
+	jsonType = "string";
 	jsonProjection(expression) {
-		return expression;
+		return CastExpr.as(expression, "text");
 	}
 	dataType = ltreeDataType.id;
 	codecId = LTREE_CODEC_ID;
@@ -98,26 +130,28 @@ var LtreeDescriptor = class extends PostgresCodecDescriptor {
 };
 const ltreeDescriptor = new LtreeDescriptor();
 var LtreeArrayCodec = class extends CodecImpl {
-	async encode(value, _ctx) {
+	constructor(descriptor) {
+		super(descriptor, ltreeArrayDataType);
+	}
+	async toWire(value, _ctx) {
 		for (const entry of value) assertValidLtree(entry);
 		return value;
 	}
-	async decode(wire, _ctx) {
+	async fromWire(wire, _ctx) {
 		return wire;
 	}
-	encodeJson(value) {
+	toDataTypeValue(value) {
 		for (const entry of value) assertValidLtree(entry);
-		return [...value];
+		return this.dataTypeValueOf([...value]);
 	}
-	decodeJson(json) {
+	fromDataTypeValue(value) {
+		const json = value.value;
 		if (!Array.isArray(json)) return [];
-		return json.map((entry) => {
-			assertValidLtree(entry);
-			return String(entry);
-		});
+		return json.map((entry) => String(entry));
 	}
 };
 var LtreeArrayDescriptor = class extends PostgresCodecDescriptor {
+	jsonType = "array";
 	jsonProjection(expression) {
 		return expression;
 	}
@@ -365,4 +399,4 @@ const ltreePackMeta = {
 //#endregion
 export { ltreeQueryOperations as n, ltreeCodecRegistry as r, ltreePackMeta as t };
 
-//# sourceMappingURL=descriptor-meta-2In8FI1I.mjs.map
+//# sourceMappingURL=descriptor-meta-Cc6tmP54.mjs.map