@prisma-next/extension-postgis 0.0.1

package/dist/geojson.mjs

@@ -0,0 +1,60 @@
+//#region src/core/geojson.ts
+/**
+* Construct a Point. Convenience for the common "lng/lat" case.
+*
+* @example
+*   point(-122.4194, 37.7749, 4326)
+*/
+function point(longitude, latitude, srid) {
+	if (!Number.isFinite(longitude) || !Number.isFinite(latitude)) throw new RangeError("point: coordinates must be finite numbers");
+	return srid !== void 0 ? {
+		type: "Point",
+		coordinates: [longitude, latitude],
+		srid
+	} : {
+		type: "Point",
+		coordinates: [longitude, latitude]
+	};
+}
+/**
+* Construct a Polygon from a single outer ring of `[lng, lat]` pairs.
+* If the first and last positions differ, the ring is closed automatically.
+*/
+function polygon(ring, srid) {
+	if (ring.length < 3) throw new Error("polygon: ring must contain at least 3 positions");
+	const first = ring[0];
+	const last = ring[ring.length - 1];
+	if (!first || !last) throw new Error("polygon: ring positions cannot be undefined");
+	for (const position of ring) if (!Number.isFinite(position[0]) || !Number.isFinite(position[1])) throw new RangeError("polygon: coordinates must be finite numbers");
+	const closed = first[0] === last[0] && first[1] === last[1] ? ring : [...ring, first];
+	if (new Set(closed.slice(0, -1).map(([x, y]) => `${x},${y}`)).size < 3) throw new Error("polygon: ring must contain at least 3 distinct positions");
+	return srid !== void 0 ? {
+		type: "Polygon",
+		coordinates: [closed],
+		srid
+	} : {
+		type: "Polygon",
+		coordinates: [closed]
+	};
+}
+/**
+* Construct a rectangular Polygon from a bounding box.
+*
+* @param bbox - `[minLng, minLat, maxLng, maxLat]`
+*/
+function bboxPolygon(bbox, srid) {
+	const [minX, minY, maxX, maxY] = bbox;
+	if (!Number.isFinite(minX) || !Number.isFinite(minY) || !Number.isFinite(maxX) || !Number.isFinite(maxY)) throw new RangeError("bboxPolygon: coordinates must be finite numbers");
+	if (minX > maxX || minY > maxY) throw new Error(`bboxPolygon: inverted bbox [${minX}, ${minY}, ${maxX}, ${maxY}] (expected minX <= maxX and minY <= maxY)`);
+	return polygon([
+		[minX, minY],
+		[maxX, minY],
+		[maxX, maxY],
+		[minX, maxY],
+		[minX, minY]
+	], srid);
+}
+//#endregion
+export { bboxPolygon, point, polygon };
+
+//# sourceMappingURL=geojson.mjs.map

