prisma-ltree 0.0.1 → 0.1.1

package/dist/pack.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"mappings":";;cAiSM,iBAAA;EAAA,SACJ,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,YAAA;IAAA,SACE,QAAA;MAAA,SACE,YAAA;IAAA;EAAA;EAAA,SAGJ,SAAA;IAAA,SACE,IAAA;MAAA;;;;;;;;;;;;;;;;;;WAEF,KAAA;IAAA,SACE,UAAA;MAAA,SACE,gBAAA,oDAAgB,eAAA;MAAA,SAChB,MAAA;QAAA,SACE,OAAA;QAAA,SACA,KAAA;QAAA,SACA,KAAA;MAAA;MAAA,SAEF,WAAA;QAAA,SAEI,OAAA;QAAA,SACA,KAAA;QAAA,SACA,KAAA;MAAA;IAAA;IAAA,SAIN,mBAAA;MAAA,SACE,MAAA;QAAA,SACE,OAAA;QAAA,SACA,KAAA;QAAA,SACA,KAAA;MAAA;IAAA;IAAA,SAGJ,OAAA;MAAA,SAEI,MAAA;MAAA,SACA,QAAA;MAAA,SACA,QAAA;MAAA,SACA,UAAA;IAAA;MAAA,SAGA,MAAA;MAAA,SACA,QAAA;MAAA,SACA,QAAA;MAAA,SACA,UAAA;IAAA;EAAA;AAAA;AAAA,cAMK,aAAA,SAAsB,iBAAA;EAAA,SACxB,YAAA,GAAe,UAAU;AAAA"}

package/dist/pack.mjs

@@ -0,0 +1,2 @@
+import { t as ltreePackMeta } from "./descriptor-meta-B84muAZG.mjs";
+export { ltreePackMeta as default };

package/dist/runtime.d.mts

@@ -0,0 +1,11 @@
+import { SqlRuntimeExtensionDescriptor } from "@prisma-next/sql-runtime";
+import { CodecDescriptorRegistry } from "@prisma-next/sql-relational-core/query-lane-context";
+
+//#region src/core/registry.d.ts
+declare const ltreeCodecRegistry: CodecDescriptorRegistry;
+//#endregion
+//#region src/exports/runtime.d.ts
+declare const ltreeRuntimeDescriptor: SqlRuntimeExtensionDescriptor<"postgres">;
+//#endregion
+export { ltreeRuntimeDescriptor as default, ltreeCodecRegistry };
+//# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/registry.ts","../src/exports/runtime.ts"],"mappings":";;;;cAIa,kBAAA,EAAoB,uBACe;;;cCD1C,sBAAA,EAAwB,6BAA6B"}

package/dist/runtime.mjs

@@ -0,0 +1,22 @@
+import { n as ltreeQueryOperations, r as ltreeCodecRegistry, t as ltreePackMeta } from "./descriptor-meta-B84muAZG.mjs";
+//#region src/exports/runtime.ts
+const ltreeRuntimeDescriptor = {
+	kind: "extension",
+	id: ltreePackMeta.id,
+	version: ltreePackMeta.version,
+	familyId: "sql",
+	targetId: "postgres",
+	types: { codecTypes: { codecDescriptors: Array.from(ltreeCodecRegistry.values()) } },
+	codecs: () => Array.from(ltreeCodecRegistry.values()),
+	queryOperations: () => ltreeQueryOperations(),
+	create() {
+		return {
+			familyId: "sql",
+			targetId: "postgres"
+		};
+	}
+};
+//#endregion
+export { ltreeRuntimeDescriptor as default, ltreeCodecRegistry };
+
+//# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../src/exports/runtime.ts"],"sourcesContent":["import type { SqlRuntimeExtensionDescriptor } from \"@prisma-next/sql-runtime\";\nimport { ltreePackMeta, ltreeQueryOperations } from \"../core/descriptor-meta\";\nimport { ltreeCodecRegistry } from \"../core/registry\";\n\nconst ltreeRuntimeDescriptor: SqlRuntimeExtensionDescriptor<\"postgres\"> = {\n  kind: \"extension\" as const,\n  id: ltreePackMeta.id,\n  version: ltreePackMeta.version,\n  familyId: \"sql\" as const,\n  targetId: \"postgres\" as const,\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(ltreeCodecRegistry.values()),\n    },\n  },\n  codecs: () => Array.from(ltreeCodecRegistry.values()),\n  queryOperations: () => ltreeQueryOperations(),\n  create() {\n    return {\n      familyId: \"sql\" as const,\n      targetId: \"postgres\" as const,\n    };\n  },\n};\n\nexport { ltreeCodecRegistry };\nexport default ltreeRuntimeDescriptor;\n"],"mappings":";;AAIA,MAAM,yBAAoE;CACxE,MAAM;CACN,IAAI,cAAc;CAClB,SAAS,cAAc;CACvB,UAAU;CACV,UAAU;CACV,OAAO,EACL,YAAY,EACV,kBAAkB,MAAM,KAAK,mBAAmB,OAAO,CAAC,EAC1D,EACF;CACA,cAAc,MAAM,KAAK,mBAAmB,OAAO,CAAC;CACpD,uBAAuB,qBAAqB;CAC5C,SAAS;EACP,OAAO;GACL,UAAU;GACV,UAAU;EACZ;CACF;AACF"}

