@prisma-next/adapter-postgres 0.4.0-dev.9 → 0.4.2

package/dist/adapter-hNElNHo4.mjs

@@ -0,0 +1,60 @@
+import { t as renderLoweredSql } from "./sql-renderer-pEaSP82_.mjs";
+import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { codecDefinitions } from "@prisma-next/target-postgres/codecs";
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/core/adapter.ts
+const defaultCapabilities = Object.freeze({
+	postgres: {
+		orderBy: true,
+		limit: true,
+		lateral: true,
+		jsonAgg: true,
+		returning: true
+	},
+	sql: {
+		enums: true,
+		returning: true,
+		defaultInInsert: true
+	}
+});
+const parameterizedCodecs = Object.values(codecDefinitions).map((definition) => definition.codec).filter((codec) => codec.paramsSchema !== void 0).map((codec) => Object.freeze({
+	codecId: codec.id,
+	paramsSchema: codec.paramsSchema,
+	...ifDefined("init", codec.init)
+}));
+var PostgresAdapterImpl = class {
+	familyId = "sql";
+	targetId = "postgres";
+	profile;
+	codecRegistry = (() => {
+		const registry = createCodecRegistry();
+		for (const definition of Object.values(codecDefinitions)) registry.register(definition.codec);
+		return registry;
+	})();
+	constructor(options) {
+		this.profile = Object.freeze({
+			id: options?.profileId ?? "postgres/default@1",
+			target: "postgres",
+			capabilities: defaultCapabilities,
+			codecs: () => this.codecRegistry,
+			readMarkerStatement: () => ({
+				sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1",
+				params: [1]
+			})
+		});
+	}
+	parameterizedCodecs() {
+		return parameterizedCodecs;
+	}
+	lower(ast, context) {
+		return renderLoweredSql(ast, context.contract);
+	}
+};
+function createPostgresAdapter(options) {
+	return Object.freeze(new PostgresAdapterImpl(options));
+}
+
+//#endregion
+export { createPostgresAdapter as t };
+//# sourceMappingURL=adapter-hNElNHo4.mjs.map

package/dist/adapter-hNElNHo4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-hNElNHo4.mjs","names":["parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor>"],"sources":["../src/core/adapter.ts"],"sourcesContent":["import {\n  type Adapter,\n  type AdapterProfile,\n  type AnyQueryAst,\n  type CodecParamsDescriptor,\n  createCodecRegistry,\n  type LowererContext,\n} from '@prisma-next/sql-relational-core/ast';\nimport { codecDefinitions } from '@prisma-next/target-postgres/codecs';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { renderLoweredSql } from './sql-renderer';\nimport type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';\n\nconst defaultCapabilities = Object.freeze({\n  postgres: {\n    orderBy: true,\n    limit: true,\n    lateral: true,\n    jsonAgg: true,\n    returning: true,\n  },\n  sql: {\n    enums: true,\n    returning: true,\n    defaultInInsert: true,\n  },\n});\n\ntype AdapterCodec = (typeof codecDefinitions)[keyof typeof codecDefinitions]['codec'];\ntype ParameterizedCodec = AdapterCodec & {\n  readonly paramsSchema: NonNullable<AdapterCodec['paramsSchema']>;\n};\n\nconst parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor> = Object.values(codecDefinitions)\n  .map((definition) => definition.codec)\n  .filter((codec): codec is ParameterizedCodec => codec.paramsSchema !== undefined)\n  .map((codec) =>\n    Object.freeze({\n      codecId: codec.id,\n      paramsSchema: codec.paramsSchema,\n      ...ifDefined('init', codec.init),\n    }),\n  );\n\nclass PostgresAdapterImpl\n  implements Adapter<AnyQueryAst, PostgresContract, PostgresLoweredStatement>\n{\n  // These fields make the adapter instance structurally compatible with\n  // RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n\n  readonly profile: AdapterProfile<'postgres'>;\n  private readonly codecRegistry = (() => {\n    const registry = createCodecRegistry();\n    for (const definition of Object.values(codecDefinitions)) {\n      registry.register(definition.codec);\n    }\n    return registry;\n  })();\n\n  constructor(options?: PostgresAdapterOptions) {\n    this.profile = Object.freeze({\n      id: options?.profileId ?? 'postgres/default@1',\n      target: 'postgres',\n      capabilities: defaultCapabilities,\n      codecs: () => this.codecRegistry,\n      readMarkerStatement: () => ({\n        sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',\n        params: [1],\n      }),\n    });\n  }\n\n  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {\n    return parameterizedCodecs;\n  }\n\n  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement {\n    return renderLoweredSql(ast, context.contract);\n  }\n}\n\nexport function createPostgresAdapter(options?: PostgresAdapterOptions) {\n  return Object.freeze(new PostgresAdapterImpl(options));\n}\n"],"mappings":";;;;;;AAaA,MAAM,sBAAsB,OAAO,OAAO;CACxC,UAAU;EACR,SAAS;EACT,OAAO;EACP,SAAS;EACT,SAAS;EACT,WAAW;EACZ;CACD,KAAK;EACH,OAAO;EACP,WAAW;EACX,iBAAiB;EAClB;CACF,CAAC;AAOF,MAAMA,sBAA4D,OAAO,OAAO,iBAAiB,CAC9F,KAAK,eAAe,WAAW,MAAM,CACrC,QAAQ,UAAuC,MAAM,iBAAiB,OAAU,CAChF,KAAK,UACJ,OAAO,OAAO;CACZ,SAAS,MAAM;CACf,cAAc,MAAM;CACpB,GAAG,UAAU,QAAQ,MAAM,KAAK;CACjC,CAAC,CACH;AAEH,IAAM,sBAAN,MAEA;CAGE,AAAS,WAAW;CACpB,AAAS,WAAW;CAEpB,AAAS;CACT,AAAiB,uBAAuB;EACtC,MAAM,WAAW,qBAAqB;AACtC,OAAK,MAAM,cAAc,OAAO,OAAO,iBAAiB,CACtD,UAAS,SAAS,WAAW,MAAM;AAErC,SAAO;KACL;CAEJ,YAAY,SAAkC;AAC5C,OAAK,UAAU,OAAO,OAAO;GAC3B,IAAI,SAAS,aAAa;GAC1B,QAAQ;GACR,cAAc;GACd,cAAc,KAAK;GACnB,4BAA4B;IAC1B,KAAK;IACL,QAAQ,CAAC,EAAE;IACZ;GACF,CAAC;;CAGJ,sBAA4D;AAC1D,SAAO;;CAGT,MAAM,KAAkB,SAAqE;AAC3F,SAAO,iBAAiB,KAAK,QAAQ,SAAS;;;AAIlD,SAAgB,sBAAsB,SAAkC;AACtE,QAAO,OAAO,OAAO,IAAI,oBAAoB,QAAQ,CAAC"}

