@prisma-next/target-postgres 0.15.0 → 0.16.0-dev.2

package/dist/{resolve-ddl-schema-XyBaaenM.mjs.map → resolve-ddl-schema-D0wi_P9Q.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"resolve-ddl-schema-XyBaaenM.mjs","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Given the contract's storage and a namespace id, returns the live Postgres\n * DDL schema name that namespace maps to. A named Postgres namespace dispatches\n * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to\n * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a\n * bare object payload (used by some tests) falls back to the namespace id\n * itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return DEFAULT_NAMESPACE_ID;\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,oCACd,SACA,aACQ;CACR,IAAI,gBAAgB,sBAClB,OAAO;CAET,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}
+{"version":3,"file":"resolve-ddl-schema-D0wi_P9Q.mjs","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Given the contract's storage and a namespace id, returns the live Postgres\n * DDL schema name that namespace maps to. A named Postgres namespace dispatches\n * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to\n * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a\n * bare object payload (used by some tests) falls back to the namespace id\n * itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return DEFAULT_NAMESPACE_ID;\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,SAAgB,oCACd,SACA,aACQ;CACR,IAAI,gBAAgB,sBAClB,OAAO;CAET,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}

package/dist/rls-canonicalize.d.mts

@@ -1,5 +1,4 @@
 import { a as normalizePredicate, i as computeContentHash, n as POLICY_OPERATION_PREDICATES, r as RlsPolicyOperation, t as ContentHashParts } from "./canonicalize-D1F4vUnP.mjs";
-
 //#region src/core/rls/wire-name.d.ts
 interface RlsPolicyWireName {
   /** The user-supplied part before the `_<8hex>` suffix. */

package/dist/rls-canonicalize.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rls-canonicalize.d.mts","names":[],"sources":["../src/core/rls/wire-name.ts"],"mappings":";;;UAAiB,iBAAA;;WAEN,MAAA;EAFM;EAAA,SAIN,IAAI;AAAA;;AAAA;AAWf;;;;iBAAgB,uBAAA,CAAwB,MAAA,UAAgB,IAAY;AAWpE;;;;AAAuE;;;AAAvE,iBAAgB,sBAAA,CAAuB,IAAA,WAAe,iBAAiB"}
+{"version":3,"file":"rls-canonicalize.d.mts","names":[],"sources":["../src/core/rls/wire-name.ts"],"mappings":";;UAAiB;;WAEN;;WAEA;;;;;;;;iBAWK,wBAAwB,gBAAgB;;;;;;;;iBAWxC,uBAAuB,eAAe"}

package/dist/runtime.d.mts

@@ -1,4 +1,4 @@
-import { t as PostgresContractView } from "./postgres-contract-view-C9j5cqP0.mjs";
+import { t as PostgresContractView } from "./postgres-contract-view-CeU7FJjW.mjs";
 import { AnyCodecDescriptor } from "@prisma-next/framework-components/codec";
 import { AnyEntityKindDescriptor, Namespace } from "@prisma-next/framework-components/ir";
 import { SqlNamespaceInput, SqlStorage } from "@prisma-next/sql-contract/types";
@@ -6,7 +6,6 @@ import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { Contract } from "@prisma-next/contract/types";
 import { RuntimeTargetDescriptor, RuntimeTargetInstance } from "@prisma-next/framework-components/execution";
 import { JsonObject } from "@prisma-next/utils/json";
-
 //#region src/core/postgres-contract-serializer.d.ts
 declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
   constructor(extraPackEntityKinds?: readonly AnyEntityKindDescriptor[]);

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;;cA0Ea,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;cACrE,oBAAA,YAA+B,uBAAA;EAAA,UAWxB,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,MAAA,oBACJ,SAAA,GAAY,iBAAA;EAyBN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;AAAA;;;UCxG7C,6BAAA,SAAsC,qBAAqB;;;;;ADgE5E;;cCxDM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cA0Ea,mCAAmC,0BAA0B,SAAS;cACrE,gCAA+B;YAWxB,yBACjB,cACA,KAAK,0BACJ,YAAY;EAyBN,kBAAkB,UAAU,SAAS,cAAc;;;;UCxG7C,sCAAsC;;;;;;;cAQjD,iCAAiC,2CAGrC;WAES,uBAAuB"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
 import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-UwYdV8fD.mjs";
-import { n as PostgresContractSerializer, t as PostgresContractView } from "./postgres-contract-view-DM8sN1Ot.mjs";
+import { n as PostgresContractSerializer, t as PostgresContractView } from "./postgres-contract-view-DebHMqGR.mjs";
 //#region src/exports/runtime.ts
 /**
 * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor` from `@prisma-next/sql-runtime`. The target package is a control-plane residence and must not pull the SQL execution-plane package into its dependency closure. The runtime descriptor here is shaped to satisfy the framework's `RuntimeTargetDescriptor` plus the structural `SqlStaticContributions` (`codecs:` returning a descriptor list) that

package/dist/schema-ir-annotations.d.mts

@@ -1,5 +1,4 @@
 import { SqlStorage } from "@prisma-next/sql-contract/types";
-
 //#region src/core/migrations/resolve-ddl-schema.d.ts
 /**
  * Given the contract's storage and a namespace id, returns the live Postgres

package/dist/schema-ir-annotations.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-ir-annotations.d.mts","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"mappings":";;;;;AAaA;;;;;;iBAAgB,mCAAA,CACd,OAAA,EAAS,UAAU,EACnB,WAAA"}
+{"version":3,"file":"schema-ir-annotations.d.mts","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"mappings":";;;;;;;;;;iBAagB,oCACd,SAAS,YACT"}

package/dist/schema-ir-annotations.mjs

@@ -1,2 +1,2 @@
-import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-XyBaaenM.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-D0wi_P9Q.mjs";
 export { resolveDdlSchemaForNamespaceStorage };

package/dist/schema-node-kinds-DxvWh2Ic.d.mts

@@ -0,0 +1,29 @@
+import { SqlSchemaIRNode } from "@prisma-next/sql-schema-ir/types";
+import { DiffableNode } from "@prisma-next/framework-components/control";
+//#region src/core/schema-ir/schema-node-kinds.d.ts
+/**
+ * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements
+ * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`
+ * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)
+ * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node
+ * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).
+ */
+type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;
+/**
+ * The `nodeKind` discriminant for each Postgres schema-diff node. Each node
+ * carries a unique value; the static `is`/`assert` guards compare against these
+ * identifiers rather than spelling the string inline or using `instanceof`. The
+ * field is an enumerable own property carried on every node instance.
+ */
+declare const PostgresSchemaNodeKind: {
+  readonly database: "postgres-database";
+  readonly namespace: "postgres-namespace";
+  readonly table: "postgres-table";
+  readonly policy: "postgres-policy";
+  readonly role: "postgres-role";
+  readonly nativeEnum: "postgres-native-enum";
+};
+type PostgresSchemaNodeKind = (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];
+//#endregion
+export { SqlSchemaDiffNode as n, PostgresSchemaNodeKind as t };
+//# sourceMappingURL=schema-node-kinds-DxvWh2Ic.d.mts.map

package/dist/schema-node-kinds-DxvWh2Ic.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-node-kinds-DxvWh2Ic.d.mts","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts"],"mappings":";;;;;;;;;;KAiBY,oBAAoB,kBAAkB;;;;;;;cAQrC;;;;;;;;KASD,iCACF,qCAAqC"}

package/dist/sql-utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-utils.d.mts","names":[],"sources":["../src/core/sql-utils.ts"],"mappings":";;AAYA;;;;;;;;;;cAAa,cAAA,SAAuB,KAAK;EAAA,SAGrB,KAAA;EAAA,SACA,IAAA;cAFhB,OAAA,UACgB,KAAA,UACA,IAAA;AAAA;;;AAmB8B;AA8BlD;;;;AAA2C;AAc3C;;iBA5CgB,eAAA,CAAgB,UAAkB;;AA4CgB;AAUlE;;;;AAA+C;AAkB/C;;;;iBA1CgB,aAAA,CAAc,KAAa;;;;iBAc3B,WAAA,CAAY,UAAA,UAAoB,UAAkB;;;;;;;iBAUlD,kBAAA,CAAmB,IAAY;;;;;;;;;;;;iBAkB/B,uBAAA,CAAwB,KAAA,UAAe,YAAoB"}
+{"version":3,"file":"sql-utils.d.mts","names":[],"sources":["../src/core/sql-utils.ts"],"mappings":";;;;;;;;;;;;cAYa,uBAAuB;WAGhB;WACA;cAFhB,iBACgB,eACA;;;;;;;;;;;;iBAmBJ,gBAAgB;;;;;;;;;;;;iBA8BhB,cAAc;;;;iBAcd,YAAY,oBAAoB;;;;;;;iBAUhC,mBAAmB;;;;;;;;;;;;iBAkBnB,wBAAwB,eAAe"}

package/dist/{table-source-BvFo7gVs.d.mts → table-source-D5c2fxAQ.d.mts}

@@ -1,5 +1,4 @@
 import { AnyFromSource, AstRewriter, TableSource } from "@prisma-next/sql-relational-core/ast";
-
 //#region src/core/ast/table-source.d.ts
 declare class PostgresTableSource extends TableSource {
   readonly schema: string | undefined;
@@ -12,4 +11,4 @@ declare class PostgresTableSource extends TableSource {
 }
 //#endregion
 export { PostgresTableSource as t };
-//# sourceMappingURL=table-source-BvFo7gVs.d.mts.map
+//# sourceMappingURL=table-source-D5c2fxAQ.d.mts.map

package/dist/table-source-D5c2fxAQ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-source-D5c2fxAQ.d.mts","names":[],"sources":["../src/core/ast/table-source.ts"],"mappings":";;cAMa,4BAA4B;WAC9B;cAEG;aACD;aACA;aACA;;EAOF,QAAQ,UAAU,cAAc"}

package/dist/{types-BDKkx8MA.d.mts → types-D2MLzLBD.d.mts}

@@ -1,5 +1,4 @@
 import { ColumnDefault } from "@prisma-next/contract/types";
-
 //#region src/core/types.d.ts
 type PostgresColumnDefault = ColumnDefault | {
   readonly kind: 'sequence';
@@ -7,4 +6,4 @@ type PostgresColumnDefault = ColumnDefault | {
 };
 //#endregion
 export { PostgresColumnDefault as t };
-//# sourceMappingURL=types-BDKkx8MA.d.mts.map
+//# sourceMappingURL=types-D2MLzLBD.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-D2MLzLBD.d.mts","names":[],"sources":["../src/core/types.ts"],"mappings":";;KAEY,wBACR;WACW;WAA2B"}

package/dist/types.d.mts

@@ -1,5 +1,6 @@
-import { a as PostgresNamespaceSchemaNode, c as PostgresTableSchemaNodeInput, d as PostgresNativeEnumSchemaNode, f as PostgresNativeEnumSchemaNodeInput, i as PostgresRoleSchemaNodeInput, l as PostgresPolicySchemaNode, n as PostgresDatabaseSchemaNodeInput, o as PostgresNamespaceSchemaNodeInput, r as PostgresRoleSchemaNode, s as PostgresTableSchemaNode, t as PostgresDatabaseSchemaNode, u as PostgresPolicySchemaNodeInput } from "./postgres-database-schema-node-CJv5bfbs.mjs";
-import { n as PostgresRlsPolicyInput, r as RlsPolicyOperation, t as PostgresRlsPolicy } from "./postgres-rls-policy--CSddvMR.mjs";
-import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
-import { a as postgresCreateNamespace, c as PostgresRlsEnablement, d as PostgresNativeEnumInput, i as isPostgresSchema, l as PostgresRlsEnablementInput, n as PostgresSchema, o as PostgresRole, r as PostgresUnboundSchema, s as PostgresRoleInput, t as PostgresContract, u as PostgresNativeEnum } from "./postgres-schema-DKq6s1P3.mjs";
-export { type PostgresColumnDefault, type PostgresContract, PostgresDatabaseSchemaNode, type PostgresDatabaseSchemaNodeInput, PostgresNamespaceSchemaNode, type PostgresNamespaceSchemaNodeInput, PostgresNativeEnum, type PostgresNativeEnumInput, PostgresNativeEnumSchemaNode, type PostgresNativeEnumSchemaNodeInput, PostgresPolicySchemaNode, type PostgresPolicySchemaNodeInput, PostgresRlsEnablement, type PostgresRlsEnablementInput, PostgresRlsPolicy, type PostgresRlsPolicyInput, PostgresRole, type PostgresRoleInput, PostgresRoleSchemaNode, type PostgresRoleSchemaNodeInput, PostgresSchema, PostgresTableSchemaNode, type PostgresTableSchemaNodeInput, PostgresUnboundSchema, type RlsPolicyOperation, isPostgresSchema, postgresCreateNamespace };
+import { a as PostgresNamespaceSchemaNode, c as PostgresTableSchemaNodeInput, d as PostgresNativeEnumSchemaNode, f as PostgresNativeEnumSchemaNodeInput, i as PostgresRoleSchemaNodeInput, l as PostgresPolicySchemaNode, n as PostgresDatabaseSchemaNodeInput, o as PostgresNamespaceSchemaNodeInput, r as PostgresRoleSchemaNode, s as PostgresTableSchemaNode, t as PostgresDatabaseSchemaNode, u as PostgresPolicySchemaNodeInput } from "./postgres-database-schema-node-DMXsIwAb.mjs";
+import { n as PostgresRlsPolicyInput, r as RlsPolicyOperation, t as PostgresRlsPolicy } from "./postgres-rls-policy-CYXdqG9B.mjs";
+import { t as PostgresSchemaNodeKind } from "./schema-node-kinds-DxvWh2Ic.mjs";
+import { t as PostgresColumnDefault } from "./types-D2MLzLBD.mjs";
+import { a as postgresCreateNamespace, c as PostgresRlsEnablement, d as PostgresNativeEnumInput, i as isPostgresSchema, l as PostgresRlsEnablementInput, n as PostgresSchema, o as PostgresRole, r as PostgresUnboundSchema, s as PostgresRoleInput, t as PostgresContract, u as PostgresNativeEnum } from "./postgres-schema-FdKRwe7X.mjs";
+export { type PostgresColumnDefault, type PostgresContract, PostgresDatabaseSchemaNode, type PostgresDatabaseSchemaNodeInput, PostgresNamespaceSchemaNode, type PostgresNamespaceSchemaNodeInput, PostgresNativeEnum, type PostgresNativeEnumInput, PostgresNativeEnumSchemaNode, type PostgresNativeEnumSchemaNodeInput, PostgresPolicySchemaNode, type PostgresPolicySchemaNodeInput, PostgresRlsEnablement, type PostgresRlsEnablementInput, PostgresRlsPolicy, type PostgresRlsPolicyInput, PostgresRole, type PostgresRoleInput, PostgresRoleSchemaNode, type PostgresRoleSchemaNodeInput, PostgresSchema, PostgresSchemaNodeKind, PostgresTableSchemaNode, type PostgresTableSchemaNodeInput, PostgresUnboundSchema, type RlsPolicyOperation, isPostgresSchema, postgresCreateNamespace };

package/dist/types.mjs

@@ -1,5 +1,5 @@
 import { t as PostgresNativeEnum } from "./postgres-native-enum-BwVNf0Ku.mjs";
-import { _ as PostgresRlsEnablement, g as PostgresRlsPolicy, i as postgresCreateNamespace, m as PostgresRole, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-Cm4DtiGA.mjs";
-import { n as PostgresNativeEnumSchemaNode, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-D6LvInCe.mjs";
-import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from "./postgres-role-schema-node-Cm-j0ZGM.mjs";
-export { PostgresDatabaseSchemaNode, PostgresNamespaceSchemaNode, PostgresNativeEnum, PostgresNativeEnumSchemaNode, PostgresPolicySchemaNode, PostgresRlsEnablement, PostgresRlsPolicy, PostgresRole, PostgresRoleSchemaNode, PostgresSchema, PostgresTableSchemaNode, PostgresUnboundSchema, isPostgresSchema, postgresCreateNamespace };
+import { _ as PostgresRlsEnablement, g as PostgresRlsPolicy, i as postgresCreateNamespace, m as PostgresRole, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-CewLYHB7.mjs";
+import { n as PostgresNativeEnumSchemaNode, r as PostgresSchemaNodeKind, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-D6LvInCe.mjs";
+import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from "./postgres-role-schema-node-bg32e7I-.mjs";
+export { PostgresDatabaseSchemaNode, PostgresNamespaceSchemaNode, PostgresNativeEnum, PostgresNativeEnumSchemaNode, PostgresPolicySchemaNode, PostgresRlsEnablement, PostgresRlsPolicy, PostgresRole, PostgresRoleSchemaNode, PostgresSchema, PostgresSchemaNodeKind, PostgresTableSchemaNode, PostgresUnboundSchema, isPostgresSchema, postgresCreateNamespace };

package/package.json

@@ -1,36 +1,36 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.15.0",
+  "version": "0.16.0-dev.2",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.15.0",
-    "@prisma-next/contract": "0.15.0",
-    "@prisma-next/errors": "0.15.0",
-    "@prisma-next/family-sql": "0.15.0",
-    "@prisma-next/framework-components": "0.15.0",
-    "@prisma-next/migration-tools": "0.15.0",
-    "@prisma-next/psl-parser": "0.15.0",
-    "@prisma-next/sql-contract": "0.15.0",
-    "@prisma-next/sql-errors": "0.15.0",
-    "@prisma-next/sql-operations": "0.15.0",
-    "@prisma-next/sql-relational-core": "0.15.0",
-    "@prisma-next/sql-schema-ir": "0.15.0",
-    "@prisma-next/ts-render": "0.15.0",
-    "@prisma-next/utils": "0.15.0",
+    "@prisma-next/cli": "0.16.0-dev.2",
+    "@prisma-next/contract": "0.16.0-dev.2",
+    "@prisma-next/errors": "0.16.0-dev.2",
+    "@prisma-next/family-sql": "0.16.0-dev.2",
+    "@prisma-next/framework-components": "0.16.0-dev.2",
+    "@prisma-next/migration-tools": "0.16.0-dev.2",
+    "@prisma-next/psl-parser": "0.16.0-dev.2",
+    "@prisma-next/sql-contract": "0.16.0-dev.2",
+    "@prisma-next/sql-errors": "0.16.0-dev.2",
+    "@prisma-next/sql-operations": "0.16.0-dev.2",
+    "@prisma-next/sql-relational-core": "0.16.0-dev.2",
+    "@prisma-next/sql-schema-ir": "0.16.0-dev.2",
+    "@prisma-next/ts-render": "0.16.0-dev.2",
+    "@prisma-next/utils": "0.16.0-dev.2",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.2",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/psl-printer": "0.15.0",
-    "@prisma-next/sql-contract-psl": "0.15.0",
-    "@prisma-next/test-utils": "0.15.0",
-    "@prisma-next/tsconfig": "0.15.0",
-    "@prisma-next/tsdown": "0.15.0",
-    "tsdown": "0.22.3",
+    "@prisma-next/psl-printer": "0.16.0-dev.2",
+    "@prisma-next/sql-contract-psl": "0.16.0-dev.2",
+    "@prisma-next/test-utils": "0.16.0-dev.2",
+    "@prisma-next/tsconfig": "0.16.0-dev.2",
+    "@prisma-next/tsdown": "0.16.0-dev.2",
+    "tsdown": "0.22.8",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
   },

package/src/core/authoring.ts

@@ -1,4 +1,7 @@
-import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';
+import {
+  temporalAuthoringPresets,
+  temporalCodecPresetWithPrecision,
+} from '@prisma-next/family-sql/control';
 import type {
   AuthoringEntityContext,
   AuthoringEntityTypeFactoryOutput,
@@ -627,10 +630,20 @@ export const postgresAuthoringFieldPresets = {
       nativeType: 'timestamptz',
     },
   },
-  temporal: /* @__PURE__ */ temporalAuthoringPresets({
-    codecId: 'pg/timestamptz@1',
-    nativeType: 'timestamptz',
-  }),
+  temporal: {
+    .../* @__PURE__ */ temporalAuthoringPresets({
+      codecId: 'pg/timestamptz@1',
+      nativeType: 'timestamptz',
+    }),
+    timestamp: /* @__PURE__ */ temporalCodecPresetWithPrecision({
+      codecId: 'pg/timestamp@1',
+      nativeType: 'timestamp',
+    }),
+    timestamptz: /* @__PURE__ */ temporalCodecPresetWithPrecision({
+      codecId: 'pg/timestamptz@1',
+      nativeType: 'timestamptz',
+    }),
+  },
   uuidNative: {
     kind: 'fieldPreset',
     output: {

package/src/core/codec-helpers.ts

@@ -47,7 +47,7 @@ export const pgNumericDecode = (wire: string | number): string => {
 };
 
 export const pgNumericRenderOutputType = (typeParams: {
-  readonly precision: number;
+  readonly precision?: number;
   readonly scale?: number;
 }): string | undefined => {
   const precision = typeParams.precision;
@@ -106,6 +106,58 @@ export const pgTimestamptzDecodeJson = (json: JsonValue): Date => {
   return date;
 };
 
+const ISO_8601_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+function formatDateOnly(year: number, month: number, day: number): string {
+  return `${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+}
+
+/**
+ * A Postgres `date` has no time-of-day or timezone component, so `pg/date@1`
+ * canonicalizes its JS-level value as a `Date` at UTC midnight
+ * (`Date.UTC(y, m, d)`), independent of the process's local timezone.
+ *
+ * `pgDateEncode` reads the calendar date via UTC getters (matching that
+ * canonical form) and formats it as `YYYY-MM-DD` directly, bypassing the pg
+ * driver's own `Date` serialization (`dateToString`), which reads *local*
+ * getters and would shift the calendar day near midnight in negative-UTC-offset
+ * environments.
+ */
+export const pgDateEncode = (value: Date): string =>
+  formatDateOnly(value.getUTCFullYear(), value.getUTCMonth() + 1, value.getUTCDate());
+
+/**
+ * Normalizes the pg driver's already-parsed `Date` for a `date` column into
+ * the canonical UTC-midnight form. The driver (via `postgres-date`) builds
+ * that `Date` at *local* midnight from the wire text; reading it back with the
+ * same (local) getters recovers the exact calendar date the driver parsed,
+ * and reconstructing via `Date.UTC` makes the result's instant independent of
+ * the process's timezone.
+ */
+export const pgDateDecode = (wire: Date): Date =>
+  new Date(Date.UTC(wire.getFullYear(), wire.getMonth(), wire.getDate()));
+
+export const pgDateEncodeJson = (value: Date): JsonValue => pgDateEncode(value);
+
+export const pgDateDecodeJson = (json: JsonValue): Date => {
+  if (typeof json !== 'string') {
+    throw new Error(`Expected date string for pg/date@1, got ${typeof json}`);
+  }
+  const match = ISO_8601_DATE.exec(json);
+  if (!match) {
+    throw new Error(`Invalid date string for pg/date@1: ${json}`);
+  }
+  const [, yearText, monthText, dayText] = match;
+  const year = Number(yearText);
+  const month = Number(monthText) - 1;
+  const day = Number(dayText);
+  const date = new Date(Date.UTC(year, month, day));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) {
+    throw new Error(`Invalid date string for pg/date@1: ${json}`);
+  }
+  return date;
+};
+
 export const pgIntervalDecode = (wire: string | Record<string, unknown>): string => {
   if (typeof wire === 'string') return wire;
   return JSON.stringify(wire);

package/src/core/codec-ids.ts

@@ -22,6 +22,7 @@ export const PG_NUMERIC_CODEC_ID = 'pg/numeric@1' as const;
 export const PG_BOOL_CODEC_ID = 'pg/bool@1' as const;
 export const PG_BIT_CODEC_ID = 'pg/bit@1' as const;
 export const PG_VARBIT_CODEC_ID = 'pg/varbit@1' as const;
+export const PG_DATE_CODEC_ID = 'pg/date@1' as const;
 export const PG_TIMESTAMP_CODEC_ID = 'pg/timestamp@1' as const;
 export const PG_TIMESTAMPTZ_CODEC_ID = 'pg/timestamptz@1' as const;
 export const PG_TIME_CODEC_ID = 'pg/time@1' as const;

package/src/core/codecs.ts

@@ -45,6 +45,10 @@ import { type as arktype } from 'arktype';
 import {
   pgByteaDecodeJson,
   pgByteaEncodeJson,
+  pgDateDecode,
+  pgDateDecodeJson,
+  pgDateEncode,
+  pgDateEncodeJson,
   pgIntervalDecode,
   pgJsonbDecode,
   pgJsonbEncode,
@@ -64,6 +68,7 @@ import {
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
+  PG_DATE_CODEC_ID,
   PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
@@ -92,14 +97,14 @@ import { PostgresNativeEnum } from './postgres-native-enum';
 
 type LengthParams = { readonly length?: number };
 type PrecisionParams = { readonly precision?: number };
-type NumericParams = { readonly precision: number; readonly scale?: number };
+type NumericParams = { readonly precision?: number; readonly scale?: number };
 
 const lengthParamsSchema = arktype({
   'length?': 'number.integer > 0',
 }) satisfies StandardSchemaV1<LengthParams>;
 
 const numericParamsSchema = arktype({
-  precision: 'number.integer > 0 & number.integer <= 1000',
+  'precision?': 'number.integer > 0 & number.integer <= 1000',
   'scale?': 'number.integer >= 0',
 }) satisfies StandardSchemaV1<NumericParams>;
 
@@ -115,6 +120,7 @@ const PG_INT8_META = { db: { sql: { postgres: { nativeType: 'bigint' } } } } as
 const PG_FLOAT4_META = { db: { sql: { postgres: { nativeType: 'real' } } } } as const;
 const PG_FLOAT8_META = { db: { sql: { postgres: { nativeType: 'double precision' } } } } as const;
 const PG_NUMERIC_META = { db: { sql: { postgres: { nativeType: 'numeric' } } } } as const;
+const PG_DATE_META = { db: { sql: { postgres: { nativeType: 'date' } } } } as const;
 const PG_TIMESTAMP_META = {
   db: { sql: { postgres: { nativeType: 'timestamp without time zone' } } },
 } as const;
@@ -648,12 +654,57 @@ export class PgNumericDescriptor extends CodecDescriptorImpl<NumericParams> {
 
 export const pgNumericDescriptor = new PgNumericDescriptor();
 
-export const pgNumericColumn = (params: NumericParams) =>
+export const pgNumericColumn = (params: NumericParams = {}) =>
   column(pgNumericDescriptor.factory(params), pgNumericDescriptor.codecId, params, 'numeric');
 
 pgNumericColumn satisfies ColumnHelperFor<PgNumericDescriptor>;
 pgNumericColumn satisfies ColumnHelperForStrict<PgNumericDescriptor>;
 
+/**
+ * A Postgres `date` has no time-of-day or timezone component. This codec
+ * canonicalizes its JS-level value as a `Date` at UTC midnight, so its
+ * round-trip is independent of the process's local timezone — see
+ * `pgDateEncode`/`pgDateDecode` in `codec-helpers.ts`.
+ */
+export class PgDateCodec extends CodecImpl<
+  typeof PG_DATE_CODEC_ID,
+  readonly ['equality', 'order'],
+  Date | string,
+  Date
+> {
+  async encode(value: Date, _ctx: CodecCallContext): Promise<string> {
+    return pgDateEncode(value);
+  }
+  async decode(wire: Date, _ctx: CodecCallContext): Promise<Date> {
+    return pgDateDecode(wire);
+  }
+  encodeJson(value: Date): JsonValue {
+    return pgDateEncodeJson(value);
+  }
+  decodeJson(json: JsonValue): Date {
+    return pgDateDecodeJson(json);
+  }
+}
+
+export class PgDateDescriptor extends CodecDescriptorImpl<void> {
+  override readonly codecId = PG_DATE_CODEC_ID;
+  override readonly traits = ['equality', 'order'] as const;
+  override readonly targetTypes = ['date'] as const;
+  override readonly meta = PG_DATE_META;
+  override readonly paramsSchema: StandardSchemaV1<void> = voidParamsSchema;
+  override factory(): (ctx: CodecInstanceContext) => PgDateCodec {
+    return () => new PgDateCodec(this);
+  }
+}
+
+export const pgDateDescriptor = new PgDateDescriptor();
+
+export const pgDateColumn = () =>
+  column(pgDateDescriptor.factory(), pgDateDescriptor.codecId, undefined, 'date');
+
+pgDateColumn satisfies ColumnHelperFor<PgDateDescriptor>;
+pgDateColumn satisfies ColumnHelperForStrict<PgDateDescriptor>;
+
 export class PgTimestampCodec extends CodecImpl<
   typeof PG_TIMESTAMP_CODEC_ID,
   readonly ['equality', 'order'],
@@ -1285,6 +1336,8 @@ export const codecDescriptors: readonly AnyCodecDescriptor[] = [
   pgFloat4Descriptor,
   pgFloat8Descriptor,
   pgNumericDescriptor,
+  // PSL `@db.Date` binding is deferred to remove-db-attributes' `Date` type; pin it via codecId, not a second targetTypes activation here.
+  pgDateDescriptor,
   pgTimestampDescriptor,
   pgTimestamptzDescriptor,
   pgTimeDescriptor,

package/src/core/default-normalizer.ts

@@ -249,3 +249,25 @@ export function parsePostgresDefault(
 
   return { kind: 'function', expression: trimmed };
 }
+
+/**
+ * Normalizes a contract-declared default through {@link parsePostgresDefault}
+ * — the same parser introspection uses — so a function-shaped default the
+ * parser recognizes as a literal (e.g. `dbgenerated("'{}'::jsonb")`)
+ * resolves to the same `resolvedDefault` shape a live introspected column
+ * would produce. Compensates once, at `SchemaIR` construction of the
+ * expected (contract-derived) side (`contractToSchemaIR`'s `resolveDefault`
+ * hook), instead of at every site that later compares the two sides. A
+ * literal default, or a function form the parser doesn't recognize, passes
+ * through unchanged; `nextval(...)` normalizes to `autoincrement()` on both
+ * sides, matching a `serial`/identity column's introspected counterpart.
+ */
+export function postgresResolveDefault(
+  def: ColumnDefault,
+  resolvedNativeType: string,
+): ColumnDefault {
+  if (def.kind !== 'function') {
+    return def;
+  }
+  return parsePostgresDefault(def.expression, resolvedNativeType) ?? def;
+}

package/src/core/descriptor-meta.ts

@@ -9,12 +9,14 @@ import {
 } from './authoring';
 import { postgresQualifyColumnType } from './codecs';
 import { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';
+import { postgresIndexTypes } from './index-types';
 import { DEFAULT_NAMESPACE_ID } from './namespace-ids';
 import { postgresCreateNamespace } from './postgres-schema';
 
 const postgresTargetDescriptorMetaBase = {
   ...postgresTargetDescriptorMetaRuntime,
   defaultNamespaceId: DEFAULT_NAMESPACE_ID,
+  indexTypes: postgresIndexTypes,
   authoring: {
     type: postgresAuthoringTypes,
     field: postgresAuthoringFieldPresets,

package/src/core/errors.ts

@@ -12,9 +12,10 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  * The `operation` argument is required so every throw site names the operation
  * that actually failed; a new operation cannot inherit a misattributed message.
  *
- * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
- * (data-transform query plan against wrong contract) because the missing
- * input is the stack itself, not the per-operation contract.
+ * Distinct from `MIGRATION.UNFILLED_PLACEHOLDER` (placeholder not filled)
+ * and `MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH` (data-transform query
+ * plan against wrong contract) because the missing input is the stack
+ * itself, not the per-operation contract.
  *
  * Lives in `@prisma-next/target-postgres/errors` rather than the shared
  * framework migration errors module because the failure is target-specific:
@@ -23,10 +24,9 @@ import { CliStructuredError } from '@prisma-next/errors/control';
  */
 export function errorPostgresMigrationStackMissing(operation: string): CliStructuredError {
   return new CliStructuredError(
-    '2007',
+    'MIGRATION.POSTGRES_CONTROL_STACK_MISSING',
     `PostgresMigration.${operation} requires a control adapter`,
     {
-      domain: 'MIG',
       why: `PostgresMigration.${operation} was invoked on an instance constructed without a ControlStack, so the stored controlAdapter is undefined and the operation cannot lower its plan.`,
       fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',
       meta: { operation },

package/src/core/index-types.ts

@@ -0,0 +1,15 @@
+import { defineIndexTypes } from '@prisma-next/sql-contract/index-types';
+import { type } from 'arktype';
+
+// Postgres's built-in index access methods (`CREATE INDEX ... USING <method>`).
+// Per-method option validation (e.g. `gin` operator classes) is out of scope;
+// every method accepts any options object until a later slice narrows it.
+export const postgresIndexTypes = defineIndexTypes()
+  .add('btree', { options: type('object') })
+  .add('hash', { options: type('object') })
+  .add('gin', { options: type('object') })
+  .add('gist', { options: type('object') })
+  .add('spgist', { options: type('object') })
+  .add('brin', { options: type('object') });
+
+export type IndexTypes = typeof postgresIndexTypes.IndexTypes;