package/package.json

@@ -1,19 +1,88 @@
 {
   "name": "prisma-ltree",
-  "version": "0.0.1",
-  "description": "Prisma extension for PostgreSQL ltree — placeholder package, full release coming soon.",
-  "license": "MIT",
+  "version": "0.1.1",
+  "description": "Prisma Next extension pack for PostgreSQL's ltree hierarchical tree data type.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/slovakian/prisma-ltree.git",
+    "directory": "packages/extension-ltree"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
   "type": "module",
-  "main": "./index.js",
+  "sideEffects": false,
   "exports": {
-    ".": "./index.js",
+    "./codec-types": "./dist/codec-types.mjs",
+    "./column-types": "./dist/column-types.mjs",
+    "./control": "./dist/control.mjs",
+    "./operation-types": "./dist/operation-types.mjs",
+    "./pack": "./dist/pack.mjs",
+    "./runtime": "./dist/runtime.mjs",
     "./package.json": "./package.json"
   },
-  "keywords": ["prisma", "ltree", "postgres", "postgresql", "hierarchy", "tree", "extension"],
-  "author": "alaskan",
-  "homepage": "https://github.com/alaskan/prisma-ltree-extension",
-  "files": ["index.js", "README.md"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@prisma-next/contract": "0.14.0",
+    "@prisma-next/contract-authoring": "0.14.0",
+    "@prisma-next/family-sql": "0.14.0",
+    "@prisma-next/framework-components": "0.14.0",
+    "@prisma-next/migration-tools": "0.14.0",
+    "@prisma-next/sql-contract": "0.14.0",
+    "@prisma-next/sql-operations": "0.14.0",
+    "@prisma-next/sql-relational-core": "0.14.0",
+    "@prisma-next/sql-runtime": "0.14.0",
+    "@prisma-next/sql-schema-ir": "0.14.0",
+    "@standard-schema/spec": "^1.1.0",
+    "arktype": "^2.2.0"
+  },
+  "devDependencies": {
+    "@electric-sql/pglite": "^0.5.3",
+    "@prisma-next/adapter-postgres": "0.14.0",
+    "@prisma-next/cli": "0.14.0",
+    "@prisma-next/extension-author-tools": "0.14.0",
+    "@prisma-next/operations": "0.14.0",
+    "@prisma-next/postgres": "0.14.0",
+    "@prisma-next/sql-contract-ts": "0.14.0",
+    "@prisma-next/target-postgres": "0.14.0",
+    "@types/node": "^24",
+    "@typescript/native-preview": "7.0.0-dev.20260509.2",
+    "@vitest/coverage-v8": "4.1.8",
+    "typescript": "^5",
+    "vite-plus": "0.1.24"
+  },
+  "peerDependencies": {
+    "@prisma-next/adapter-postgres": "0.14.0",
+    "typescript": ">=5.9"
+  },
+  "peerDependenciesMeta": {
+    "@prisma-next/adapter-postgres": {
+      "optional": true
+    },
+    "typescript": {
+      "optional": true
+    }
+  },
   "engines": {
-    "node": ">=18"
+    "node": ">=24"
+  },
+  "prismaNext": {
+    "family": "sql",
+    "dialects": [
+      "postgres"
+    ],
+    "type": "extension-pack"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check",
+    "build:contract-space": "prisma-next contract emit",
+    "check-pins": "prisma-next-check-pins"
   }
-}
+}