package/dist/adapter.d.mts

@@ -1,4 +1,4 @@
-import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-DxaTd7aP.mjs";
+import { c as PostgresContract, l as PostgresLoweredStatement, s as PostgresAdapterOptions } from "./types-CfRPdAk8.mjs";
 import { Adapter, AdapterProfile, AnyQueryAst, CodecParamsDescriptor, LowererContext } from "@prisma-next/sql-relational-core/ast";
 
 //#region src/core/adapter.d.ts
@@ -9,13 +9,7 @@ declare class PostgresAdapterImpl implements Adapter<AnyQueryAst, PostgresContra
   private readonly codecRegistry;
   constructor(options?: PostgresAdapterOptions);
   parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor>;
-  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): Readonly<{
-    profileId: string;
-    body: Readonly<{
-      sql: string;
-      params: unknown[];
-    }>;
-  }>;
+  lower(ast: AnyQueryAst, context: LowererContext<PostgresContract>): PostgresLoweredStatement;
 }
 declare function createPostgresAdapter(options?: PostgresAdapterOptions): Readonly<PostgresAdapterImpl>;
 //#endregion

package/dist/adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":[],"mappings":";;;;cAyFM,mBAAA,YACO,QAAQ,aAAa,kBAAkB;;EAD9C,SAAA,QAAA,EAAA,UACJ;EAAmB,SAAA,OAAA,EAOD,cAPC,CAAA,UAAA,CAAA;EAAa,iBAAA,aAAA;EAAkB,WAAA,CAAA,OAAA,CAAA,EAgB5B,sBAhB4B;EAOhC,mBAAA,CAAA,CAAA,EAsBK,aAtBL,CAsBmB,qBAtBnB,CAAA;EASI,KAAA,CAAA,GAAA,EAiBX,WAjBW,EAAA,OAAA,EAiBW,cAjBX,CAiB0B,gBAjB1B,CAAA,CAAA,EAiB2C,QAjB3C,CAAA;IAae,SAAA,EAAA,MAAA;IAAd,IAAA,UAAA,CAAA;MAIZ,GAAA,EAAA,MAAA;MAAqC,MAAA,EAAA,OAAA,EAAA;IAAf,CAAA,CAAA;;;AAjCtB,iBAumBG,qBAAA,CAvmBH,OAAA,CAAA,EAumBmC,sBAvmBnC,CAAA,EAumByD,QAvmBzD,CAumByD,mBAvmBzD,CAAA"}
+{"version":3,"file":"adapter.d.mts","names":[],"sources":["../src/core/adapter.ts"],"sourcesContent":[],"mappings":";;;;cA4CM,mBAAA,YACO,QAAQ,aAAa,kBAAkB;;EAD9C,SAAA,QAAA,EAAA,UACJ;EAAmB,SAAA,OAAA,EAOD,cAPC,CAAA,UAAA,CAAA;EAAa,iBAAA,aAAA;EAAkB,WAAA,CAAA,OAAA,CAAA,EAgB5B,sBAhB4B;EAOhC,mBAAA,CAAA,CAAA,EAsBK,aAtBL,CAsBmB,qBAtBnB,CAAA;EASI,KAAA,CAAA,GAAA,EAiBX,WAjBW,EAAA,OAAA,EAiBW,cAjBX,CAiB0B,gBAjB1B,CAAA,CAAA,EAiB8C,wBAjB9C;;AAaC,iBAST,qBAAA,CATS,OAAA,CAAA,EASuB,sBATvB,CAAA,EAS6C,QAT7C,CAS6C,mBAT7C,CAAA"}

package/dist/adapter.mjs

@@ -1,3 +1,3 @@
-import { t as createPostgresAdapter } from "./adapter-7pXt8ej9.mjs";
+import { t as createPostgresAdapter } from "./adapter-hNElNHo4.mjs";
 
 export { createPostgresAdapter };

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

