prisma-ltree 0.0.1 → 0.1.0

package/README.md

@@ -1,9 +1,214 @@
 # prisma-ltree
 
-Prisma extension for PostgreSQL `ltree` — hierarchical tree data type support.
+A [Prisma Next](https://github.com/prisma/prisma) extension pack for PostgreSQL's
+[`ltree`](https://www.postgresql.org/docs/current/ltree.html) hierarchical-tree data type.
 
-> **Status:** Placeholder. Full implementation in development.
+Model category trees, org charts, taxonomies, and filesystem-like paths in Postgres and query
+them with type-safe, prisma-native operators — ancestor/descendant checks, `lquery`/`ltxtquery`
+pattern matching, path manipulation, and lowest-common-ancestor computation — without dropping to
+raw SQL.
+
+## Overview
+
+This extension pack provides:
+
+- **`pg/ltree@1` codec** — `string ↔ string` with label-syntax + length validation (traits
+  `['equality', 'order']`).
+- **`pg/ltree-array@1` codec** — `string[] ↔ string[]` with per-element validation, for the
+  `ltree[]` first-match operators (see [ADR-003](../../docs/decisions/ADR-003-array-receiver.md)).
+- **`ltree()` / `ltreeArray()` column helpers** — non-parameterized columns with `nativeType`
+  `'ltree'` / `'ltree[]'`.
+- **Query operators** — hierarchy, pattern-match, scalar functions, concatenation, conversion, and
+  array first-match operators (full list under [Operations](#operations)).
+- **Baseline migration** — installs the Postgres extension via
+  `CREATE EXTENSION IF NOT EXISTS ltree` (invariantId `ltree:install-ltree-v1`).
+- **Multi-plane entrypoints** — `/control`, `/runtime`, `/column-types`, `/codec-types`,
+  `/operation-types`, `/pack`.
+
+The single source of truth for what is supported, planned, or out-of-scope is
+[`docs/feature-support.md`](../../docs/feature-support.md).
+
+## Installation
+
+```bash
+pnpm add prisma-ltree
+```
+
+Requires Node `>=24` and `@prisma-next/*@0.14.0`.
+
+## Database Setup
+
+The extension ships an on-disk baseline migration that installs `ltree` when the pack is composed
+into an application. `prisma-next db init` / `db update` apply it automatically. The equivalent
+manual DDL is:
+
+```sql
+CREATE EXTENSION IF NOT EXISTS ltree;
+```
+
+## Configuration
+
+Add the pack to your `prisma-next.config.ts`:
+
+```typescript
+import { defineConfig } from "@prisma-next/cli/config-types";
+import postgresAdapter from "@prisma-next/adapter-postgres/control";
+import sql from "@prisma-next/family-sql/control";
+import postgres from "@prisma-next/target-postgres/control";
+import ltree from "prisma-ltree/control";
+
+export default defineConfig({
+  family: sql,
+  target: postgres,
+  adapter: postgresAdapter,
+  extensionPacks: [ltree],
+});
+```
+
+## Usage
+
+### Contract Definition
+
+```typescript
+import { int4Column, textColumn } from "@prisma-next/adapter-postgres/column-types";
+import sqlFamily from "@prisma-next/family-sql/pack";
+import { defineContract, field, model } from "@prisma-next/sql-contract-ts/contract-builder";
+import { ltree } from "prisma-ltree/column-types";
+import ltreePack from "prisma-ltree/pack";
+import postgres from "@prisma-next/target-postgres/pack";
+
+export const contract = defineContract({
+  family: sqlFamily,
+  target: postgres,
+  extensionPacks: { ltree: ltreePack },
+  models: {
+    Category: model("Category", {
+      fields: {
+        id: field.column(int4Column).id(),
+        name: field.column(textColumn),
+        path: field.column(ltree()),
+      },
+    }).sql({ table: "category" }),
+  },
+});
+```
+
+### Runtime Setup
+
+```typescript
+import { instantiateExecutionStack } from "@prisma-next/framework-components/execution";
+import { createExecutionContext, createSqlExecutionStack } from "@prisma-next/sql-runtime";
+import postgresAdapter from "@prisma-next/adapter-postgres/runtime";
+import postgresTarget from "@prisma-next/target-postgres/runtime";
+import ltree from "prisma-ltree/runtime";
+
+const stack = createSqlExecutionStack({
+  target: postgresTarget,
+  adapter: postgresAdapter,
+  extensionPacks: [ltree],
+});
+const context = createExecutionContext({ contract, stack });
+const stackInstance = instantiateExecutionStack(stack);
+```
+
+### Query Usage
+
+```typescript
+import { sql, tables } from "../prisma/query";
+import { param } from "@prisma-next/sql-query/param";
+
+// Find every descendant of "Top.Science"
+const plan = sql
+  .from(tables.category)
+  .select({
+    id: tables.category.columns.id,
+    depth: tables.category.columns.path.nlevel(),
+  })
+  .where(tables.category.columns.path.isDescendantOf(param("prefix")))
+  .build({ params: { prefix: "Top.Science" } });
+```
+
+## Operations
+
+All boolean operators return `pg/bool@1`. See
+[`docs/feature-support.md`](../../docs/feature-support.md) for the authoritative matrix.
+
+### Hierarchy (→ boolean)
+
+| Method                     | SQL              |
+| -------------------------- | ---------------- |
+| `path.isAncestorOf(rhs)`   | `ltree @> ltree` |
+| `path.isDescendantOf(rhs)` | `ltree <@ ltree` |
+
+### Pattern matching (→ boolean)
+
+| Method                              | SQL                 | Arg        |
+| ----------------------------------- | ------------------- | ---------- |
+| `path.matchesLquery(pattern)`       | `ltree ~ lquery`    | `string`   |
+| `path.matchesLqueryArray(patterns)` | `ltree ? lquery[]`  | `string[]` |
+| `path.matchesLtxtquery(query)`      | `ltree @ ltxtquery` | `string`   |
+
+### Scalar functions
+
+| Method                       | SQL                           | Returns      |
+| ---------------------------- | ----------------------------- | ------------ |
+| `path.nlevel()`              | `nlevel(ltree)`               | `pg/int4@1`  |
+| `path.subltree(start, end)`  | `subltree(ltree, start, end)` | `pg/ltree@1` |
+| `path.subpath(offset, len?)` | `subpath(ltree, offset, len)` | `pg/ltree@1` |
+| `path.indexOf(other, off?)`  | `index(ltree, ltree, off)`    | `pg/int4@1`  |
+| `path.lca(other, ...rest)`   | `lca(ltree, ltree, ...)`      | `pg/ltree@1` |
+
+`lca` is a variadic method requiring **≥2 paths** and returns the proper (strictly shorter) lowest
+common ancestor (see [ADR-001](../../docs/decisions/ADR-001-lca-api-shape.md)).
+
+### Concatenation (→ ltree) & conversion
+
+| Method                    | SQL                 | Returns      |
+| ------------------------- | ------------------- | ------------ |
+| `path.concat(rhs)`        | `ltree \|\| ltree`  | `pg/ltree@1` |
+| `path.concatText(label)`  | `ltree \|\| text`   | `pg/ltree@1` |
+| `path.prependText(label)` | `text \|\| ltree`   | `pg/ltree@1` |
+| `path.toText()`           | `ltree2text(ltree)` | `pg/text@1`  |
+| `text.toLtree()`          | `text2ltree(text)`  | `pg/ltree@1` |
+
+`prependText` keeps the ltree column as the receiver even though it is the right operand, and
+`toLtree` is rooted on a text column (see
+[ADR-002](../../docs/decisions/ADR-002-free-function-lowering.md)).
+
+### Array first-match (→ ltree, receiver `ltree[]`)
+
+| Method                             | SQL                    |
+| ---------------------------------- | ---------------------- |
+| `paths.firstAncestorOf(rhs)`       | `ltree[] ?@> ltree`    |
+| `paths.firstDescendantOf(rhs)`     | `ltree[] ?<@ ltree`    |
+| `paths.firstMatchLquery(pattern)`  | `ltree[] ?~ lquery`    |
+| `paths.firstMatchLtxtquery(query)` | `ltree[] ?@ ltxtquery` |
+
+## Types
+
+```typescript
+import type { CodecTypes, Ltree, LtreeArray } from "prisma-ltree/codec-types";
+import type { QueryOperationTypes } from "prisma-ltree/operation-types";
+
+// CodecTypes['pg/ltree@1']['output']       = string
+// CodecTypes['pg/ltree-array@1']['output'] = readonly string[]
+```
+
+## Development
+
+This package is built with [Vite+](https://viteplus.dev/):
+
+```bash
+vp install        # install dependencies
+vp check          # format, lint, typecheck
+vp test           # run unit + integration + type-level tests
+vp test --coverage # enforce the 95% coverage threshold
+vp run build      # build dist/
+```
+
+Integration tests run against [PGlite](https://pglite.dev/) with the `ltree` contrib extension —
+every operator is lowered through a composed Postgres runtime adapter and executed for real.
 
 ## License
 
-MIT
+Apache-2.0

package/dist/codec-types-mZn-cIh9.d.mts

@@ -0,0 +1,73 @@
+import { CodecCallContext, CodecDescriptorImpl, CodecImpl, CodecInstanceContext } from "@prisma-next/framework-components/codec";
+import { JsonValue } from "@prisma-next/contract/types";
+import { ExtractCodecTypes } from "@prisma-next/sql-relational-core/ast";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/core/constants.d.ts
+declare const LTREE_CODEC_ID: "pg/ltree@1";
+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;
+}
+declare class LtreeDescriptor extends CodecDescriptorImpl<void> {
+  readonly codecId: "pg/ltree@1";
+  readonly traits: readonly ["equality", "order"];
+  readonly targetTypes: readonly ["ltree"];
+  readonly meta: {
+    readonly db: {
+      readonly sql: {
+        readonly postgres: {
+          readonly nativeType: "ltree";
+        };
+      };
+    };
+  };
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderOutputType(): string;
+  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[];
+}
+declare class LtreeArrayDescriptor extends CodecDescriptorImpl<void> {
+  readonly codecId: "pg/ltree-array@1";
+  readonly traits: readonly ["equality"];
+  readonly targetTypes: readonly ["ltree[]"];
+  readonly meta: {
+    readonly db: {
+      readonly sql: {
+        readonly postgres: {
+          readonly nativeType: "ltree[]";
+        };
+      };
+    };
+  };
+  readonly paramsSchema: StandardSchemaV1<void>;
+  renderOutputType(): string;
+  factory(): (ctx: CodecInstanceContext) => LtreeArrayCodec;
+}
+declare const codecDescriptorMap: {
+  readonly ltree: LtreeDescriptor;
+  readonly ltreeArray: LtreeArrayDescriptor;
+};
+type CodecTypes$1 = ExtractCodecTypes<typeof codecDescriptorMap>;
+//#endregion
+//#region src/types/codec-types.d.ts
+type Ltree = string & {
+  readonly __ltree?: undefined;
+};
+type LtreeArray = readonly string[] & {
+  readonly __ltreeArray?: undefined;
+};
+type CodecTypes = CodecTypes$1;
+//#endregion
+export { Ltree as n, LtreeArray as r, CodecTypes as t };
+//# sourceMappingURL=codec-types-mZn-cIh9.d.mts.map

package/dist/codec-types-mZn-cIh9.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-mZn-cIh9.d.mts","names":[],"sources":["../src/core/constants.ts","../src/core/codecs.ts","../src/types/codec-types.ts"],"mappings":";;;;;;cAAa,cAAA;AAAA,cAEA,oBAAA;;;cCkDA,UAAA,SAAmB,SAAA,QACvB,cAAA;EAKD,MAAA,CAAO,KAAA,UAAe,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAK/C,MAAA,CAAO,IAAA,UAAc,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAIpD,UAAA,CAAW,KAAA,WAAgB,SAAA;EAK3B,UAAA,CAAW,IAAA,EAAM,SAAA;AAAA;AAAA,cAQN,eAAA,SAAwB,mBAAA;EAAA,SACjB,OAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,IAAA;IAAA;eANO,GAAA;QAAA,SAAO,QAAA;UAAA,SAAY,UAAA;QAAA;MAAA;IAAA;EAAA;EAAA,SAO1B,YAAA,EAAc,gBAAA;EACvB,gBAAA;EAGA,OAAA,KAAY,GAAA,EAAK,oBAAA,KAAyB,UAAA;AAAA;AAAA,cAkBxC,eAAA,SAAwB,SAAA,QAC5B,oBAAA;EAKD,MAAA,CAAO,KAAA,qBAA0B,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAO1D,MAAA,CAAO,IAAA,qBAAyB,IAAA,EAAM,gBAAA,GAAmB,OAAA;EAI/D,UAAA,CAAW,KAAA,sBAA2B,SAAA;EAOtC,UAAA,CAAW,IAAA,EAAM,SAAA;AAAA;AAAA,cAWN,oBAAA,SAA6B,mBAAA;EAAA,SACtB,OAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,IAAA;IAAA;eA1CZ,GAAA;QAAA,SAAO,QAAA;UAAA,SAAY,UAAA;QAAA;MAAA;IAAA;EAAA;EAAA,SA2CP,YAAA,EAAc,gBAAA;EACvB,gBAAA;EAGA,OAAA,KAAY,GAAA,EAAK,oBAAA,KAAyB,eAAA;AAAA;AAAA,cAmB/C,kBAAA;EAAA,SACJ,KAAA,EAAK,eAAA;EAAA,SACL,UAAA,EAAU,oBAAA;AAAA;AAAA,KAGA,YAAA,GAAa,iBAAiB,QAAQ,kBAAA;;;KC7KtC,KAAA;EAAA,SAA4B,OAAO;AAAA;AAAA,KAEnC,UAAA;EAAA,SAA4C,YAAY;AAAA;AAAA,KAExD,UAAA,GAAa,YAAc"}

package/dist/codec-types.d.mts

@@ -0,0 +1,2 @@
+import { n as Ltree, r as LtreeArray, t as CodecTypes } from "./codec-types-mZn-cIh9.mjs";
+export type { CodecTypes, Ltree, LtreeArray };

package/dist/codec-types.mjs

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

package/dist/column-types.d.mts

@@ -0,0 +1,8 @@
+import { ColumnTypeDescriptor } from "@prisma-next/framework-components/codec";
+
+//#region src/exports/column-types.d.ts
+declare function ltree(): ColumnTypeDescriptor;
+declare function ltreeArray(): ColumnTypeDescriptor;
+//#endregion
+export { ltree, ltreeArray };
+//# sourceMappingURL=column-types.d.mts.map

package/dist/column-types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/exports/column-types.ts"],"mappings":";;;iBAIgB,KAAA,IAAS,oBAAoB;AAAA,iBAO7B,UAAA,IAAc,oBAAoB"}

package/dist/column-types.mjs

@@ -0,0 +1,18 @@
+import { a as LTREE_ARRAY_CODEC_ID, o as LTREE_CODEC_ID, r as LTREE_NATIVE_TYPE, t as LTREE_ARRAY_NATIVE_TYPE } from "./contract-space-constants-Da9EC668.mjs";
+//#region src/exports/column-types.ts
+function ltree() {
+	return {
+		codecId: LTREE_CODEC_ID,
+		nativeType: LTREE_NATIVE_TYPE
+	};
+}
+function ltreeArray() {
+	return {
+		codecId: LTREE_ARRAY_CODEC_ID,
+		nativeType: LTREE_ARRAY_NATIVE_TYPE
+	};
+}
+//#endregion
+export { ltree, ltreeArray };
+
+//# sourceMappingURL=column-types.mjs.map

package/dist/column-types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-types.mjs","names":[],"sources":["../src/exports/column-types.ts"],"sourcesContent":["import type { ColumnTypeDescriptor } from \"@prisma-next/framework-components/codec\";\nimport { LTREE_ARRAY_CODEC_ID, LTREE_CODEC_ID } from \"../core/constants\";\nimport { LTREE_ARRAY_NATIVE_TYPE, LTREE_NATIVE_TYPE } from \"../core/contract-space-constants\";\n\nexport function ltree(): ColumnTypeDescriptor {\n  return {\n    codecId: LTREE_CODEC_ID,\n    nativeType: LTREE_NATIVE_TYPE,\n  } as const;\n}\n\nexport function ltreeArray(): ColumnTypeDescriptor {\n  return {\n    codecId: LTREE_ARRAY_CODEC_ID,\n    nativeType: LTREE_ARRAY_NATIVE_TYPE,\n  } as const;\n}\n"],"mappings":";;AAIA,SAAgB,QAA8B;CAC5C,OAAO;EACL,SAAS;EACT,YAAY;CACd;AACF;AAEA,SAAgB,aAAmC;CACjD,OAAO;EACL,SAAS;EACT,YAAY;CACd;AACF"}

package/dist/contract-space-constants-Da9EC668.mjs

@@ -0,0 +1,15 @@
+//#region src/core/constants.ts
+const LTREE_CODEC_ID = "pg/ltree@1";
+const LTREE_ARRAY_CODEC_ID = "pg/ltree-array@1";
+const LTREE_MAX_LABEL_LENGTH = 1e3;
+const LTREE_MAX_LABELS = 65535;
+//#endregion
+//#region src/core/contract-space-constants.ts
+const LTREE_SPACE_ID = "ltree";
+const LTREE_NATIVE_TYPE = "ltree";
+const LTREE_ARRAY_NATIVE_TYPE = "ltree[]";
+const LTREE_BASELINE_MIGRATION_NAME = "20260619T2142_install_ltree";
+//#endregion
+export { LTREE_ARRAY_CODEC_ID as a, LTREE_MAX_LABEL_LENGTH as c, LTREE_SPACE_ID as i, LTREE_BASELINE_MIGRATION_NAME as n, LTREE_CODEC_ID as o, LTREE_NATIVE_TYPE as r, LTREE_MAX_LABELS as s, LTREE_ARRAY_NATIVE_TYPE as t };
+
+//# sourceMappingURL=contract-space-constants-Da9EC668.mjs.map

package/dist/contract-space-constants-Da9EC668.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-space-constants-Da9EC668.mjs","names":[],"sources":["../src/core/constants.ts","../src/core/contract-space-constants.ts"],"sourcesContent":["export const LTREE_CODEC_ID = \"pg/ltree@1\" as const;\n\nexport const LTREE_ARRAY_CODEC_ID = \"pg/ltree-array@1\" as const;\n\nexport const LTREE_MAX_LABEL_LENGTH = 1000;\n\nexport const LTREE_MAX_LABELS = 65535;\n","export const LTREE_SPACE_ID = \"ltree\" as const;\n\nexport const LTREE_NATIVE_TYPE = \"ltree\" as const;\n\nexport const LTREE_ARRAY_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"],"mappings":";AAAA,MAAa,iBAAiB;AAE9B,MAAa,uBAAuB;AAEpC,MAAa,yBAAyB;AAEtC,MAAa,mBAAmB;;;ACNhC,MAAa,iBAAiB;AAE9B,MAAa,oBAAoB;AAEjC,MAAa,0BAA0B;AAKvC,MAAa,gCAAgC"}

package/dist/control.d.mts

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

package/dist/control.d.mts.map

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

package/dist/control.mjs

@@ -0,0 +1,139 @@
+import { a as LTREE_ARRAY_CODEC_ID, i as LTREE_SPACE_ID, n as LTREE_BASELINE_MIGRATION_NAME, o as LTREE_CODEC_ID } from "./contract-space-constants-Da9EC668.mjs";
+import { n as ltreeQueryOperations, t as ltreePackMeta } from "./descriptor-meta-B84muAZG.mjs";
+import { contractSpaceFromJson } from "@prisma-next/migration-tools/spaces";
+//#region migrations/app/20260619T2142_install_ltree/migration.json
+var migration_default = {
+	from: null,
+	to: "sha256:81cc0a29674d926c9089886b1941ba66d6ce26ec5644fc8a0b7c92a5e9e9876e",
+	providedInvariants: ["ltree:install-ltree-v1"],
+	createdAt: "2026-06-19T21:42:51.612Z",
+	migrationHash: "sha256:12135607df23ecea31aaf9e402703096cfcb236abf9e48a6797de2e74208700a"
+};
+//#endregion
+//#region migrations/app/20260619T2142_install_ltree/ops.json
+var ops_default = [{
+	"id": "ltree.install-ltree-extension",
+	"label": "Enable extension \"ltree\"",
+	"operationClass": "additive",
+	"invariantId": "ltree:install-ltree-v1",
+	"target": {
+		"id": "postgres",
+		"details": {
+			"schema": "public",
+			"objectType": "dependency",
+			"name": "ltree"
+		}
+	},
+	"precheck": [{
+		"description": "verify extension \"ltree\" is not already enabled",
+		"sql": "SELECT NOT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"]
+	}],
+	"execute": [{
+		"description": "create extension \"ltree\"",
+		"sql": "CREATE EXTENSION IF NOT EXISTS ltree"
+	}],
+	"postcheck": [{
+		"description": "confirm extension \"ltree\" is enabled",
+		"sql": "SELECT EXISTS (SELECT 1 AS \"one\" FROM \"pg_extension\" WHERE \"extname\" = $1) AS \"result\"",
+		"params": ["ltree"]
+	}]
+}];
+//#endregion
+//#region migrations/app/refs/head.json
+var head_default = {
+	hash: "sha256:81cc0a29674d926c9089886b1941ba66d6ce26ec5644fc8a0b7c92a5e9e9876e",
+	invariants: ["ltree:install-ltree-v1"]
+};
+//#endregion
+//#region src/contract.json
+var contract_default = {
+	schemaVersion: "1",
+	targetFamily: "sql",
+	target: "postgres",
+	profileHash: "sha256:9c8aa3114e84ed3b7ea2bd57526d9c2e1bf7c5292be694e9d3801f566fda7ccb",
+	roots: {},
+	domain: { "namespaces": { "public": { "models": {} } } },
+	storage: {
+		"namespaces": { "public": {
+			"entries": { "table": {} },
+			"id": "public",
+			"kind": "postgres-schema"
+		} },
+		"storageHash": "sha256:81cc0a29674d926c9089886b1941ba66d6ce26ec5644fc8a0b7c92a5e9e9876e",
+		"types": {
+			"ltree": {
+				"codecId": "pg/ltree@1",
+				"kind": "codec-instance",
+				"nativeType": "ltree"
+			},
+			"ltreeArray": {
+				"codecId": "pg/ltree-array@1",
+				"kind": "codec-instance",
+				"nativeType": "ltree[]"
+			}
+		}
+	},
+	capabilities: {
+		"postgres": {
+			"distinctOn": true,
+			"jsonAgg": true,
+			"lateral": true,
+			"limit": true,
+			"orderBy": true,
+			"returning": true
+		},
+		"sql": {
+			"defaultInInsert": true,
+			"enums": true,
+			"lateral": true,
+			"returning": true
+		}
+	},
+	extensionPacks: {},
+	meta: {},
+	_generated: {
+		"warning": "⚠️  GENERATED FILE - DO NOT EDIT",
+		"message": "This file is automatically generated by \"prisma-next contract emit\".",
+		"regenerate": "To regenerate, run: prisma-next contract emit"
+	}
+};
+//#endregion
+//#region src/exports/control.ts
+const ltreeControlPlaneHooks = {
+	expandNativeType: ({ nativeType }) => nativeType,
+	resolveIdentityValue: () => null
+};
+const ltreeContractSpace = contractSpaceFromJson({
+	contractJson: contract_default,
+	migrations: [{
+		dirName: LTREE_BASELINE_MIGRATION_NAME,
+		metadata: migration_default,
+		ops: ops_default
+	}],
+	headRef: head_default
+});
+const ltreeExtensionDescriptor = {
+	...ltreePackMeta,
+	id: LTREE_SPACE_ID,
+	contractSpace: ltreeContractSpace,
+	types: {
+		...ltreePackMeta.types,
+		codecTypes: {
+			...ltreePackMeta.types.codecTypes,
+			controlPlaneHooks: {
+				[LTREE_CODEC_ID]: ltreeControlPlaneHooks,
+				[LTREE_ARRAY_CODEC_ID]: ltreeControlPlaneHooks
+			}
+		}
+	},
+	queryOperations: () => ltreeQueryOperations(),
+	create: () => ({
+		familyId: "sql",
+		targetId: "postgres"
+	})
+};
+//#endregion
+export { ltreeExtensionDescriptor as default, ltreeExtensionDescriptor };
+
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":["baselineMetadata","baselineOps"],"sources":["../migrations/app/20260619T2142_install_ltree/migration.json","../migrations/app/20260619T2142_install_ltree/ops.json","../migrations/app/refs/head.json","../src/contract.json","../src/exports/control.ts"],"sourcesContent":["","","","","import type { Contract } from \"@prisma-next/contract/types\";\nimport type {\n  CodecControlHooks,\n  SqlControlExtensionDescriptor,\n} from \"@prisma-next/family-sql/control\";\nimport { contractSpaceFromJson } from \"@prisma-next/migration-tools/spaces\";\nimport type { SqlStorage } from \"@prisma-next/sql-contract/types\";\nimport baselineMetadata from \"../../migrations/app/20260619T2142_install_ltree/migration.json\" with { type: \"json\" };\nimport baselineOps from \"../../migrations/app/20260619T2142_install_ltree/ops.json\" with { type: \"json\" };\nimport headRef from \"../../migrations/app/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  expandNativeType: ({ nativeType }) => nativeType,\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AIeA,MAAM,yBAA4C;CAChD,mBAAmB,EAAE,iBAAiB;CACtC,4BAA4B;AAC9B;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"}