package/src/contract.d.ts

@@ -0,0 +1,115 @@
+// ⚠️  GENERATED FILE - DO NOT EDIT
+// This file is automatically generated by 'prisma-next contract emit'.
+// To regenerate, run: prisma-next contract emit
+import type { QueryOperationTypes as PgAdapterQueryOps } from '@prisma-next/adapter-postgres/operation-types';
+import type {
+  Bit,
+  Char,
+  CodecTypes as PgTypes,
+  Interval,
+  JsonValue,
+  Numeric,
+  Time,
+  Timestamp,
+  Timestamptz,
+  Timetz,
+  VarBit,
+  Varchar,
+} from '@prisma-next/target-postgres/codec-types';
+
+import type {
+  ContractWithTypeMaps,
+  TypeMaps as TypeMapsType,
+} from '@prisma-next/sql-contract/types';
+import type {
+  Contract as ContractType,
+  ExecutionHashBase,
+  NamespaceId,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+
+export type StorageHash =
+  StorageHashBase<'sha256:81cc0a29674d926c9089886b1941ba66d6ce26ec5644fc8a0b7c92a5e9e9876e'>;
+export type ExecutionHash = ExecutionHashBase<string>;
+export type ProfileHash =
+  ProfileHashBase<'sha256:9c8aa3114e84ed3b7ea2bd57526d9c2e1bf7c5292be694e9d3801f566fda7ccb'>;
+
+export type CodecTypes = PgTypes;
+export type LaneCodecTypes = CodecTypes;
+export type QueryOperationTypes = PgAdapterQueryOps<CodecTypes>;
+type DefaultLiteralValue<CodecId extends string, _Encoded> = CodecId extends keyof CodecTypes
+  ? CodecTypes[CodecId]['output']
+  : _Encoded;
+
+export type FieldOutputTypes = { readonly public: Record<string, never> };
+export type FieldInputTypes = { readonly public: Record<string, never> };
+export type TypeMaps = TypeMapsType<
+  CodecTypes,
+  QueryOperationTypes,
+  FieldOutputTypes,
+  FieldInputTypes
+>;
+
+type ContractBase = Omit<
+  ContractType<{
+    readonly namespaces: {
+      readonly public: {
+        readonly id: 'public';
+        readonly kind: 'postgres-schema';
+        readonly entries: { readonly table: {} };
+      };
+    };
+    readonly types: {
+      readonly ltree: {
+        readonly kind: 'codec-instance';
+        readonly codecId: 'pg/ltree@1';
+        readonly nativeType: 'ltree';
+        readonly typeParams: Record<string, never>;
+      };
+      readonly ltreeArray: {
+        readonly kind: 'codec-instance';
+        readonly codecId: 'pg/ltree-array@1';
+        readonly nativeType: 'ltree[]';
+        readonly typeParams: Record<string, never>;
+      };
+    };
+    readonly storageHash: StorageHash;
+  }>,
+  'roots' | 'domain'
+> & {
+  readonly target: 'postgres';
+  readonly targetFamily: 'sql';
+  readonly roots: Record<string, never>;
+  readonly domain: {
+    readonly namespaces: {
+      readonly public: {
+        readonly models: Record<string, never>;
+      };
+    };
+  };
+  readonly capabilities: {
+    readonly postgres: {
+      readonly distinctOn: true;
+      readonly jsonAgg: true;
+      readonly lateral: true;
+      readonly limit: true;
+      readonly orderBy: true;
+      readonly returning: true;
+    };
+    readonly sql: {
+      readonly defaultInInsert: true;
+      readonly enums: true;
+      readonly lateral: true;
+      readonly returning: true;
+    };
+  };
+  readonly extensionPacks: {};
+  readonly meta: {};
+
+  readonly profileHash: ProfileHash;
+};
+
+export type Contract = ContractWithTypeMaps<ContractBase, TypeMaps>;
+
+export type Namespaces = Contract['storage']['namespaces'];

package/src/contract.json

@@ -0,0 +1,61 @@
+{
+  "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"
+  }
+}