@@ -1 +1 @@
-{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":[],"mappings":";;;;KAEK,6BAAA;;;AAFsB;AAc3B;;;;ACwBA;AAKA;AAUA;AAUa,KDjDD,kBAAA,GCoD6B;EAE5B,SAAA,WAG4B,CAAA,EAAA;IAE5B,SAG4B,OAAA,CAAA,EAAA,MAAA;IAE5B,SAAA,UAG4B,CAAA,EDhEf,6BCgEe;EAE5B,CAAA;EAKG,SAAA,UAAa,CAAA,EAAA,OAG1B;AAUH,CAAA;;;AA/Da,cAAA,UAG4B,EAAA;EAEzB,SAAA,OAAU,EAAA,WAAkB;EAU5B,SAAA,UAAa,EAAA,MAAA;AAU7B,CAAA;AAKa,iBAzBG,UAAA,CA4ByB,MAAA,EAAA,MAAA,CAAA,EA5BG,oBA4BH,GAAA;EAE5B,SAAA,UAG4B,EAAA;IAE5B,SAAA,MAG4B,EAAA,MAAA;EAE5B,CAAA;AAKb,CAAA;AAaa,iBAhDG,aAAA,CAmDyB,MAAA,EAAA,MAAA,CAAA,EAnDM,oBAmDN,GAAA;EAE5B,SAAA,UAAA,EAG4B;IAEzB,SAAU,MAAA,EAAA,MAAsB;EAUhC,CAAA;AAUhB,CAAA;AAKgB,cAzEH,UAyE8B,EAAA;EAU3B,SAAA,OAAY,EAAA,WAAkB;EAU9B,SAAA,UAAc,EAAA,MAAA;AAU9B,CAAA;AAKa,cAvGA,UA0G4B,EAAA;EA8CzB,SAAI,OAAA,EAAA,WAAU;EAId,SAAK,UAAA,EAAU,MAAA;AAI/B,CAAA;AAEU,cA7JG,UA6JH,EAAA;EACP,SAAA,OAAA,EAAA,WAAA;EAAgE,SAAA,UAAA,EAAA,MAAA;CAAM;AAQzD,cAjKH,YAiKa,EAAA;EACd,SAAA,OAAA,EAAA,aAAA;EAET,SAAA,UAAA,EAAA,QAAA;CAA2C;AAAQ,cA/JzC,YA+JyC,EAAA;;;;iBA1JtC,aAAA,qCAGb;;;;;;cAUU;;;;cAKA;;;;iBAKG,UAAA,sBAAgC;;;;;iBAUhC,YAAA,sBAAkC;;;;;cAUrC;;;;iBAKG,SAAA,kBAA2B;;;;;iBAU3B,YAAA,kBAA8B;;;;;iBAU9B,cAAA,sBAAoC;;;;;cAUvC;;;;cAKA;;;;iBAiDG,IAAA,UAAc,qBAAqB;iBAInC,KAAA,UAAe,qBAAqB;iBAIpC,uEAEN,SACP;;qBAAgE;;;iBAQnD,8CACJ,+BAET;oBAA2C"}
+{"version":3,"file":"column-types.d.mts","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":[],"mappings":";;;;KAEK,6BAAA;;;AAFsB;AAc3B;;;;ACwBA;AAKA;AAUA;AAUa,KDjDD,kBAAA,GCoD6B;EAE5B,SAAA,WAG4B,CAAA,EAAA;IAE5B,SAG4B,OAAA,CAAA,EAAA,MAAA;IAE5B,SAAA,UAG4B,CAAA,EDhEf,6BCgEe;EAE5B,CAAA;EAKG,SAAA,UAAa,CAAA,EAAA,OAG1B;AAUH,CAAA;;;AA/Da,cAAA,UAG4B,EAAA;EAEzB,SAAA,OAAU,EAAA,WAAkB;EAU5B,SAAA,UAAa,EAAA,MAAkB;AAU/C,CAAA;AAKa,iBAzBG,UAAA,CA4ByB,MAAA,EAAA,MAAA,CAAA,EA5BG,oBA4BH,GAAA;EAE5B,SAAA,UAG4B,EAAA;IAE5B,SAAA,MAG4B,EAAA,MAAA;EAE5B,CAAA;AAKb,CAAA;AAaa,iBAhDG,aAAA,CAmDyB,MAAA,EAAA,MAAA,CAAA,EAnDM,oBAmDN,GAAA;EAE5B,SAAA,UAAA,EAG4B;IAEzB,SAAU,MAAA,EAAA,MAAsB;EAUhC,CAAA;AAUhB,CAAA;AAKgB,cAzEH,UAyE8B,EAAA;EAU3B,SAAA,OAAY,EAAA,WAAkB;EAU9B,SAAA,UAAc,EAAA,MAAA;AAU9B,CAAA;AAKa,cAvGA,UA0G4B,EAAA;EA8CzB,SAAI,OAAA,EAAA,WAAU;EAId,SAAK,UAAA,EAAU,MAAA;AAI/B,CAAA;AAEU,cA7JG,UA6JH,EAAA;EACP,SAAA,OAAA,EAAA,WAAA;EAAgE,SAAA,UAAA,EAAA,MAAA;CAAM;AAQzD,cAjKH,YAiKa,EAAA;EACd,SAAA,OAAA,EAAA,aAAA;EAET,SAAA,UAAA,EAAA,QAAA;CAA2C;AAAQ,cA/JzC,YA+JyC,EAAA;;;;iBA1JtC,aAAA,qCAGb;;;;;;cAUU;;;;cAKA;;;;iBAKG,UAAA,sBAAgC;;;;;iBAUhC,YAAA,sBAAkC;;;;;cAUrC;;;;iBAKG,SAAA,kBAA2B;;;;;iBAU3B,YAAA,kBAA8B;;;;;iBAU9B,cAAA,sBAAoC;;;;;cAUvC;;;;cAKA;;;;iBAiDG,IAAA,UAAc,qBAAqB;iBAInC,KAAA,UAAe,qBAAqB;iBAIpC,uEAEN,SACP;;qBAAgE;;;iBAQnD,8CACJ,+BAET;oBAA2C"}

package/dist/column-types.mjs

@@ -1,4 +1,4 @@
-import { C as SQL_CHAR_CODEC_ID, O as SQL_VARCHAR_CODEC_ID, _ as PG_TIMESTAMPTZ_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIME_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, g as PG_TEXT_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_ENUM_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMP_CODEC_ID, x as PG_VARBIT_CODEC_ID, y as PG_TIMETZ_CODEC_ID } from "./codec-ids-BwjcIf74.mjs";
+import { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_ENUM_CODEC_ID, PG_FLOAT4_CODEC_ID, PG_FLOAT8_CODEC_ID, PG_INT2_CODEC_ID, PG_INT4_CODEC_ID, PG_INT8_CODEC_ID, PG_INTERVAL_CODEC_ID, PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID, PG_NUMERIC_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_VARBIT_CODEC_ID, SQL_CHAR_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
 
 //#region src/core/standard-schema.ts
 function isObjectLike(value) {

package/dist/column-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"column-types.mjs","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":["type UnknownRecord = Record<string, unknown>;\n\ntype StandardSchemaJsonSchemaField = {\n  readonly output?: unknown;\n};\n\n/**\n * Runtime view of the Standard Schema protocol.\n * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,\n * and `.expression` for an optional TypeScript type expression string (Arktype-specific).\n *\n * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads\n * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.\n */\nexport type StandardSchemaLike = {\n  readonly '~standard'?: {\n    readonly version?: number;\n    readonly jsonSchema?: StandardSchemaJsonSchemaField;\n  };\n  readonly expression?: unknown;\n};\n\nfunction isObjectLike(value: unknown): value is UnknownRecord {\n  return (typeof value === 'object' || typeof value === 'function') && value !== null;\n}\n\nfunction resolveOutputJsonSchemaField(schema: StandardSchemaLike): unknown {\n  const jsonSchema = schema['~standard']?.jsonSchema;\n  if (!jsonSchema) {\n    return undefined;\n  }\n\n  if (typeof jsonSchema.output === 'function') {\n    return jsonSchema.output({\n      target: 'draft-07',\n    });\n  }\n\n  return jsonSchema.output;\n}\n\nexport function extractStandardSchemaOutputJsonSchema(\n  schema: StandardSchemaLike,\n): UnknownRecord | undefined {\n  const outputSchema = resolveOutputJsonSchemaField(schema);\n  if (!isObjectLike(outputSchema)) {\n    return undefined;\n  }\n\n  return outputSchema;\n}\n\nexport function extractStandardSchemaTypeExpression(\n  schema: StandardSchemaLike,\n): string | undefined {\n  const expression = schema.expression;\n  if (typeof expression !== 'string') {\n    return undefined;\n  }\n\n  const trimmedExpression = expression.trim();\n  if (trimmedExpression.length === 0) {\n    return undefined;\n  }\n\n  return trimmedExpression;\n}\n\nexport function isStandardSchemaLike(value: unknown): value is StandardSchemaLike {\n  return isObjectLike(value) && isObjectLike((value as StandardSchemaLike)['~standard']);\n}\n","/**\n * Column type descriptors for Postgres adapter.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport type { StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '../core/codec-ids';\nimport {\n  extractStandardSchemaOutputJsonSchema,\n  extractStandardSchemaTypeExpression,\n  isStandardSchemaLike,\n  type StandardSchemaLike,\n} from '../core/standard-schema';\n\nexport const textColumn = {\n  codecId: PG_TEXT_CODEC_ID,\n  nativeType: 'text',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function charColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_CHAR_CODEC_ID,\n    nativeType: 'character',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varcharColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_VARCHAR_CODEC_ID,\n    nativeType: 'character varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport const int4Column = {\n  codecId: PG_INT4_CODEC_ID,\n  nativeType: 'int4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int2Column = {\n  codecId: PG_INT2_CODEC_ID,\n  nativeType: 'int2',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int8Column = {\n  codecId: PG_INT8_CODEC_ID,\n  nativeType: 'int8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float4Column = {\n  codecId: PG_FLOAT4_CODEC_ID,\n  nativeType: 'float4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float8Column = {\n  codecId: PG_FLOAT8_CODEC_ID,\n  nativeType: 'float8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function numericColumn(\n  precision: number,\n  scale?: number,\n): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly precision: number; readonly scale?: number };\n} {\n  return {\n    codecId: PG_NUMERIC_CODEC_ID,\n    nativeType: 'numeric',\n    typeParams: scale === undefined ? { precision } : { precision, scale },\n  } as const;\n}\n\nexport const timestampColumn = {\n  codecId: PG_TIMESTAMP_CODEC_ID,\n  nativeType: 'timestamp',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const timestamptzColumn = {\n  codecId: PG_TIMESTAMPTZ_CODEC_ID,\n  nativeType: 'timestamptz',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function timeColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIME_CODEC_ID,\n    nativeType: 'time',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport function timetzColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIMETZ_CODEC_ID,\n    nativeType: 'timetz',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const boolColumn = {\n  codecId: PG_BOOL_CODEC_ID,\n  nativeType: 'bool',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function bitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_BIT_CODEC_ID,\n    nativeType: 'bit',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varbitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_VARBIT_CODEC_ID,\n    nativeType: 'bit varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport function intervalColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_INTERVAL_CODEC_ID,\n    nativeType: 'interval',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const jsonColumn = {\n  codecId: PG_JSON_CODEC_ID,\n  nativeType: 'json',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const jsonbColumn = {\n  codecId: PG_JSONB_CODEC_ID,\n  nativeType: 'jsonb',\n} as const satisfies ColumnTypeDescriptor;\n\ntype JsonSchemaTypeParams = {\n  readonly schemaJson: Record<string, unknown>;\n  readonly type?: string;\n};\n\nfunction createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {\n  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);\n  if (!outputSchema) {\n    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');\n  }\n\n  const expression = extractStandardSchemaTypeExpression(schema);\n  if (expression) {\n    return { schemaJson: outputSchema, type: expression };\n  }\n\n  return { schemaJson: outputSchema };\n}\n\nfunction createJsonColumnFactory(\n  codecId: string,\n  nativeType: string,\n  staticDescriptor: ColumnTypeDescriptor,\n) {\n  return (schema?: StandardSchemaLike): ColumnTypeDescriptor => {\n    if (!schema) {\n      return staticDescriptor;\n    }\n\n    if (!isStandardSchemaLike(schema)) {\n      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);\n    }\n\n    return {\n      codecId,\n      nativeType,\n      typeParams: createJsonTypeParams(schema),\n    };\n  };\n}\n\nconst _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);\nconst _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);\n\nexport function json(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _json(schema);\n}\n\nexport function jsonb(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _jsonb(schema);\n}\n\nexport function enumType<const Values extends readonly string[]>(\n  name: string,\n  values: Values,\n): StorageTypeInstance & { readonly typeParams: { readonly values: Values } } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType: name,\n    typeParams: { values },\n  } as const;\n}\n\nexport function enumColumn<TypeName extends string>(\n  typeName: TypeName,\n  nativeType: string,\n): ColumnTypeDescriptor & { readonly typeRef: TypeName } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType,\n    typeRef: typeName,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"column-types.mjs","names":[],"sources":["../src/core/standard-schema.ts","../src/exports/column-types.ts"],"sourcesContent":["type UnknownRecord = Record<string, unknown>;\n\ntype StandardSchemaJsonSchemaField = {\n  readonly output?: unknown;\n};\n\n/**\n * Runtime view of the Standard Schema protocol.\n * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,\n * and `.expression` for an optional TypeScript type expression string (Arktype-specific).\n *\n * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads\n * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.\n */\nexport type StandardSchemaLike = {\n  readonly '~standard'?: {\n    readonly version?: number;\n    readonly jsonSchema?: StandardSchemaJsonSchemaField;\n  };\n  readonly expression?: unknown;\n};\n\nfunction isObjectLike(value: unknown): value is UnknownRecord {\n  return (typeof value === 'object' || typeof value === 'function') && value !== null;\n}\n\nfunction resolveOutputJsonSchemaField(schema: StandardSchemaLike): unknown {\n  const jsonSchema = schema['~standard']?.jsonSchema;\n  if (!jsonSchema) {\n    return undefined;\n  }\n\n  if (typeof jsonSchema.output === 'function') {\n    return jsonSchema.output({\n      target: 'draft-07',\n    });\n  }\n\n  return jsonSchema.output;\n}\n\nexport function extractStandardSchemaOutputJsonSchema(\n  schema: StandardSchemaLike,\n): UnknownRecord | undefined {\n  const outputSchema = resolveOutputJsonSchemaField(schema);\n  if (!isObjectLike(outputSchema)) {\n    return undefined;\n  }\n\n  return outputSchema;\n}\n\nexport function extractStandardSchemaTypeExpression(\n  schema: StandardSchemaLike,\n): string | undefined {\n  const expression = schema.expression;\n  if (typeof expression !== 'string') {\n    return undefined;\n  }\n\n  const trimmedExpression = expression.trim();\n  if (trimmedExpression.length === 0) {\n    return undefined;\n  }\n\n  return trimmedExpression;\n}\n\nexport function isStandardSchemaLike(value: unknown): value is StandardSchemaLike {\n  return isObjectLike(value) && isObjectLike((value as StandardSchemaLike)['~standard']);\n}\n","/**\n * Column type descriptors for Postgres adapter.\n *\n * These descriptors provide both codecId and nativeType for use in contract authoring.\n * They are derived from the same source of truth as codec definitions and manifests.\n */\n\nimport type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';\nimport type { StorageTypeInstance } from '@prisma-next/sql-contract/types';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_ENUM_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/target-postgres/codec-ids';\nimport {\n  extractStandardSchemaOutputJsonSchema,\n  extractStandardSchemaTypeExpression,\n  isStandardSchemaLike,\n  type StandardSchemaLike,\n} from '../core/standard-schema';\n\nexport const textColumn = {\n  codecId: PG_TEXT_CODEC_ID,\n  nativeType: 'text',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function charColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_CHAR_CODEC_ID,\n    nativeType: 'character',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varcharColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: SQL_VARCHAR_CODEC_ID,\n    nativeType: 'character varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport const int4Column = {\n  codecId: PG_INT4_CODEC_ID,\n  nativeType: 'int4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int2Column = {\n  codecId: PG_INT2_CODEC_ID,\n  nativeType: 'int2',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const int8Column = {\n  codecId: PG_INT8_CODEC_ID,\n  nativeType: 'int8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float4Column = {\n  codecId: PG_FLOAT4_CODEC_ID,\n  nativeType: 'float4',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const float8Column = {\n  codecId: PG_FLOAT8_CODEC_ID,\n  nativeType: 'float8',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function numericColumn(\n  precision: number,\n  scale?: number,\n): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly precision: number; readonly scale?: number };\n} {\n  return {\n    codecId: PG_NUMERIC_CODEC_ID,\n    nativeType: 'numeric',\n    typeParams: scale === undefined ? { precision } : { precision, scale },\n  } as const;\n}\n\nexport const timestampColumn = {\n  codecId: PG_TIMESTAMP_CODEC_ID,\n  nativeType: 'timestamp',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const timestamptzColumn = {\n  codecId: PG_TIMESTAMPTZ_CODEC_ID,\n  nativeType: 'timestamptz',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function timeColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIME_CODEC_ID,\n    nativeType: 'time',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport function timetzColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_TIMETZ_CODEC_ID,\n    nativeType: 'timetz',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const boolColumn = {\n  codecId: PG_BOOL_CODEC_ID,\n  nativeType: 'bool',\n} as const satisfies ColumnTypeDescriptor;\n\nexport function bitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_BIT_CODEC_ID,\n    nativeType: 'bit',\n    typeParams: { length },\n  } as const;\n}\n\nexport function varbitColumn(length: number): ColumnTypeDescriptor & {\n  readonly typeParams: { readonly length: number };\n} {\n  return {\n    codecId: PG_VARBIT_CODEC_ID,\n    nativeType: 'bit varying',\n    typeParams: { length },\n  } as const;\n}\n\nexport function intervalColumn(precision?: number): ColumnTypeDescriptor & {\n  readonly typeParams?: { readonly precision: number };\n} {\n  return {\n    codecId: PG_INTERVAL_CODEC_ID,\n    nativeType: 'interval',\n    ...(precision === undefined ? {} : { typeParams: { precision } }),\n  } as const;\n}\n\nexport const jsonColumn = {\n  codecId: PG_JSON_CODEC_ID,\n  nativeType: 'json',\n} as const satisfies ColumnTypeDescriptor;\n\nexport const jsonbColumn = {\n  codecId: PG_JSONB_CODEC_ID,\n  nativeType: 'jsonb',\n} as const satisfies ColumnTypeDescriptor;\n\ntype JsonSchemaTypeParams = {\n  readonly schemaJson: Record<string, unknown>;\n  readonly type?: string;\n};\n\nfunction createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {\n  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);\n  if (!outputSchema) {\n    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');\n  }\n\n  const expression = extractStandardSchemaTypeExpression(schema);\n  if (expression) {\n    return { schemaJson: outputSchema, type: expression };\n  }\n\n  return { schemaJson: outputSchema };\n}\n\nfunction createJsonColumnFactory(\n  codecId: string,\n  nativeType: string,\n  staticDescriptor: ColumnTypeDescriptor,\n) {\n  return (schema?: StandardSchemaLike): ColumnTypeDescriptor => {\n    if (!schema) {\n      return staticDescriptor;\n    }\n\n    if (!isStandardSchemaLike(schema)) {\n      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);\n    }\n\n    return {\n      codecId,\n      nativeType,\n      typeParams: createJsonTypeParams(schema),\n    };\n  };\n}\n\nconst _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);\nconst _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);\n\nexport function json(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _json(schema);\n}\n\nexport function jsonb(schema?: StandardSchemaLike): ColumnTypeDescriptor {\n  return _jsonb(schema);\n}\n\nexport function enumType<const Values extends readonly string[]>(\n  name: string,\n  values: Values,\n): StorageTypeInstance & { readonly typeParams: { readonly values: Values } } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType: name,\n    typeParams: { values },\n  } as const;\n}\n\nexport function enumColumn<TypeName extends string>(\n  typeName: TypeName,\n  nativeType: string,\n): ColumnTypeDescriptor & { readonly typeRef: TypeName } {\n  return {\n    codecId: PG_ENUM_CODEC_ID,\n    nativeType,\n    typeRef: typeName,\n  };\n}\n"],"mappings":"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"}