package/dist/geojson.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"geojson.mjs","names":[],"sources":["../src/core/geojson.ts"],"sourcesContent":["/**\n * GeoJSON-shaped value types used by the PostGIS codec.\n *\n * The codec speaks GeoJSON-style objects to JavaScript callers and\n * EWKT/EWKB on the wire. This file is the single source of truth for the\n * value shapes; the public type re-export lives in `exports/geojson.ts`.\n */\n\nexport type Position = readonly [number, number];\n\nexport type GeometryPoint = {\n  readonly type: 'Point';\n  readonly coordinates: Position;\n  readonly srid?: number;\n};\n\nexport type GeometryLineString = {\n  readonly type: 'LineString';\n  readonly coordinates: ReadonlyArray<Position>;\n  readonly srid?: number;\n};\n\nexport type GeometryPolygon = {\n  readonly type: 'Polygon';\n  readonly coordinates: ReadonlyArray<ReadonlyArray<Position>>;\n  readonly srid?: number;\n};\n\nexport type GeometryMultiPoint = {\n  readonly type: 'MultiPoint';\n  readonly coordinates: ReadonlyArray<Position>;\n  readonly srid?: number;\n};\n\nexport type GeometryMultiLineString = {\n  readonly type: 'MultiLineString';\n  readonly coordinates: ReadonlyArray<ReadonlyArray<Position>>;\n  readonly srid?: number;\n};\n\nexport type GeometryMultiPolygon = {\n  readonly type: 'MultiPolygon';\n  readonly coordinates: ReadonlyArray<ReadonlyArray<ReadonlyArray<Position>>>;\n  readonly srid?: number;\n};\n\nexport type Geometry =\n  | GeometryPoint\n  | GeometryLineString\n  | GeometryPolygon\n  | GeometryMultiPoint\n  | GeometryMultiLineString\n  | GeometryMultiPolygon;\n\n/**\n * Construct a Point. Convenience for the common \"lng/lat\" case.\n *\n * @example\n *   point(-122.4194, 37.7749, 4326)\n */\nexport function point(longitude: number, latitude: number, srid?: number): GeometryPoint {\n  if (!Number.isFinite(longitude) || !Number.isFinite(latitude)) {\n    throw new RangeError('point: coordinates must be finite numbers');\n  }\n  return srid !== undefined\n    ? { type: 'Point', coordinates: [longitude, latitude], srid }\n    : { type: 'Point', coordinates: [longitude, latitude] };\n}\n\n/**\n * Construct a Polygon from a single outer ring of `[lng, lat]` pairs.\n * If the first and last positions differ, the ring is closed automatically.\n */\nexport function polygon(ring: ReadonlyArray<Position>, srid?: number): GeometryPolygon {\n  if (ring.length < 3) {\n    throw new Error('polygon: ring must contain at least 3 positions');\n  }\n  const first = ring[0];\n  const last = ring[ring.length - 1];\n  if (!first || !last) {\n    throw new Error('polygon: ring positions cannot be undefined');\n  }\n  for (const position of ring) {\n    if (!Number.isFinite(position[0]) || !Number.isFinite(position[1])) {\n      throw new RangeError('polygon: coordinates must be finite numbers');\n    }\n  }\n  const closed = first[0] === last[0] && first[1] === last[1] ? ring : [...ring, first];\n  const distinct = new Set(closed.slice(0, -1).map(([x, y]) => `${x},${y}`));\n  if (distinct.size < 3) {\n    throw new Error('polygon: ring must contain at least 3 distinct positions');\n  }\n  return srid !== undefined\n    ? { type: 'Polygon', coordinates: [closed], srid }\n    : { type: 'Polygon', coordinates: [closed] };\n}\n\n/**\n * Construct a rectangular Polygon from a bounding box.\n *\n * @param bbox - `[minLng, minLat, maxLng, maxLat]`\n */\nexport function bboxPolygon(\n  bbox: readonly [number, number, number, number],\n  srid?: number,\n): GeometryPolygon {\n  const [minX, minY, maxX, maxY] = bbox;\n  if (\n    !Number.isFinite(minX) ||\n    !Number.isFinite(minY) ||\n    !Number.isFinite(maxX) ||\n    !Number.isFinite(maxY)\n  ) {\n    throw new RangeError('bboxPolygon: coordinates must be finite numbers');\n  }\n  if (minX > maxX || minY > maxY) {\n    throw new Error(\n      `bboxPolygon: inverted bbox [${minX}, ${minY}, ${maxX}, ${maxY}] (expected minX <= maxX and minY <= maxY)`,\n    );\n  }\n  return polygon(\n    [\n      [minX, minY],\n      [maxX, minY],\n      [maxX, maxY],\n      [minX, maxY],\n      [minX, minY],\n    ],\n    srid,\n  );\n}\n"],"mappings":";;;;;;;AA4DA,SAAgB,MAAM,WAAmB,UAAkB,MAA8B;CACvF,IAAI,CAAC,OAAO,SAAS,UAAU,IAAI,CAAC,OAAO,SAAS,SAAS,EAC3D,MAAM,IAAI,WAAW,4CAA4C;CAEnE,OAAO,SAAS,KAAA,IACZ;EAAE,MAAM;EAAS,aAAa,CAAC,WAAW,SAAS;EAAE;EAAM,GAC3D;EAAE,MAAM;EAAS,aAAa,CAAC,WAAW,SAAS;EAAE;;;;;;AAO3D,SAAgB,QAAQ,MAA+B,MAAgC;CACrF,IAAI,KAAK,SAAS,GAChB,MAAM,IAAI,MAAM,kDAAkD;CAEpE,MAAM,QAAQ,KAAK;CACnB,MAAM,OAAO,KAAK,KAAK,SAAS;CAChC,IAAI,CAAC,SAAS,CAAC,MACb,MAAM,IAAI,MAAM,8CAA8C;CAEhE,KAAK,MAAM,YAAY,MACrB,IAAI,CAAC,OAAO,SAAS,SAAS,GAAG,IAAI,CAAC,OAAO,SAAS,SAAS,GAAG,EAChE,MAAM,IAAI,WAAW,8CAA8C;CAGvE,MAAM,SAAS,MAAM,OAAO,KAAK,MAAM,MAAM,OAAO,KAAK,KAAK,OAAO,CAAC,GAAG,MAAM,MAAM;CAErF,IAAI,IADiB,IAAI,OAAO,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,OAAO,GAAG,EAAE,GAAG,IAAI,CAC7D,CAAC,OAAO,GAClB,MAAM,IAAI,MAAM,2DAA2D;CAE7E,OAAO,SAAS,KAAA,IACZ;EAAE,MAAM;EAAW,aAAa,CAAC,OAAO;EAAE;EAAM,GAChD;EAAE,MAAM;EAAW,aAAa,CAAC,OAAO;EAAE;;;;;;;AAQhD,SAAgB,YACd,MACA,MACiB;CACjB,MAAM,CAAC,MAAM,MAAM,MAAM,QAAQ;CACjC,IACE,CAAC,OAAO,SAAS,KAAK,IACtB,CAAC,OAAO,SAAS,KAAK,IACtB,CAAC,OAAO,SAAS,KAAK,IACtB,CAAC,OAAO,SAAS,KAAK,EAEtB,MAAM,IAAI,WAAW,kDAAkD;CAEzE,IAAI,OAAO,QAAQ,OAAO,MACxB,MAAM,IAAI,MACR,+BAA+B,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,4CAChE;CAEH,OAAO,QACL;EACE,CAAC,MAAM,KAAK;EACZ,CAAC,MAAM,KAAK;EACZ,CAAC,MAAM,KAAK;EACZ,CAAC,MAAM,KAAK;EACZ,CAAC,MAAM,KAAK;EACb,EACD,KACD"}

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