package/src/contract.ts

@@ -0,0 +1,27 @@
+import { defineContract } from "@prisma-next/postgres/contract-builder";
+import { LTREE_ARRAY_CODEC_ID, LTREE_CODEC_ID } from "./core/constants";
+import {
+  LTREE_ARRAY_STORAGE_TYPE,
+  LTREE_ARRAY_NATIVE_TYPE,
+  LTREE_NATIVE_TYPE,
+} from "./core/contract-space-constants";
+
+export const contract = defineContract({}, () => ({
+  types: {
+    [LTREE_NATIVE_TYPE]: {
+      kind: "codec-instance",
+      codecId: LTREE_CODEC_ID,
+      nativeType: LTREE_NATIVE_TYPE,
+      typeParams: {},
+    },
+    [LTREE_ARRAY_STORAGE_TYPE]: {
+      kind: "codec-instance",
+      codecId: LTREE_ARRAY_CODEC_ID,
+      nativeType: LTREE_ARRAY_NATIVE_TYPE,
+      typeParams: {},
+    },
+  },
+  models: {},
+}));
+
+export default contract;

package/src/core/authoring.ts

@@ -0,0 +1,22 @@
+import type { AuthoringTypeNamespace } from "@prisma-next/framework-components/authoring";
+import { LTREE_ARRAY_CODEC_ID, LTREE_CODEC_ID } from "./constants";
+import { LTREE_ARRAY_NATIVE_TYPE, LTREE_NATIVE_TYPE } from "./contract-space-constants";
+
+export 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,
+      },
+    },
+  },
+} as const satisfies AuthoringTypeNamespace;

package/src/core/codecs.ts