package/dist/control.d.mts

@@ -1,75 +1,8 @@
-import { ColumnDefault } from "@prisma-next/contract/types";
+import { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
+import { parsePostgresDefault } from "@prisma-next/target-postgres/default-normalizer";
+import { normalizeSchemaNativeType } from "@prisma-next/target-postgres/native-type-normalizer";
 import { SqlControlAdapterDescriptor } from "@prisma-next/family-sql/control";
 
-//#region src/core/sql-utils.d.ts
-
-/**
- * Shared SQL utility functions for the Postgres adapter.
- *
- * These functions handle safe SQL identifier and literal escaping
- * with security validations to prevent injection and encoding issues.
- */
-/**
- * Error thrown when an invalid SQL identifier or literal is detected.
- * Boundary layers map this to structured envelopes.
- */
-declare class SqlEscapeError extends Error {
-  readonly value: string;
-  readonly kind: 'identifier' | 'literal';
-  constructor(message: string, value: string, kind: 'identifier' | 'literal');
-}
-/**
- * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
- *
- * Security validations:
- * - Rejects null bytes which could cause truncation or unexpected behavior
- * - Rejects empty identifiers
- * - Warns on identifiers exceeding PostgreSQL's 63-character limit
- *
- * @throws {SqlEscapeError} If the identifier contains null bytes or is empty
- */
-declare function quoteIdentifier(identifier: string): string;
-/**
- * Escapes a string literal for safe use in SQL statements.
- *
- * Security validations:
- * - Rejects null bytes which could cause truncation or unexpected behavior
- *
- * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
- * Backslashes are treated as literal characters, not escape sequences.
- *
- * @throws {SqlEscapeError} If the value contains null bytes
- */
-declare function escapeLiteral(value: string): string;
-/**
- * Builds a qualified name (schema.object) with proper quoting.
- */
-declare function qualifyName(schemaName: string, objectName: string): string;
-//#endregion
-//#region src/core/default-normalizer.d.ts
-/**
- * Parses a raw Postgres column default expression into a normalized ColumnDefault.
- * This enables semantic comparison between contract defaults and introspected schema defaults.
- *
- * Used by the migration diff layer to normalize raw database defaults during comparison,
- * keeping the introspection layer focused on faithful data capture.
- *
- * @param rawDefault - Raw default expression from information_schema.columns.column_default
- * @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)
- * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
- */
-declare function parsePostgresDefault(rawDefault: string, nativeType?: string): ColumnDefault | undefined;
-//#endregion
-//#region src/core/control-adapter.d.ts
-
-/**
- * Normalizes a Postgres schema native type to its canonical form for comparison.
- *
- * Uses a pre-computed lookup map for simple prefix replacements (O(1))
- * and handles complex temporal type normalization separately.
- */
-declare function normalizeSchemaNativeType(nativeType: string): string;
-//#endregion
 //#region src/exports/control.d.ts
 declare const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'>;
 //#endregion

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/sql-utils.ts","../src/core/default-normalizer.ts","../src/core/control-adapter.ts","../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAWA;AA0BA;AAiCA;AAcA;;;cAzEa,cAAA,SAAuB,KAAA;ECuDpB,SAAA,KAAA,EAAA,MAAA;;;;ACsZhB;;;;AC/cgG;;;;;;iBH4BhF,eAAA;;;;;;;;;;;;iBAiCA,aAAA;;;;iBAcA,WAAA;;;;;;AAzEhB;AA0BA;AAiCA;AAcA;;;;AClBA;iBAAgB,oBAAA,2CAGb;;;;;;;;;;iBCmZa,yBAAA;;;cC7cV,2BAA2B"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":[],"mappings":";;;;;;cAgBM,2BAA2B"}