@@ -0,0 +1,123 @@
+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;
+}>;
+/**
+ * Operation type definitions for the PostGIS extension.
+ *
+ * These are type-only signatures consumed by emitted `contract.d.ts`
+ * files so the query builder surfaces `.distance()`, `.dwithin()`,
+ * `.contains()`, `.within()`, `.intersects()`, and `.intersectsBbox()`
+ * on `geometry` columns.
+ */
+type OperationTypes = {
+  readonly 'pg/geometry@1': {
+    readonly distance: {
+      readonly self: {
+        readonly codecId: 'pg/geometry@1';
+      };
+    };
+    readonly distanceSphere: {
+      readonly self: {
+        readonly codecId: 'pg/geometry@1';
+      };
+    };
+    readonly dwithin: {
+      readonly self: {
+        readonly codecId: 'pg/geometry@1';
+      };
+    };
+    readonly contains: {
+      readonly self: {
+        readonly codecId: 'pg/geometry@1';
+      };
+    };
+    readonly within: {
+      readonly self: {
+        readonly codecId: 'pg/geometry@1';
+      };
+    };
+    readonly intersects: {
+      readonly self: {
+        readonly codecId: 'pg/geometry@1';
+      };
+    };
+    readonly intersectsBbox: {
+      readonly self: {
+        readonly codecId: 'pg/geometry@1';
+      };
+    };
+  };
+};
+type QueryOperationTypes<CT extends CodecTypesBase> = SqlQueryOperationTypes<CT, {
+  readonly distance: {
+    readonly self: {
+      readonly codecId: 'pg/geometry@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/geometry@1', boolean, CT>, other: CodecExpression<'pg/geometry@1', boolean, CT>) => Expression<{
+      codecId: 'pg/float8@1';
+      nullable: false;
+    }>;
+  };
+  readonly distanceSphere: {
+    readonly self: {
+      readonly codecId: 'pg/geometry@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/geometry@1', boolean, CT>, other: CodecExpression<'pg/geometry@1', boolean, CT>) => Expression<{
+      codecId: 'pg/float8@1';
+      nullable: false;
+    }>;
+  };
+  readonly dwithin: {
+    readonly self: {
+      readonly codecId: 'pg/geometry@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/geometry@1', boolean, CT>, other: CodecExpression<'pg/geometry@1', boolean, CT>, distance: CodecExpression<'pg/float8@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly contains: {
+    readonly self: {
+      readonly codecId: 'pg/geometry@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/geometry@1', boolean, CT>, other: CodecExpression<'pg/geometry@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly within: {
+    readonly self: {
+      readonly codecId: 'pg/geometry@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/geometry@1', boolean, CT>, other: CodecExpression<'pg/geometry@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly intersects: {
+    readonly self: {
+      readonly codecId: 'pg/geometry@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/geometry@1', boolean, CT>, other: CodecExpression<'pg/geometry@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+  readonly intersectsBbox: {
+    readonly self: {
+      readonly codecId: 'pg/geometry@1';
+    };
+    readonly impl: (self: CodecExpression<'pg/geometry@1', boolean, CT>, other: CodecExpression<'pg/geometry@1', boolean, CT>) => Expression<{
+      codecId: 'pg/bool@1';
+      nullable: false;
+    }>;
+  };
+}>;
+//#endregion
+export { QueryOperationTypes as n, OperationTypes as t };
+//# sourceMappingURL=operation-types-C2s9tY0P.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operation-types-C2s9tY0P.d.mts","names":[],"sources":["../src/types/operation-types.ts"],"mappings":";;;;KAGK,cAAA,GAAiB,MAAA;EAAA,SAA0B,KAAA;EAAA,SAAyB,MAAA;AAAA;;;;;;;;AAWzE;KAAY,cAAA;EAAA,SACD,eAAA;IAAA,SACE,QAAA;MAAA,SAAqB,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SACtC,cAAA;MAAA,SAA2B,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SAC5C,OAAA;MAAA,SAAoB,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SACrC,QAAA;MAAA,SAAqB,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SACtC,MAAA;MAAA,SAAmB,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SACpC,UAAA;MAAA,SAAuB,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;IAAA,SACxC,cAAA;MAAA,SAA2B,IAAA;QAAA,SAAiB,OAAA;MAAA;IAAA;EAAA;AAAA;AAAA,KAI7C,mBAAA,YAA+B,cAAA,IAAkB,sBAAA,CAC3D,EAAA;EAAA,SAEW,QAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,2BAA0C,EAAA,GAChD,KAAA,EAAO,eAAA,2BAA0C,EAAA,MAC9C,UAAA;MAAa,OAAA;MAAwB,QAAA;IAAA;EAAA;EAAA,SAEnC,cAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,2BAA0C,EAAA,GAChD,KAAA,EAAO,eAAA,2BAA0C,EAAA,MAC9C,UAAA;MAAa,OAAA;MAAwB,QAAA;IAAA;EAAA;EAAA,SAEnC,OAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,2BAA0C,EAAA,GAChD,KAAA,EAAO,eAAA,2BAA0C,EAAA,GACjD,QAAA,EAAU,eAAA,yBAAwC,EAAA,MAC/C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,QAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,2BAA0C,EAAA,GAChD,KAAA,EAAO,eAAA,2BAA0C,EAAA,MAC9C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,MAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,2BAA0C,EAAA,GAChD,KAAA,EAAO,eAAA,2BAA0C,EAAA,MAC9C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,UAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,2BAA0C,EAAA,GAChD,KAAA,EAAO,eAAA,2BAA0C,EAAA,MAC9C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;EAAA,SAEjC,cAAA;IAAA,SACE,IAAA;MAAA,SAAiB,OAAA;IAAA;IAAA,SACjB,IAAA,GACP,IAAA,EAAM,eAAA,2BAA0C,EAAA,GAChD,KAAA,EAAO,eAAA,2BAA0C,EAAA,MAC9C,UAAA;MAAa,OAAA;MAAsB,QAAA;IAAA;EAAA;AAAA"}

package/dist/operation-types.d.mts

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

package/dist/operation-types.mjs

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

package/dist/pack.d.mts

@@ -0,0 +1,75 @@
+import { t as CodecTypes } from "./codec-types-DODPC0GY.mjs";
+import * as _$_prisma_next_framework_components_codec0 from "@prisma-next/framework-components/codec";
+
+//#region src/core/descriptor-meta.d.ts
+declare const postgisPackMetaBase: {
+  readonly kind: "extension";
+  readonly id: "postgis";
+  readonly familyId: "sql";
+  readonly targetId: "postgres";
+  readonly version: "0.0.1";
+  readonly capabilities: {
+    readonly postgres: {
+      readonly 'postgis.geometry': true;
+    };
+  };
+  readonly authoring: {
+    readonly type: {
+      readonly postgis: {
+        readonly Geometry: {
+          readonly kind: "typeConstructor";
+          readonly args: readonly [{
+            readonly kind: "number";
+            readonly name: "srid";
+            readonly integer: true;
+            readonly minimum: 0;
+          }];
+          readonly output: {
+            readonly codecId: "pg/geometry@1";
+            readonly nativeType: "geometry";
+            readonly typeParams: {
+              readonly srid: {
+                readonly kind: "arg";
+                readonly index: 0;
+              };
+            };
+          };
+        };
+      };
+    };
+  };
+  readonly types: {
+    readonly codecTypes: {
+      readonly codecDescriptors: _$_prisma_next_framework_components_codec0.CodecDescriptor<unknown>[];
+      readonly import: {
+        readonly package: "@prisma-next/extension-postgis/codec-types";
+        readonly named: "CodecTypes";
+        readonly alias: "PostgisTypes";
+      };
+      readonly typeImports: readonly [{
+        readonly package: "@prisma-next/extension-postgis/codec-types";
+        readonly named: "Geometry";
+        readonly alias: "Geometry";
+      }];
+    };
+    readonly queryOperationTypes: {
+      readonly import: {
+        readonly package: "@prisma-next/extension-postgis/operation-types";
+        readonly named: "QueryOperationTypes";
+        readonly alias: "PostgisQueryOperationTypes";
+      };
+    };
+    readonly storage: readonly [{
+      readonly typeId: "pg/geometry@1";
+      readonly familyId: "sql";
+      readonly targetId: "postgres";
+      readonly nativeType: "geometry";
+    }];
+  };
+};
+declare const postgisPackMeta: typeof postgisPackMetaBase & {
+  readonly __codecTypes?: CodecTypes;
+};
+//#endregion
+export { postgisPackMeta as default };
+//# sourceMappingURL=pack.d.mts.map

package/dist/pack.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"mappings":";;;;cA4IM,mBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAyCI,0CAAA,CAAA,eAAA;MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;cAEG,eAAA,SAAwB,mBAAA;EAAA,SAC1B,YAAA,GAAe,UAAA;AAAA"}

package/dist/pack.mjs

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

package/dist/runtime.d.mts

@@ -0,0 +1,19 @@
+import { SqlRuntimeExtensionDescriptor } from "@prisma-next/sql-runtime";
+import { CodecDescriptorRegistry } from "@prisma-next/sql-relational-core/query-lane-context";
+
+//#region src/core/registry.d.ts
+/**
+ * Registry of every codec descriptor shipped by `@prisma-next/extension-postgis`.
+ *
+ * Public consumer surface for the postgis codec set. Currently a single
+ * entry (`pg/geometry@1`); the registry shape stays consistent with
+ * the other codec-shipping packages so consumers don't need to
+ * special-case extensions.
+ */
+declare const postgisCodecRegistry: CodecDescriptorRegistry;
+//#endregion
+//#region src/exports/runtime.d.ts
+declare const postgisRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'>;
+//#endregion
+export { postgisRuntimeDescriptor as default, postgisCodecRegistry };
+//# 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":";;;;;;;AAYA;;;;;cAAa,oBAAA,EAAsB,uBAAA;;;cCR7B,wBAAA,EAA0B,6BAAA"}

package/dist/runtime.mjs

@@ -0,0 +1,22 @@
+import { n as postgisQueryOperations, r as postgisCodecRegistry, t as postgisPackMeta } from "./descriptor-meta-DUKzIH9c.mjs";
+//#region src/exports/runtime.ts
+const postgisRuntimeDescriptor = {
+	kind: "extension",
+	id: postgisPackMeta.id,
+	version: postgisPackMeta.version,
+	familyId: "sql",
+	targetId: "postgres",
+	types: { codecTypes: { codecDescriptors: Array.from(postgisCodecRegistry.values()) } },
+	codecs: () => Array.from(postgisCodecRegistry.values()),
+	queryOperations: () => postgisQueryOperations(),
+	create() {
+		return {
+			familyId: "sql",
+			targetId: "postgres"
+		};
+	}
+};
+//#endregion
+export { postgisRuntimeDescriptor as default, postgisCodecRegistry };
+
+//# 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 { postgisPackMeta, postgisQueryOperations } from '../core/descriptor-meta';\nimport { postgisCodecRegistry } from '../core/registry';\n\nconst postgisRuntimeDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {\n  kind: 'extension' as const,\n  id: postgisPackMeta.id,\n  version: postgisPackMeta.version,\n  familyId: 'sql' as const,\n  targetId: 'postgres' as const,\n  // Expose the unified descriptor list so `extractCodecLookup` reads\n  // `targetTypes` / `meta` / `renderOutputType` directly off the\n  // descriptors and materialises the representative `Codec` for the\n  // SQL renderer's cast-policy lookup. Without it, the Postgres\n  // adapter's runtime codec lookup would miss `pg/geometry@1` and\n  // `$N::geometry` casts would disappear once the renderer switches\n  // to lookup-driven cast policy.\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(postgisCodecRegistry.values()),\n    },\n  },\n  codecs: () => Array.from(postgisCodecRegistry.values()),\n  queryOperations: () => postgisQueryOperations(),\n  create() {\n    return {\n      familyId: 'sql' as const,\n      targetId: 'postgres' as const,\n    };\n  },\n};\n\nexport { postgisCodecRegistry };\nexport default postgisRuntimeDescriptor;\n"],"mappings":";;AAIA,MAAM,2BAAsE;CAC1E,MAAM;CACN,IAAI,gBAAgB;CACpB,SAAS,gBAAgB;CACzB,UAAU;CACV,UAAU;CAQV,OAAO,EACL,YAAY,EACV,kBAAkB,MAAM,KAAK,qBAAqB,QAAQ,CAAC,EAC5D,EACF;CACD,cAAc,MAAM,KAAK,qBAAqB,QAAQ,CAAC;CACvD,uBAAuB,wBAAwB;CAC/C,SAAS;EACP,OAAO;GACL,UAAU;GACV,UAAU;GACX;;CAEJ"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@prisma-next/extension-postgis",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "scripts": {
+    "build:contract-space": "prisma-next contract emit",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --project tsconfig.json --noEmit",
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
+  },
+  "dependencies": {
+    "@prisma-next/contract": "workspace:*",
+    "@prisma-next/contract-authoring": "workspace:*",
+    "@prisma-next/family-sql": "workspace:*",
+    "@prisma-next/framework-components": "workspace:*",
+    "@prisma-next/migration-tools": "workspace:*",
+    "@prisma-next/sql-contract": "workspace:*",
+    "@prisma-next/sql-operations": "workspace:*",
+    "@prisma-next/sql-relational-core": "workspace:*",
+    "@prisma-next/sql-runtime": "workspace:*",
+    "@prisma-next/sql-schema-ir": "workspace:*",
+    "@standard-schema/spec": "^1.1.0",
+    "arktype": "^2.1.29"
+  },
+  "devDependencies": {
+    "@prisma-next/adapter-postgres": "workspace:*",
+    "@prisma-next/cli": "workspace:*",
+    "@prisma-next/operations": "workspace:*",
+    "@prisma-next/sql-contract-ts": "workspace:*",
+    "@prisma-next/target-postgres": "workspace:*",
+    "@prisma-next/test-utils": "workspace:*",
+    "@prisma-next/tsconfig": "workspace:*",
+    "@prisma-next/tsdown": "workspace:*",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    "./codec-types": "./dist/codec-types.mjs",
+    "./column-types": "./dist/column-types.mjs",
+    "./control": "./dist/control.mjs",
+    "./geojson": "./dist/geojson.mjs",
+    "./operation-types": "./dist/operation-types.mjs",
+    "./pack": "./dist/pack.mjs",
+    "./runtime": "./dist/runtime.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/3-extensions/postgis"
+  }
+}

package/src/contract.d.ts

@@ -0,0 +1,91 @@
+// ⚠️  GENERATED FILE - DO NOT EDIT
+// This file is automatically generated by 'prisma-next contract emit'.
+// To regenerate, run: prisma-next contract emit
+import type { CodecTypes as PgTypes } from '@prisma-next/target-postgres/codec-types';
+import type { JsonValue } from '@prisma-next/target-postgres/codec-types';
+import type { Char } from '@prisma-next/target-postgres/codec-types';
+import type { Varchar } from '@prisma-next/target-postgres/codec-types';
+import type { Numeric } from '@prisma-next/target-postgres/codec-types';
+import type { Bit } from '@prisma-next/target-postgres/codec-types';
+import type { VarBit } from '@prisma-next/target-postgres/codec-types';
+import type { Timestamp } from '@prisma-next/target-postgres/codec-types';
+import type { Timestamptz } from '@prisma-next/target-postgres/codec-types';
+import type { Time } from '@prisma-next/target-postgres/codec-types';
+import type { Timetz } from '@prisma-next/target-postgres/codec-types';
+import type { Interval } from '@prisma-next/target-postgres/codec-types';
+import type { QueryOperationTypes as PgAdapterQueryOps } from '@prisma-next/adapter-postgres/operation-types';
+
+import type {
+  ContractWithTypeMaps,
+  TypeMaps as TypeMapsType,
+} from '@prisma-next/sql-contract/types';
+import type {
+  Contract as ContractType,
+  ExecutionHashBase,
+  ProfileHashBase,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+
+export type StorageHash =
+  StorageHashBase<'sha256:01622b3970e0ee2a582cc4c857bca7f6ed970f21b23f44e3f2781eea0be7d5eb'>;
+export type ExecutionHash = ExecutionHashBase<string>;
+export type ProfileHash =
+  ProfileHashBase<'sha256:1a8dbe044289f30a1de958fe800cc5a8378b285d2e126a8c44b58864bac2c18e'>;
+
+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 = Record<string, never>;
+export type FieldInputTypes = Record<string, never>;
+export type TypeMaps = TypeMapsType<
+  CodecTypes,
+  QueryOperationTypes,
+  FieldOutputTypes,
+  FieldInputTypes
+>;
+
+type ContractBase = ContractType<
+  {
+    readonly tables: {};
+    readonly types: {
+      readonly geometry: {
+        readonly codecId: 'pg/geometry@1';
+        readonly nativeType: 'geometry';
+        readonly typeParams: Record<string, never>;
+      };
+    };
+    readonly storageHash: StorageHash;
+  },
+  Record<string, never>
+> & {
+  readonly target: 'postgres';
+  readonly targetFamily: 'sql';
+  readonly roots: Record<string, string>;
+  readonly capabilities: {
+    readonly postgres: {
+      readonly jsonAgg: true;
+      readonly lateral: true;
+      readonly limit: true;
+      readonly orderBy: true;
+      readonly returning: true;
+    };
+    readonly sql: {
+      readonly defaultInInsert: true;
+      readonly enums: true;
+      readonly returning: true;
+    };
+  };
+  readonly extensionPacks: {};
+  readonly meta: {};
+
+  readonly profileHash: ProfileHash;
+};
+
+export type Contract = ContractWithTypeMaps<ContractBase, TypeMaps>;
+
+export type Tables = Contract['storage']['tables'];
+export type Models = Contract['models'];

package/src/contract.json

@@ -0,0 +1,40 @@
+{
+  "schemaVersion": "1",
+  "targetFamily": "sql",
+  "target": "postgres",
+  "profileHash": "sha256:1a8dbe044289f30a1de958fe800cc5a8378b285d2e126a8c44b58864bac2c18e",
+  "roots": {},
+  "models": {},
+  "storage": {
+    "storageHash": "sha256:01622b3970e0ee2a582cc4c857bca7f6ed970f21b23f44e3f2781eea0be7d5eb",
+    "tables": {},
+    "types": {
+      "geometry": {
+        "codecId": "pg/geometry@1",
+        "nativeType": "geometry",
+        "typeParams": {}
+      }
+    }
+  },
+  "capabilities": {
+    "postgres": {
+      "jsonAgg": true,
+      "lateral": true,
+      "limit": true,
+      "orderBy": true,
+      "returning": true
+    },
+    "sql": {
+      "defaultInInsert": true,
+      "enums": 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,61 @@
+/**
+ * TS contract source for the `extension-postgis` package.
+ *
+ * Authored against the contract-space package layout convention. The
+ * same emit pipeline application authors use is applied here:
+ *
+ *   `prisma-next contract emit` → `<package>/src/contract.{json,d.ts}`
+ *   `prisma-next migration plan` → `<package>/migrations/<dirName>/`
+ *
+ * The descriptor at `src/exports/control.ts` then wires the emitted
+ * JSON artefacts via JSON-import declarations.
+ *
+ * ## IR coverage
+ *
+ * postgis ships **no tables** of its own. The single object the
+ * extension contributes to the contract IR is the parameterised native
+ * type `geometry`, registered under `storage.types`. Per-column
+ * instances on the user's side carry concrete `typeParams.srid`
+ * (e.g. `geometry({ srid: 4326 })`); the registration here declares
+ * the parameterised shape so the verifier sees `geometry` as part of
+ * postgis's space contribution and so the pinned `contract.json` on
+ * disk is materially distinct from an empty space.
+ *
+ * ## Why TS, not PSL
+ *
+ * The contract-space package layout convention prefers PSL
+ * (`src/contract.prisma`). postgis is the same narrow exception
+ * pgvector takes: PSL's `types {}` block instantiates parameterised
+ * types at app authoring time (e.g. `Geom4326 = postgis.Geometry(4326)`)
+ * but has no surface for an extension to register the parameterised
+ * BASE type itself (the `storage.types.geometry` entry with empty
+ * `typeParams` shown below). Until PSL grows that surface, this
+ * extension keeps its contract source in TS.
+ *
+ * @see docs/architecture docs/adrs/ADR 212 - Contract spaces.md
+ */
+
+import sqlFamily from '@prisma-next/family-sql/pack';
+import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
+import postgresPack from '@prisma-next/target-postgres/pack';
+import { POSTGIS_GEOMETRY_CODEC_ID } from './core/constants';
+import { POSTGIS_NATIVE_TYPE } from './core/contract-space-constants';
+
+export const contract = defineContract(
+  {
+    family: sqlFamily,
+    target: postgresPack,
+  },
+  () => ({
+    types: {
+      [POSTGIS_NATIVE_TYPE]: {
+        codecId: POSTGIS_GEOMETRY_CODEC_ID,
+        nativeType: POSTGIS_NATIVE_TYPE,
+        typeParams: {},
+      },
+    },
+    models: {},
+  }),
+);
+
+export default contract;

package/src/core/authoring.ts

@@ -0,0 +1,18 @@
+import type { AuthoringTypeNamespace } from '@prisma-next/framework-components/authoring';
+import { POSTGIS_GEOMETRY_CODEC_ID } from './constants';
+
+export const postgisAuthoringTypes = {
+  postgis: {
+    Geometry: {
+      kind: 'typeConstructor',
+      args: [{ kind: 'number', name: 'srid', integer: true, minimum: 0 }],
+      output: {
+        codecId: POSTGIS_GEOMETRY_CODEC_ID,
+        nativeType: 'geometry',
+        typeParams: {
+          srid: { kind: 'arg', index: 0 },
+        },
+      },
+    },
+  },
+} as const satisfies AuthoringTypeNamespace;