@@ -0,0 +1,178 @@
+import type { JsonValue } from "@prisma-next/contract/types";
+import {
+  type AnyCodecDescriptor,
+  type CodecCallContext,
+  CodecDescriptorImpl,
+  CodecImpl,
+  type CodecInstanceContext,
+  type ColumnHelperFor,
+  type ColumnHelperForStrict,
+  column,
+  voidParamsSchema,
+} from "@prisma-next/framework-components/codec";
+import type { ExtractCodecTypes } from "@prisma-next/sql-relational-core/ast";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import {
+  LTREE_ARRAY_CODEC_ID,
+  LTREE_CODEC_ID,
+  LTREE_MAX_LABEL_LENGTH,
+  LTREE_MAX_LABELS,
+} from "./constants";
+import { LTREE_ARRAY_NATIVE_TYPE, LTREE_NATIVE_TYPE } from "./contract-space-constants";
+
+const LABEL_PATTERN = /^[A-Za-z0-9_-]+$/;
+
+export function assertValidLtree(value: unknown): asserts value is string {
+  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 > LTREE_MAX_LABELS) {
+    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 > LTREE_MAX_LABEL_LENGTH) {
+      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`,
+      );
+    }
+  }
+}
+
+export class LtreeCodec extends CodecImpl<
+  typeof LTREE_CODEC_ID,
+  readonly ["equality", "order"],
+  string,
+  string
+> {
+  async encode(value: string, _ctx: CodecCallContext): Promise<string> {
+    assertValidLtree(value);
+    return value;
+  }
+
+  async decode(wire: string, _ctx: CodecCallContext): Promise<string> {
+    return wire;
+  }
+
+  encodeJson(value: string): JsonValue {
+    assertValidLtree(value);
+    return value;
+  }
+
+  decodeJson(json: JsonValue): string {
+    assertValidLtree(json);
+    return json;
+  }
+}
+
+const LTREE_META = { db: { sql: { postgres: { nativeType: LTREE_NATIVE_TYPE } } } } as const;
+
+export class LtreeDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = LTREE_CODEC_ID;
+  override readonly traits = ["equality", "order"] as const;
+  override readonly targetTypes = [LTREE_NATIVE_TYPE] as const;
+  override readonly meta = LTREE_META;
+  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;
+  override renderOutputType(): string {
+    return "string";
+  }
+  override factory(): (ctx: CodecInstanceContext) => LtreeCodec {
+    const shared = new LtreeCodec(this);
+    return () => shared;
+  }
+}
+
+export const ltreeDescriptor = new LtreeDescriptor();
+
+export const ltree = () =>
+  column(ltreeDescriptor.factory(), ltreeDescriptor.codecId, undefined, LTREE_NATIVE_TYPE);
+
+ltree satisfies ColumnHelperFor<LtreeDescriptor>;
+ltree satisfies ColumnHelperForStrict<LtreeDescriptor>;
+
+const LTREE_ARRAY_META = {
+  db: { sql: { postgres: { nativeType: LTREE_ARRAY_NATIVE_TYPE } } },
+} as const;
+
+export class LtreeArrayCodec extends CodecImpl<
+  typeof LTREE_ARRAY_CODEC_ID,
+  readonly ["equality"],
+  readonly string[],
+  readonly string[]
+> {
+  async encode(value: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]> {
+    for (const entry of value) {
+      assertValidLtree(entry);
+    }
+    return value;
+  }
+
+  async decode(wire: readonly string[], _ctx: CodecCallContext): Promise<readonly string[]> {
+    return wire;
+  }
+
+  encodeJson(value: readonly string[]): JsonValue {
+    for (const entry of value) {
+      assertValidLtree(entry);
+    }
+    return [...value];
+  }
+
+  decodeJson(json: JsonValue): readonly string[] {
+    if (!Array.isArray(json)) {
+      return [];
+    }
+    return json.map((entry) => {
+      assertValidLtree(entry);
+      return String(entry);
+    });
+  }
+}
+
+export class LtreeArrayDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = LTREE_ARRAY_CODEC_ID;
+  override readonly traits = ["equality"] as const;
+  override readonly targetTypes = [LTREE_ARRAY_NATIVE_TYPE] as const;
+  override readonly meta = LTREE_ARRAY_META;
+  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;
+  override renderOutputType(): string {
+    return "readonly string[]";
+  }
+  override factory(): (ctx: CodecInstanceContext) => LtreeArrayCodec {
+    const shared = new LtreeArrayCodec(this);
+    return () => shared;
+  }
+}
+
+export const ltreeArrayDescriptor = new LtreeArrayDescriptor();
+
+export const ltreeArray = () =>
+  column(
+    ltreeArrayDescriptor.factory(),
+    ltreeArrayDescriptor.codecId,
+    undefined,
+    LTREE_ARRAY_NATIVE_TYPE,
+  );
+
+ltreeArray satisfies ColumnHelperFor<LtreeArrayDescriptor>;
+ltreeArray satisfies ColumnHelperForStrict<LtreeArrayDescriptor>;
+
+const codecDescriptorMap = {
+  ltree: ltreeDescriptor,
+  ltreeArray: ltreeArrayDescriptor,
+} as const;
+
+export type CodecTypes = ExtractCodecTypes<typeof codecDescriptorMap>;
+
+export const codecDescriptors: readonly AnyCodecDescriptor[] = Object.values(codecDescriptorMap);

package/src/core/constants.ts

@@ -0,0 +1,7 @@
+export const LTREE_CODEC_ID = "pg/ltree@1" as const;
+
+export const LTREE_ARRAY_CODEC_ID = "pg/ltree-array@1" as const;
+
+export const LTREE_MAX_LABEL_LENGTH = 1000;
+
+export const LTREE_MAX_LABELS = 65535;

package/src/core/contract-space-constants.ts

@@ -0,0 +1,14 @@
+export const LTREE_SPACE_ID = "ltree" as const;
+
+export const LTREE_NATIVE_TYPE = "ltree" as const;
+
+export const LTREE_ARRAY_NATIVE_TYPE = "ltree[]" as const;
+
+/** Contract storage.types key — must be a valid identifier for contract emit. */
+export const LTREE_ARRAY_STORAGE_TYPE = "ltreeArray" as const;
+
+export const LTREE_BASELINE_MIGRATION_NAME = "20260619T2142_install_ltree" as const;
+
+export const LTREE_INVARIANTS = {
+  installLtree: "ltree:install-ltree-v1",
+} as const;