package/dist/control.mjs

@@ -1,137 +1,11 @@
-import { i as quoteIdentifier, n as escapeLiteral, r as qualifyName, t as SqlEscapeError } from "./sql-utils-CSfAGEwF.mjs";
-import { n as pgEnumControlHooks, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-DemWrTfB.mjs";
+import { t as renderLoweredSql } from "./sql-renderer-pEaSP82_.mjs";
+import { r as pgEnumControlHooks, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-RTDzyrae.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier } from "@prisma-next/target-postgres/sql-utils";
+import { parsePostgresDefault, parsePostgresDefault as parsePostgresDefault$1 } from "@prisma-next/target-postgres/default-normalizer";
+import { normalizeSchemaNativeType, normalizeSchemaNativeType as normalizeSchemaNativeType$1 } from "@prisma-next/target-postgres/native-type-normalizer";
 import { builtinGeneratorRegistryMetadata, resolveBuiltinGeneratedColumnDescriptor } from "@prisma-next/ids";
 
-//#region src/core/default-normalizer.ts
-/**
-* Pre-compiled regex patterns for performance.
-* These are compiled once at module load time rather than on each function call.
-*/
-const NEXTVAL_PATTERN = /^nextval\s*\(/i;
-const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-/**
-* Returns the canonical expression for a timestamp default function, or undefined
-* if the expression is not a recognized timestamp default.
-*
-* Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:
-* - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'
-* - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'
-*
-* These are semantically different in Postgres: now() returns the transaction
-* start time (constant within a transaction), while clock_timestamp() returns
-* the actual wall-clock time (can differ across rows in a single INSERT).
-*/
-function canonicalizeTimestampDefault(expr) {
-	if (NOW_FUNCTION_PATTERN.test(expr)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return "clock_timestamp()";
-	if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return void 0;
-	let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, "").trim();
-	if (inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1).trim();
-	if (NOW_FUNCTION_PATTERN.test(inner)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return "clock_timestamp()";
-	inner = inner.replace(TEXT_CAST_SUFFIX, "").trim();
-	if (NOW_LITERAL_PATTERN.test(inner)) return "now()";
-}
-/**
-* Parses a raw Postgres column default expression into a normalized ColumnDefault.
-* This enables semantic comparison between contract defaults and introspected schema defaults.
-*
-* Used by the migration diff layer to normalize raw database defaults during comparison,
-* keeping the introspection layer focused on faithful data capture.
-*
-* @param rawDefault - Raw default expression from information_schema.columns.column_default
-* @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)
-* @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
-*/
-function parsePostgresDefault(rawDefault, nativeType) {
-	const trimmed = rawDefault.trim();
-	const normalizedType = nativeType?.toLowerCase();
-	const isBigInt = normalizedType === "bigint" || normalizedType === "int8";
-	if (NEXTVAL_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "autoincrement()"
-	};
-	const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-	if (canonicalTimestamp) return {
-		kind: "function",
-		expression: canonicalTimestamp
-	};
-	if (UUID_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "gen_random_uuid()"
-	};
-	if (UUID_OSSP_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "gen_random_uuid()"
-	};
-	if (NULL_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: null
-	};
-	if (TRUE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: true
-	};
-	if (FALSE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: false
-	};
-	if (NUMERIC_PATTERN.test(trimmed)) {
-		const num = Number(trimmed);
-		if (!Number.isFinite(num)) return void 0;
-		if (isBigInt && !Number.isSafeInteger(num)) return {
-			kind: "literal",
-			value: trimmed
-		};
-		return {
-			kind: "literal",
-			value: num
-		};
-	}
-	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-	if (stringMatch?.[1] !== void 0) {
-		const unescaped = stringMatch[1].replace(/''/g, "'");
-		if (normalizedType === "json" || normalizedType === "jsonb") try {
-			return {
-				kind: "literal",
-				value: JSON.parse(unescaped)
-			};
-		} catch {}
-		if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {
-			const num = Number(unescaped);
-			if (Number.isSafeInteger(num)) return {
-				kind: "literal",
-				value: num
-			};
-			return {
-				kind: "literal",
-				value: unescaped
-			};
-		}
-		return {
-			kind: "literal",
-			value: unescaped
-		};
-	}
-	return {
-		kind: "function",
-		expression: trimmed
-	};
-}
-
-//#endregion
 //#region src/core/control-adapter.ts
 /**
 * Postgres control plane adapter for control-plane operations like introspection.
@@ -144,13 +18,24 @@ var PostgresControlAdapter = class {
 	* Target-specific normalizer for raw Postgres default expressions.
 	* Used by schema verification to normalize raw defaults before comparison.
 	*/
-	normalizeDefault = parsePostgresDefault;
+	normalizeDefault = parsePostgresDefault$1;
 	/**
 	* Target-specific normalizer for Postgres schema native type names.
 	* Used by schema verification to normalize introspected type names
 	* before comparison with contract native types.
 	*/
-	normalizeNativeType = normalizeSchemaNativeType;
+	normalizeNativeType = normalizeSchemaNativeType$1;
+	/**
+	* Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
+	*
+	* Delegates to the shared `renderLoweredSql` renderer so the control adapter
+	* emits byte-identical SQL to `PostgresAdapterImpl.lower()` for the same AST
+	* and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
+	* without instantiating the runtime adapter.
+	*/
+	lower(ast, context) {
+		return renderLoweredSql(ast, context.contract);
+	}
 	/**
 	* Introspects a Postgres database schema and returns a raw SqlSchemaIR.
 	*
@@ -407,32 +292,6 @@ var PostgresControlAdapter = class {
 		return ((await driver.query("SELECT version() AS version", [])).rows[0]?.version ?? "").match(/PostgreSQL (\d+\.\d+)/)?.[1] ?? "unknown";
 	}
 };
-/**
-* Pre-computed lookup map for simple prefix-based type normalization.
-* Maps short Postgres type names to their canonical SQL names.
-* Using a Map for O(1) lookup instead of multiple startsWith checks.
-*/
-const TYPE_PREFIX_MAP = new Map([
-	["varchar", "character varying"],
-	["bpchar", "character"],
-	["varbit", "bit varying"]
-]);
-/**
-* Normalizes a Postgres schema native type to its canonical form for comparison.
-*
-* Uses a pre-computed lookup map for simple prefix replacements (O(1))
-* and handles complex temporal type normalization separately.
-*/
-function normalizeSchemaNativeType(nativeType) {
-	const trimmed = nativeType.trim();
-	for (const [prefix, replacement] of TYPE_PREFIX_MAP) if (trimmed.startsWith(prefix)) return replacement + trimmed.slice(prefix.length);
-	if (trimmed.includes(" with time zone")) {
-		if (trimmed.startsWith("timestamp")) return `timestamptz${trimmed.slice(9).replace(" with time zone", "")}`;
-		if (trimmed.startsWith("time")) return `timetz${trimmed.slice(4).replace(" with time zone", "")}`;
-	}
-	if (trimmed.includes(" without time zone")) return trimmed.replace(" without time zone", "");
-	return trimmed;
-}
 function normalizeFormattedType(formattedType, dataType, udtName) {
 	if (formattedType === "integer") return "int4";
 	if (formattedType === "smallint") return "int2";
@@ -738,7 +597,7 @@ const postgresAdapterDescriptor = {
 		defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),
 		generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors()
 	},
-	create() {
+	create(_stack) {
 		return new PostgresControlAdapter();
 	}
 };