@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/column-types-BH-MU6uU.d.mts

@@ -0,0 +1,108 @@
+import { ColumnTypeDescriptor } from "@prisma/orm-framework/components/codec";
+//#region ../../../3-targets/6-adapters/postgres/dist/column-types.d.mts
+//#region src/exports/column-types.d.ts
+declare const textColumn: {
+  readonly codecId: "pg/text@1";
+  readonly nativeType: "text";
+};
+declare function charColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+declare function varcharColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+declare const int4Column: {
+  readonly codecId: "pg/int4@1";
+  readonly nativeType: "int4";
+};
+declare const int2Column: {
+  readonly codecId: "pg/int2@1";
+  readonly nativeType: "int2";
+};
+declare const int8Column: {
+  readonly codecId: "pg/int8@1";
+  readonly nativeType: "int8";
+};
+declare const float4Column: {
+  readonly codecId: "pg/float4@1";
+  readonly nativeType: "float4";
+};
+declare const float8Column: {
+  readonly codecId: "pg/float8@1";
+  readonly nativeType: "float8";
+};
+declare function numericColumn(precision: number, scale?: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly precision: number;
+    readonly scale?: number;
+  };
+};
+declare const timestampColumn: {
+  readonly codecId: "pg/timestamp@1";
+  readonly nativeType: "timestamp";
+};
+declare const timestamptzColumn: {
+  readonly codecId: "pg/timestamptz@1";
+  readonly nativeType: "timestamptz";
+};
+declare function timeColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: {
+    readonly precision: number;
+  };
+};
+declare function timetzColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: {
+    readonly precision: number;
+  };
+};
+declare const boolColumn: {
+  readonly codecId: "pg/bool@1";
+  readonly nativeType: "bool";
+};
+declare function bitColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+declare function varbitColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: {
+    readonly length: number;
+  };
+};
+/**
+ * Postgres `bytea` column descriptor — variable-length binary string.
+ *
+ * Round-trips as `Uint8Array` on the JS side. The pg wire-protocol text encoding (`\x` followed by hex-encoded bytes, canonical for Postgres ≥ 9.0) and binary encoding are both handled by the underlying driver; the codec only normalizes the JS-side representation to a plain `Uint8Array` view.
+ */
+declare const byteaColumn: {
+  readonly codecId: "pg/bytea@1";
+  readonly nativeType: "bytea";
+};
+declare function intervalColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: {
+    readonly precision: number;
+  };
+};
+/**
+ * Postgres `json` column descriptor — untyped raw JSON.
+ *
+ * For schema-typed JSON columns, use the per-library extension package (`@internal/extension-arktype-json` ships `arktypeJson(schema)` for arktype). The schema-accepting `json(schema)` / `jsonb(schema)` overloads previously shipped from this module retired in Phase C of the codec-registry-unification project — see spec § AC-7.
+ */
+declare const jsonColumn: {
+  readonly codecId: "pg/json@1";
+  readonly nativeType: "json";
+};
+/**
+ * Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement note as {@link jsonColumn}.
+ */
+declare const jsonbColumn: {
+  readonly codecId: "pg/jsonb@1";
+  readonly nativeType: "jsonb";
+};
+//#endregion
+export { timestamptzColumn as _, float4Column as a, varcharColumn as b, int4Column as c, jsonColumn as d, jsonbColumn as f, timestampColumn as g, timeColumn as h, charColumn as i, int8Column as l, textColumn as m, boolColumn as n, float8Column as o, numericColumn as p, byteaColumn as r, int2Column as s, bitColumn as t, intervalColumn as u, timetzColumn as v, varbitColumn as y };
+//# sourceMappingURL=column-types-BH-MU6uU.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"column-types-BH-MU6uU.d.mts","names":[],"sources":["../../../../3-targets/6-adapters/postgres/dist/column-types.d.mts"],"mappings":";;;cAEc;WACH;WACA;;iBAEM,WAAW,iBAAiB;WAClC;aACE;;;iBAGI,cAAc,iBAAiB;WACrC;aACE;;;cAGC;WACH;WACA;;cAEG;WACH;WACA;;cAEG;WACH;WACA;;cAEG;WACH;WACA;;cAEG;WACH;WACA;;iBAEM,cAAc,mBAAmB,iBAAiB;WACxD;aACE;aACA;;;cAGC;WACH;WACA;;cAEG;WACH;WACA;;iBAEM,WAAW,qBAAqB;WACtC;aACE;;;iBAGI,aAAa,qBAAqB;WACxC;aACE;;;cAGC;WACH;WACA;;iBAEM,UAAU,iBAAiB;WACjC;aACE;;;iBAGI,aAAa,iBAAiB;WACpC;aACE;;;;;;;;cAQC;WACH;WACA;;iBAEM,eAAe,qBAAqB;WAC1C;aACE;;;;;;;;cAQC;WACH;WACA;;;;;cAKG;WACH;WACA"}

package/dist/column-types-CwAyCgp2.mjs

@@ -0,0 +1,126 @@
+import { C as PG_TIMETZ_CODEC_ID, E as PG_VARBIT_CODEC_ID, N as SQL_VARCHAR_CODEC_ID, O as SQL_CHAR_CODEC_ID, S as PG_TIMESTAMP_CODEC_ID, _ as PG_JSON_CODEC_ID, b as PG_TEXT_CODEC_ID, c as PG_FLOAT8_CODEC_ID, d as PG_INT2_CODEC_ID, f as PG_INT4_CODEC_ID, g as PG_JSONB_CODEC_ID, m as PG_INTERVAL_CODEC_ID, n as PG_BOOL_CODEC_ID, p as PG_INT8_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT4_CODEC_ID, t as PG_BIT_CODEC_ID, v as PG_NUMERIC_CODEC_ID, w as PG_TIME_CODEC_ID, x as PG_TIMESTAMPTZ_CODEC_ID } from "./codec-ids-tX7Svtz--BuOfRaVU.mjs";
+//#region ../../../3-targets/6-adapters/postgres/dist/column-types.mjs
+const textColumn = {
+	codecId: PG_TEXT_CODEC_ID,
+	nativeType: "text"
+};
+function charColumn(length) {
+	return {
+		codecId: SQL_CHAR_CODEC_ID,
+		nativeType: "character",
+		typeParams: { length }
+	};
+}
+function varcharColumn(length) {
+	return {
+		codecId: SQL_VARCHAR_CODEC_ID,
+		nativeType: "character varying",
+		typeParams: { length }
+	};
+}
+const int4Column = {
+	codecId: PG_INT4_CODEC_ID,
+	nativeType: "int4"
+};
+const int2Column = {
+	codecId: PG_INT2_CODEC_ID,
+	nativeType: "int2"
+};
+const int8Column = {
+	codecId: PG_INT8_CODEC_ID,
+	nativeType: "int8"
+};
+const float4Column = {
+	codecId: PG_FLOAT4_CODEC_ID,
+	nativeType: "float4"
+};
+const float8Column = {
+	codecId: PG_FLOAT8_CODEC_ID,
+	nativeType: "float8"
+};
+function numericColumn(precision, scale) {
+	return {
+		codecId: PG_NUMERIC_CODEC_ID,
+		nativeType: "numeric",
+		typeParams: scale === void 0 ? { precision } : {
+			precision,
+			scale
+		}
+	};
+}
+const timestampColumn = {
+	codecId: PG_TIMESTAMP_CODEC_ID,
+	nativeType: "timestamp"
+};
+const timestamptzColumn = {
+	codecId: PG_TIMESTAMPTZ_CODEC_ID,
+	nativeType: "timestamptz"
+};
+function timeColumn(precision) {
+	return {
+		codecId: PG_TIME_CODEC_ID,
+		nativeType: "time",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+function timetzColumn(precision) {
+	return {
+		codecId: PG_TIMETZ_CODEC_ID,
+		nativeType: "timetz",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+const boolColumn = {
+	codecId: PG_BOOL_CODEC_ID,
+	nativeType: "bool"
+};
+function bitColumn(length) {
+	return {
+		codecId: PG_BIT_CODEC_ID,
+		nativeType: "bit",
+		typeParams: { length }
+	};
+}
+function varbitColumn(length) {
+	return {
+		codecId: PG_VARBIT_CODEC_ID,
+		nativeType: "bit varying",
+		typeParams: { length }
+	};
+}
+/**
+* Postgres `bytea` column descriptor — variable-length binary string.
+*
+* Round-trips as `Uint8Array` on the JS side. The pg wire-protocol text encoding (`\x` followed by hex-encoded bytes, canonical for Postgres ≥ 9.0) and binary encoding are both handled by the underlying driver; the codec only normalizes the JS-side representation to a plain `Uint8Array` view.
+*/
+const byteaColumn = {
+	codecId: PG_BYTEA_CODEC_ID,
+	nativeType: "bytea"
+};
+function intervalColumn(precision) {
+	return {
+		codecId: PG_INTERVAL_CODEC_ID,
+		nativeType: "interval",
+		...precision === void 0 ? {} : { typeParams: { precision } }
+	};
+}
+/**
+* Postgres `json` column descriptor — untyped raw JSON.
+*
+* For schema-typed JSON columns, use the per-library extension package (`@internal/extension-arktype-json` ships `arktypeJson(schema)` for arktype). The schema-accepting `json(schema)` / `jsonb(schema)` overloads previously shipped from this module retired in Phase C of the codec-registry-unification project — see spec § AC-7.
+*/
+const jsonColumn = {
+	codecId: PG_JSON_CODEC_ID,
+	nativeType: "json"
+};
+/**
+* Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement note as {@link jsonColumn}.
+*/
+const jsonbColumn = {
+	codecId: PG_JSONB_CODEC_ID,
+	nativeType: "jsonb"
+};
+//#endregion
+export { timestamptzColumn as _, float4Column as a, varcharColumn as b, int4Column as c, jsonColumn as d, jsonbColumn as f, timestampColumn as g, timeColumn as h, charColumn as i, int8Column as l, textColumn as m, boolColumn as n, float8Column as o, numericColumn as p, byteaColumn as r, int2Column as s, bitColumn as t, intervalColumn as u, timetzColumn as v, varbitColumn as y };
+
+//# sourceMappingURL=column-types-CwAyCgp2.mjs.map

package/dist/column-types-CwAyCgp2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-types-CwAyCgp2.mjs","names":[],"sources":["../../../../3-targets/6-adapters/postgres/dist/column-types.mjs"],"sourcesContent":["import { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_BYTEA_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 \"@internal/target-postgres/codec-ids\";\n//#region src/exports/column-types.ts\nconst textColumn = {\n\tcodecId: PG_TEXT_CODEC_ID,\n\tnativeType: \"text\"\n};\nfunction charColumn(length) {\n\treturn {\n\t\tcodecId: SQL_CHAR_CODEC_ID,\n\t\tnativeType: \"character\",\n\t\ttypeParams: { length }\n\t};\n}\nfunction varcharColumn(length) {\n\treturn {\n\t\tcodecId: SQL_VARCHAR_CODEC_ID,\n\t\tnativeType: \"character varying\",\n\t\ttypeParams: { length }\n\t};\n}\nconst int4Column = {\n\tcodecId: PG_INT4_CODEC_ID,\n\tnativeType: \"int4\"\n};\nconst int2Column = {\n\tcodecId: PG_INT2_CODEC_ID,\n\tnativeType: \"int2\"\n};\nconst int8Column = {\n\tcodecId: PG_INT8_CODEC_ID,\n\tnativeType: \"int8\"\n};\nconst float4Column = {\n\tcodecId: PG_FLOAT4_CODEC_ID,\n\tnativeType: \"float4\"\n};\nconst float8Column = {\n\tcodecId: PG_FLOAT8_CODEC_ID,\n\tnativeType: \"float8\"\n};\nfunction numericColumn(precision, scale) {\n\treturn {\n\t\tcodecId: PG_NUMERIC_CODEC_ID,\n\t\tnativeType: \"numeric\",\n\t\ttypeParams: scale === void 0 ? { precision } : {\n\t\t\tprecision,\n\t\t\tscale\n\t\t}\n\t};\n}\nconst timestampColumn = {\n\tcodecId: PG_TIMESTAMP_CODEC_ID,\n\tnativeType: \"timestamp\"\n};\nconst timestamptzColumn = {\n\tcodecId: PG_TIMESTAMPTZ_CODEC_ID,\n\tnativeType: \"timestamptz\"\n};\nfunction timeColumn(precision) {\n\treturn {\n\t\tcodecId: PG_TIME_CODEC_ID,\n\t\tnativeType: \"time\",\n\t\t...precision === void 0 ? {} : { typeParams: { precision } }\n\t};\n}\nfunction timetzColumn(precision) {\n\treturn {\n\t\tcodecId: PG_TIMETZ_CODEC_ID,\n\t\tnativeType: \"timetz\",\n\t\t...precision === void 0 ? {} : { typeParams: { precision } }\n\t};\n}\nconst boolColumn = {\n\tcodecId: PG_BOOL_CODEC_ID,\n\tnativeType: \"bool\"\n};\nfunction bitColumn(length) {\n\treturn {\n\t\tcodecId: PG_BIT_CODEC_ID,\n\t\tnativeType: \"bit\",\n\t\ttypeParams: { length }\n\t};\n}\nfunction varbitColumn(length) {\n\treturn {\n\t\tcodecId: PG_VARBIT_CODEC_ID,\n\t\tnativeType: \"bit varying\",\n\t\ttypeParams: { length }\n\t};\n}\n/**\n* Postgres `bytea` column descriptor — variable-length binary string.\n*\n* Round-trips as `Uint8Array` on the JS side. The pg wire-protocol text encoding (`\\x` followed by hex-encoded bytes, canonical for Postgres ≥ 9.0) and binary encoding are both handled by the underlying driver; the codec only normalizes the JS-side representation to a plain `Uint8Array` view.\n*/\nconst byteaColumn = {\n\tcodecId: PG_BYTEA_CODEC_ID,\n\tnativeType: \"bytea\"\n};\nfunction intervalColumn(precision) {\n\treturn {\n\t\tcodecId: PG_INTERVAL_CODEC_ID,\n\t\tnativeType: \"interval\",\n\t\t...precision === void 0 ? {} : { typeParams: { precision } }\n\t};\n}\n/**\n* Postgres `json` column descriptor — untyped raw JSON.\n*\n* For schema-typed JSON columns, use the per-library extension package (`@internal/extension-arktype-json` ships `arktypeJson(schema)` for arktype). The schema-accepting `json(schema)` / `jsonb(schema)` overloads previously shipped from this module retired in Phase C of the codec-registry-unification project — see spec § AC-7.\n*/\nconst jsonColumn = {\n\tcodecId: PG_JSON_CODEC_ID,\n\tnativeType: \"json\"\n};\n/**\n* Postgres `jsonb` column descriptor — untyped raw JSONB. Same retirement note as {@link jsonColumn}.\n*/\nconst jsonbColumn = {\n\tcodecId: PG_JSONB_CODEC_ID,\n\tnativeType: \"jsonb\"\n};\n//#endregion\nexport { bitColumn, boolColumn, byteaColumn, charColumn, float4Column, float8Column, int2Column, int4Column, int8Column, intervalColumn, jsonColumn, jsonbColumn, numericColumn, textColumn, timeColumn, timestampColumn, timestamptzColumn, timetzColumn, varbitColumn, varcharColumn };\n\n//# sourceMappingURL=column-types.mjs.map"],"mappings":";;AAEA,MAAM,aAAa;CAClB,SAAS;CACT,YAAY;AACb;AACA,SAAS,WAAW,QAAQ;CAC3B,OAAO;EACN,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,OAAO;CACtB;AACD;AACA,SAAS,cAAc,QAAQ;CAC9B,OAAO;EACN,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,OAAO;CACtB;AACD;AACA,MAAM,aAAa;CAClB,SAAS;CACT,YAAY;AACb;AACA,MAAM,aAAa;CAClB,SAAS;CACT,YAAY;AACb;AACA,MAAM,aAAa;CAClB,SAAS;CACT,YAAY;AACb;AACA,MAAM,eAAe;CACpB,SAAS;CACT,YAAY;AACb;AACA,MAAM,eAAe;CACpB,SAAS;CACT,YAAY;AACb;AACA,SAAS,cAAc,WAAW,OAAO;CACxC,OAAO;EACN,SAAS;EACT,YAAY;EACZ,YAAY,UAAU,KAAK,IAAI,EAAE,UAAU,IAAI;GAC9C;GACA;EACD;CACD;AACD;AACA,MAAM,kBAAkB;CACvB,SAAS;CACT,YAAY;AACb;AACA,MAAM,oBAAoB;CACzB,SAAS;CACT,YAAY;AACb;AACA,SAAS,WAAW,WAAW;CAC9B,OAAO;EACN,SAAS;EACT,YAAY;EACZ,GAAG,cAAc,KAAK,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE;CAC5D;AACD;AACA,SAAS,aAAa,WAAW;CAChC,OAAO;EACN,SAAS;EACT,YAAY;EACZ,GAAG,cAAc,KAAK,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE;CAC5D;AACD;AACA,MAAM,aAAa;CAClB,SAAS;CACT,YAAY;AACb;AACA,SAAS,UAAU,QAAQ;CAC1B,OAAO;EACN,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,OAAO;CACtB;AACD;AACA,SAAS,aAAa,QAAQ;CAC7B,OAAO;EACN,SAAS;EACT,YAAY;EACZ,YAAY,EAAE,OAAO;CACtB;AACD;;;;;;AAMA,MAAM,cAAc;CACnB,SAAS;CACT,YAAY;AACb;AACA,SAAS,eAAe,WAAW;CAClC,OAAO;EACN,SAAS;EACT,YAAY;EACZ,GAAG,cAAc,KAAK,IAAI,CAAC,IAAI,EAAE,YAAY,EAAE,UAAU,EAAE;CAC5D;AACD;;;;;;AAMA,MAAM,aAAa;CAClB,SAAS;CACT,YAAY;AACb;;;;AAIA,MAAM,cAAc;CACnB,SAAS;CACT,YAAY;AACb"}

package/dist/contract-free-BZUS18FU.mjs

@@ -0,0 +1,118 @@
+import { b as PG_TEXT_CODEC_ID, f as PG_INT4_CODEC_ID, g as PG_JSONB_CODEC_ID, p as PG_INT8_CODEC_ID, x as PG_TIMESTAMPTZ_CODEC_ID, y as PG_TEXT_ARRAY_CODEC_ID } from "./codec-ids-tX7Svtz--BuOfRaVU.mjs";
+import { l as PostgresTableSource } from "./postgres-schema-KSzLDONj-CsXGoY8b.mjs";
+import { f as createSchema, p as createTable } from "./ddl-BdP4q3KY-Duef4uHw.mjs";
+import { col, fn, lit, table } from "@prisma/orm-family-sql/relational-core/contract-free";
+import { APP_SPACE_ID } from "@prisma/orm-framework/components/control";
+//#region ../../../3-targets/3-targets/postgres/dist/contract-free.mjs
+const desc = (codecId, opts) => ({
+	codecId,
+	nullable: opts?.nullable ?? false
+});
+const text = (opts) => desc(PG_TEXT_CODEC_ID, opts);
+const int4 = (opts) => desc(PG_INT4_CODEC_ID, opts);
+const int8 = (opts) => desc(PG_INT8_CODEC_ID, opts);
+const jsonb = (opts) => desc(PG_JSONB_CODEC_ID, opts);
+const textArray = (opts) => desc(PG_TEXT_ARRAY_CODEC_ID, opts);
+const timestamptz = (opts) => desc(PG_TIMESTAMPTZ_CODEC_ID, opts);
+/**
+* Declare a PostgreSQL control-plane table with a typed column schema. Wraps
+* the generic `table()` factory with a `PostgresTableSource` so the renderer
+* qualifies the table name with the optional schema prefix.
+*
+* ```ts
+* const marker = pgTable(
+*   { name: 'marker', schema: 'prisma_contract' },
+*   { space: text(), core_hash: text(), updated_at: timestamptz() },
+* );
+* ```
+*/
+function pgTable(source, columns) {
+	return table(new PostgresTableSource(source), columns);
+}
+const markerColumns = [
+	col("space", "text", {
+		notNull: true,
+		primaryKey: true,
+		default: lit(APP_SPACE_ID)
+	}),
+	col("core_hash", "text", { notNull: true }),
+	col("profile_hash", "text", { notNull: true }),
+	col("contract_json", "jsonb"),
+	col("canonical_version", "int"),
+	col("updated_at", "timestamptz", {
+		notNull: true,
+		default: fn("now()")
+	}),
+	col("app_tag", "text"),
+	col("meta", "jsonb", {
+		notNull: true,
+		default: lit("{}")
+	}),
+	col("invariants", "text[]", {
+		notNull: true,
+		default: lit("{}")
+	})
+];
+const ledgerColumns = [
+	col("id", "bigserial", { primaryKey: true }),
+	col("created_at", "timestamptz", {
+		notNull: true,
+		default: fn("now()")
+	}),
+	col("space", "text", { notNull: true }),
+	col("migration_name", "text", { notNull: true }),
+	col("migration_hash", "text", { notNull: true }),
+	col("origin_core_hash", "text"),
+	col("origin_profile_hash", "text"),
+	col("destination_core_hash", "text", { notNull: true }),
+	col("destination_profile_hash", "text"),
+	col("operations", "jsonb", { notNull: true })
+];
+const contractColumns = [
+	col("core_hash", "text", {
+		notNull: true,
+		primaryKey: true
+	}),
+	col("created_at", "timestamptz", {
+		notNull: true,
+		default: fn("now()")
+	}),
+	col("contract_json", "jsonb", { notNull: true })
+];
+const markerTable = createTable({
+	schema: "prisma_contract",
+	table: "marker",
+	ifNotExists: true,
+	columns: markerColumns
+});
+const ledgerTable = createTable({
+	schema: "prisma_contract",
+	table: "ledger",
+	ifNotExists: true,
+	columns: ledgerColumns
+});
+const contractTable = createTable({
+	schema: "prisma_contract",
+	table: "contract",
+	ifNotExists: true,
+	columns: contractColumns
+});
+const controlSchema = createSchema({
+	schema: "prisma_contract",
+	ifNotExists: true
+});
+function buildSignMarkerBootstrapQueries() {
+	return [controlSchema, markerTable];
+}
+function buildControlTableBootstrapQueries() {
+	return [
+		controlSchema,
+		markerTable,
+		ledgerTable,
+		contractTable
+	];
+}
+//#endregion
+export { jsonb as a, textArray as c, int8 as i, timestamptz as l, buildSignMarkerBootstrapQueries as n, pgTable as o, int4 as r, text as s, buildControlTableBootstrapQueries as t };
+
+//# sourceMappingURL=contract-free-BZUS18FU.mjs.map

package/dist/contract-free-BZUS18FU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-free-BZUS18FU.mjs","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/contract-free.mjs"],"sourcesContent":["import { b as PG_TEXT_CODEC_ID, f as PG_INT4_CODEC_ID, g as PG_JSONB_CODEC_ID, p as PG_INT8_CODEC_ID, x as PG_TIMESTAMPTZ_CODEC_ID, y as PG_TEXT_ARRAY_CODEC_ID } from \"./codec-ids-tX7Svtz-.mjs\";\nimport { u as PostgresTableSource } from \"./postgres-schema-KSzLDONj.mjs\";\nimport { A as toRegclass, D as tableExistsAst, E as rlsPolicyExistsAst, O as tableIsEmptyAst, T as rlsEnabledAst, _ as columnNullabilityAst, b as extensionExistsAst, c as createTable, d as dropDefaultAction, g as columnExistsAst, h as columnDefaultAst, i as alterTable, k as tablePrimaryKeyAst, s as createSchema, t as addColumnAction, v as columnTypeAst, w as noNullValuesAst, x as indexExistsAst, y as constraintExistsAst } from \"./ddl-BdP4q3KY.mjs\";\nimport { col, fn, lit, table } from \"@internal/sql-relational-core/contract-free\";\nimport { APP_SPACE_ID } from \"@internal/framework-components/control\";\n//#region src/contract-free/columns.ts\nconst desc = (codecId, opts) => ({\n\tcodecId,\n\tnullable: opts?.nullable ?? false\n});\nconst text = (opts) => desc(PG_TEXT_CODEC_ID, opts);\nconst int4 = (opts) => desc(PG_INT4_CODEC_ID, opts);\nconst int8 = (opts) => desc(PG_INT8_CODEC_ID, opts);\nconst jsonb = (opts) => desc(PG_JSONB_CODEC_ID, opts);\nconst textArray = (opts) => desc(PG_TEXT_ARRAY_CODEC_ID, opts);\nconst timestamptz = (opts) => desc(PG_TIMESTAMPTZ_CODEC_ID, opts);\n/**\n* Declare a PostgreSQL control-plane table with a typed column schema. Wraps\n* the generic `table()` factory with a `PostgresTableSource` so the renderer\n* qualifies the table name with the optional schema prefix.\n*\n* ```ts\n* const marker = pgTable(\n*   { name: 'marker', schema: 'prisma_contract' },\n*   { space: text(), core_hash: text(), updated_at: timestamptz() },\n* );\n* ```\n*/\nfunction pgTable(source, columns) {\n\treturn table(new PostgresTableSource(source), columns);\n}\n//#endregion\n//#region src/contract-free/control-bootstrap.ts\nconst markerColumns = [\n\tcol(\"space\", \"text\", {\n\t\tnotNull: true,\n\t\tprimaryKey: true,\n\t\tdefault: lit(APP_SPACE_ID)\n\t}),\n\tcol(\"core_hash\", \"text\", { notNull: true }),\n\tcol(\"profile_hash\", \"text\", { notNull: true }),\n\tcol(\"contract_json\", \"jsonb\"),\n\tcol(\"canonical_version\", \"int\"),\n\tcol(\"updated_at\", \"timestamptz\", {\n\t\tnotNull: true,\n\t\tdefault: fn(\"now()\")\n\t}),\n\tcol(\"app_tag\", \"text\"),\n\tcol(\"meta\", \"jsonb\", {\n\t\tnotNull: true,\n\t\tdefault: lit(\"{}\")\n\t}),\n\tcol(\"invariants\", \"text[]\", {\n\t\tnotNull: true,\n\t\tdefault: lit(\"{}\")\n\t})\n];\nconst ledgerColumns = [\n\tcol(\"id\", \"bigserial\", { primaryKey: true }),\n\tcol(\"created_at\", \"timestamptz\", {\n\t\tnotNull: true,\n\t\tdefault: fn(\"now()\")\n\t}),\n\tcol(\"space\", \"text\", { notNull: true }),\n\tcol(\"migration_name\", \"text\", { notNull: true }),\n\tcol(\"migration_hash\", \"text\", { notNull: true }),\n\tcol(\"origin_core_hash\", \"text\"),\n\tcol(\"origin_profile_hash\", \"text\"),\n\tcol(\"destination_core_hash\", \"text\", { notNull: true }),\n\tcol(\"destination_profile_hash\", \"text\"),\n\tcol(\"operations\", \"jsonb\", { notNull: true })\n];\nconst contractColumns = [\n\tcol(\"core_hash\", \"text\", {\n\t\tnotNull: true,\n\t\tprimaryKey: true\n\t}),\n\tcol(\"created_at\", \"timestamptz\", {\n\t\tnotNull: true,\n\t\tdefault: fn(\"now()\")\n\t}),\n\tcol(\"contract_json\", \"jsonb\", { notNull: true })\n];\nconst markerTable = createTable({\n\tschema: \"prisma_contract\",\n\ttable: \"marker\",\n\tifNotExists: true,\n\tcolumns: markerColumns\n});\nconst ledgerTable = createTable({\n\tschema: \"prisma_contract\",\n\ttable: \"ledger\",\n\tifNotExists: true,\n\tcolumns: ledgerColumns\n});\nconst contractTable = createTable({\n\tschema: \"prisma_contract\",\n\ttable: \"contract\",\n\tifNotExists: true,\n\tcolumns: contractColumns\n});\nconst controlSchema = createSchema({\n\tschema: \"prisma_contract\",\n\tifNotExists: true\n});\nfunction buildSignMarkerBootstrapQueries() {\n\treturn [controlSchema, markerTable];\n}\nfunction buildControlTableBootstrapQueries() {\n\treturn [\n\t\tcontrolSchema,\n\t\tmarkerTable,\n\t\tledgerTable,\n\t\tcontractTable\n\t];\n}\n//#endregion\nexport { PostgresTableSource, addColumnAction, alterTable, buildControlTableBootstrapQueries, buildSignMarkerBootstrapQueries, columnDefaultAst, columnExistsAst, columnNullabilityAst, columnTypeAst, constraintExistsAst, createSchema, createTable, dropDefaultAction, extensionExistsAst, indexExistsAst, int4, int8, jsonb, noNullValuesAst, pgTable, rlsEnabledAst, rlsPolicyExistsAst, tableExistsAst, tableIsEmptyAst, tablePrimaryKeyAst, text, textArray, timestamptz, toRegclass };\n\n//# sourceMappingURL=contract-free.mjs.map"],"mappings":";;;;;;AAMA,MAAM,QAAQ,SAAS,UAAU;CAChC;CACA,UAAU,MAAM,YAAY;AAC7B;AACA,MAAM,QAAQ,SAAS,KAAK,kBAAkB,IAAI;AAClD,MAAM,QAAQ,SAAS,KAAK,kBAAkB,IAAI;AAClD,MAAM,QAAQ,SAAS,KAAK,kBAAkB,IAAI;AAClD,MAAM,SAAS,SAAS,KAAK,mBAAmB,IAAI;AACpD,MAAM,aAAa,SAAS,KAAK,wBAAwB,IAAI;AAC7D,MAAM,eAAe,SAAS,KAAK,yBAAyB,IAAI;;;;;;;;;;;;;AAahE,SAAS,QAAQ,QAAQ,SAAS;CACjC,OAAO,MAAM,IAAI,oBAAoB,MAAM,GAAG,OAAO;AACtD;AAGA,MAAM,gBAAgB;CACrB,IAAI,SAAS,QAAQ;EACpB,SAAS;EACT,YAAY;EACZ,SAAS,IAAI,YAAY;CAC1B,CAAC;CACD,IAAI,aAAa,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC1C,IAAI,gBAAgB,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC7C,IAAI,iBAAiB,OAAO;CAC5B,IAAI,qBAAqB,KAAK;CAC9B,IAAI,cAAc,eAAe;EAChC,SAAS;EACT,SAAS,GAAG,OAAO;CACpB,CAAC;CACD,IAAI,WAAW,MAAM;CACrB,IAAI,QAAQ,SAAS;EACpB,SAAS;EACT,SAAS,IAAI,IAAI;CAClB,CAAC;CACD,IAAI,cAAc,UAAU;EAC3B,SAAS;EACT,SAAS,IAAI,IAAI;CAClB,CAAC;AACF;AACA,MAAM,gBAAgB;CACrB,IAAI,MAAM,aAAa,EAAE,YAAY,KAAK,CAAC;CAC3C,IAAI,cAAc,eAAe;EAChC,SAAS;EACT,SAAS,GAAG,OAAO;CACpB,CAAC;CACD,IAAI,SAAS,QAAQ,EAAE,SAAS,KAAK,CAAC;CACtC,IAAI,kBAAkB,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC/C,IAAI,kBAAkB,QAAQ,EAAE,SAAS,KAAK,CAAC;CAC/C,IAAI,oBAAoB,MAAM;CAC9B,IAAI,uBAAuB,MAAM;CACjC,IAAI,yBAAyB,QAAQ,EAAE,SAAS,KAAK,CAAC;CACtD,IAAI,4BAA4B,MAAM;CACtC,IAAI,cAAc,SAAS,EAAE,SAAS,KAAK,CAAC;AAC7C;AACA,MAAM,kBAAkB;CACvB,IAAI,aAAa,QAAQ;EACxB,SAAS;EACT,YAAY;CACb,CAAC;CACD,IAAI,cAAc,eAAe;EAChC,SAAS;EACT,SAAS,GAAG,OAAO;CACpB,CAAC;CACD,IAAI,iBAAiB,SAAS,EAAE,SAAS,KAAK,CAAC;AAChD;AACA,MAAM,cAAc,YAAY;CAC/B,QAAQ;CACR,OAAO;CACP,aAAa;CACb,SAAS;AACV,CAAC;AACD,MAAM,cAAc,YAAY;CAC/B,QAAQ;CACR,OAAO;CACP,aAAa;CACb,SAAS;AACV,CAAC;AACD,MAAM,gBAAgB,YAAY;CACjC,QAAQ;CACR,OAAO;CACP,aAAa;CACb,SAAS;AACV,CAAC;AACD,MAAM,gBAAgB,aAAa;CAClC,QAAQ;CACR,aAAa;AACd,CAAC;AACD,SAAS,kCAAkC;CAC1C,OAAO,CAAC,eAAe,WAAW;AACnC;AACA,SAAS,oCAAoC;CAC5C,OAAO;EACN;EACA;EACA;EACA;CACD;AACD"}

package/dist/contract-free-DzpGxLfb.d.mts

@@ -0,0 +1,258 @@
+import "./table-source-ikHOZmhD-DriY1Lcr.mjs";
+import { f as PostgresCreateSchema, l as PostgresAlterTable, o as DropDefaultAction, p as PostgresCreateTable, r as AnyAlterTableAction, t as AddColumnAction } from "./nodes-BU-V-aZA-RqwPH68u.mjs";
+import { DdlColumn, DdlNode, DdlTableConstraint, SelectAst } from "@prisma/orm-family-sql/relational-core/ast";
+import { CfExpr, ColumnDescriptor, ColumnSchema, TableHandle } from "@prisma/orm-family-sql/relational-core/contract-free";
+//#region ../../../3-targets/3-targets/postgres/dist/contract-free.d.mts
+//#region src/contract-free/checks.d.ts
+/**
+ * `to_regclass($1)` with the qualified table name bound as a text parameter.
+ * Thin vocabulary wrapper over the core `cfExpr.fn` helper — the target
+ * supplies only the template and the codec'd operand.
+ */
+declare function toRegclass(qualifiedName: string): CfExpr;
+interface TableExistsCheckBuilder {
+  tableAbsent(): SelectAst;
+  tablePresent(): SelectAst;
+}
+/**
+ * Typed builder for the migration planner's table-existence checks. Produces
+ * FROM-less `SELECT to_regclass($1) IS [NOT] NULL AS "result"` ASTs with the
+ * qualified table name bound as a text parameter — never inlined into the SQL.
+ *
+ * `schema` is a namespace coordinate: the framework `__unbound__` sentinel
+ * elides the qualifier (search_path decides at runtime); any other id
+ * qualifies as `"schema"."table"`.
+ */
+declare function tableExistsAst(schema: string, table: string): TableExistsCheckBuilder;
+interface ConstraintExistsCheckBuilder {
+  constraintPresent(): SelectAst;
+  constraintAbsent(): SelectAst;
+}
+/**
+ * Typed builder for the migration planner's constraint-existence checks.
+ * Produces `SELECT [NOT ]EXISTS (SELECT 1 FROM pg_constraint c JOIN
+ * pg_namespace n ON n.oid = c.connamespace WHERE c.conname = $1 AND
+ * n.nspname = $2 [AND c.conrelid = to_regclass($3)]) AS "result"` with the
+ * constraint name, schema name, and qualified table name bound as text
+ * parameters.
+ *
+ * When `table` is omitted the check matches by name + schema across all
+ * tables. Pass `table` to scope the check to a single table (prevents false
+ * matches on identically-named constraints in different tables). `schema`
+ * is a namespace coordinate: the `__unbound__` sentinel compares `nspname`
+ * against `current_schema()` instead of a bound parameter.
+ */
+declare function constraintExistsAst(options: {
+  readonly constraintName: string;
+  readonly schema: string;
+  readonly table?: string;
+}): ConstraintExistsCheckBuilder;
+interface ColumnExistsCheckBuilder {
+  columnPresent(): SelectAst;
+  columnAbsent(): SelectAst;
+}
+/**
+ * Typed builder for column-existence checks over
+ * `information_schema.columns`, with schema, table, and column names bound
+ * as text parameters.
+ */
+declare function columnExistsAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+}): ColumnExistsCheckBuilder;
+/**
+ * Typed nullability check: EXISTS over `information_schema.columns` with
+ * `is_nullable` compared against the bound `'YES'` / `'NO'` marker.
+ */
+declare function columnNullabilityAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+  readonly nullable: boolean;
+}): SelectAst;
+interface ColumnDefaultCheckBuilder {
+  defaultPresent(): SelectAst;
+  defaultAbsent(): SelectAst;
+  noDefault(): SelectAst;
+}
+/**
+ * Typed default-presence checks over `information_schema.columns`.
+ * `defaultPresent` / `defaultAbsent` assert the column row exists with a
+ * non-null / null `column_default`; `noDefault` is the NOT EXISTS variant
+ * (also true when the column row is missing entirely).
+ */
+declare function columnDefaultAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+}): ColumnDefaultCheckBuilder;
+/**
+ * Typed column-type check: EXISTS over `pg_attribute` joined to `pg_class`
+ * and `pg_namespace`, comparing `format_type(a.atttypid, a.atttypmod)`
+ * against the bound expected display type and excluding dropped columns.
+ */
+declare function columnTypeAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+  readonly expectedType: string;
+}): SelectAst;
+interface TablePrimaryKeyCheckBuilder {
+  pkPresent(): SelectAst;
+  pkAbsent(): SelectAst;
+}
+/**
+ * Typed primary-key existence check over `pg_index` joined to `pg_class`
+ * and `pg_namespace`, with a LEFT JOIN on the index relation so an
+ * optional `constraintName` can scope the match to a named constraint.
+ */
+declare function tablePrimaryKeyAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly constraintName?: string;
+}): TablePrimaryKeyCheckBuilder;
+/**
+ * Typed emptiness check: NOT EXISTS over the user table itself with
+ * `LIMIT 1`. The table is addressed through the namespace's polymorphic
+ * `tableSource` (qualified for named schemas, bare for the unbound slot).
+ */
+declare function tableIsEmptyAst(schema: string, table: string): SelectAst;
+/**
+ * Typed no-NULL-values data check used by `SET NOT NULL` prechecks:
+ * NOT EXISTS over the user table where the column IS NULL.
+ */
+declare function noNullValuesAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly column: string;
+}): SelectAst;
+interface ExtensionExistsCheckBuilder {
+  extensionPresent(): SelectAst;
+  extensionAbsent(): SelectAst;
+}
+/**
+ * Typed extension existence check over `pg_extension`, with the extension
+ * name bound as a text parameter.
+ */
+declare function extensionExistsAst(extensionName: string): ExtensionExistsCheckBuilder;
+interface RlsPolicyExistsCheckBuilder {
+  policyPresent(): SelectAst;
+  policyAbsent(): SelectAst;
+}
+/**
+ * Typed RLS-policy existence check over `pg_policies`, with schema, table,
+ * and policy names bound as text parameters (never inlined). The `schema`
+ * coordinate is the resolved live-database schema name (e.g. `'public'`),
+ * compared against `pg_policies.schemaname` as a bound parameter.
+ */
+declare function rlsPolicyExistsAst(options: {
+  readonly schema: string;
+  readonly table: string;
+  readonly policyName: string;
+}): RlsPolicyExistsCheckBuilder;
+interface RlsEnabledCheckBuilder {
+  rlsEnabled(): SelectAst;
+  rlsDisabled(): SelectAst;
+}
+/**
+ * Typed row-level-security enabled check over `pg_class` joined to
+ * `pg_namespace`, comparing `pg_class.relrowsecurity` against the expected
+ * boolean. Schema and table names are bound as text parameters.
+ */
+declare function rlsEnabledAst(schema: string, table: string): RlsEnabledCheckBuilder;
+interface IndexExistsCheckBuilder {
+  indexPresent(): SelectAst;
+  indexAbsent(): SelectAst;
+}
+/**
+ * Typed index existence check riding the same `to_regclass` vocabulary as
+ * `tableExistsAst`, with the qualified index name bound as a text parameter.
+ */
+declare function indexExistsAst(schema: string, indexName: string): IndexExistsCheckBuilder;
+//#endregion
+//#region src/contract-free/columns.d.ts
+type ColOpts = {
+  readonly nullable?: boolean;
+};
+declare const text: (opts?: ColOpts) => ColumnDescriptor;
+declare const int4: (opts?: ColOpts) => ColumnDescriptor;
+declare const int8: (opts?: ColOpts) => ColumnDescriptor;
+declare const jsonb: (opts?: ColOpts) => ColumnDescriptor;
+declare const textArray: (opts?: ColOpts) => ColumnDescriptor;
+declare const timestamptz: (opts?: ColOpts) => ColumnDescriptor;
+/**
+ * Declare a PostgreSQL control-plane table with a typed column schema. Wraps
+ * the generic `table()` factory with a `PostgresTableSource` so the renderer
+ * qualifies the table name with the optional schema prefix.
+ *
+ * ```ts
+ * const marker = pgTable(
+ *   { name: 'marker', schema: 'prisma_contract' },
+ *   { space: text(), core_hash: text(), updated_at: timestamptz() },
+ * );
+ * ```
+ */
+declare function pgTable<Schema extends ColumnSchema>(source: {
+  readonly name: string;
+  readonly schema?: string;
+  readonly alias?: string;
+}, columns: Schema): TableHandle<Schema>;
+//#endregion
+//#region src/contract-free/control-bootstrap.d.ts
+declare function buildSignMarkerBootstrapQueries(): readonly DdlNode[];
+declare function buildControlTableBootstrapQueries(): readonly DdlNode[];
+//#endregion
+//#region src/contract-free/ddl.d.ts
+/**
+ * Build a Postgres `CREATE TABLE` query node.
+ *
+ * Pass `constraints` for table-level composite primary keys, foreign keys, and
+ * unique constraints — use the {@link PrimaryKeyConstraint}, {@link ForeignKeyConstraint},
+ * and {@link UniqueConstraint} classes from `@internal/sql-relational-core/ast`.
+ *
+ * Precondition: identifiers (`table`, `schema`, column names/types) are
+ * emitted to SQL verbatim — they are not quoted or escaped, so callers must
+ * pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal
+ * default values, by contrast, are single-quote-escaped (embedded `'` doubled)
+ * by the renderer. Identifier quoting for untrusted identifiers is added when
+ * the migration planner adopts this lowering path.
+ */
+declare function createTable(options: {
+  readonly table: string;
+  readonly schema?: string;
+  readonly ifNotExists?: boolean;
+  readonly columns: readonly DdlColumn[];
+  readonly constraints?: readonly DdlTableConstraint[];
+}): PostgresCreateTable;
+/**
+ * Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the
+ * pre-trusted-identifier precondition.
+ */
+declare function createSchema(options: {
+  readonly schema: string;
+  readonly ifNotExists?: boolean;
+}): PostgresCreateSchema;
+/**
+ * Build an `ADD COLUMN` action for use inside {@link alterTable}.
+ * The column is a structured `DdlColumn` so codec-encoded defaults flow
+ * through the adapter's `pgRenderDdlColumn` → `pgRenderDdlColumnDefault` path.
+ */
+declare function addColumnAction(column: DdlColumn): AddColumnAction;
+/**
+ * Build a `DROP DEFAULT` action (`ALTER COLUMN "<name>" DROP DEFAULT`) for
+ * use inside {@link alterTable}. The renderer quotes the column name.
+ */
+declare function dropDefaultAction(columnName: string): DropDefaultAction;
+/**
+ * Build a Postgres `ALTER TABLE` query node carrying one or more actions.
+ * See {@link addColumnAction} / {@link dropDefaultAction} for building actions.
+ */
+declare function alterTable(options: {
+  readonly table: string;
+  readonly schema?: string;
+  readonly actions: readonly AnyAlterTableAction[];
+}): PostgresAlterTable;
+//#endregion
+export { rlsPolicyExistsAst as A, indexExistsAst as C, noNullValuesAst as D, jsonb as E, textArray as F, timestamptz as I, toRegclass as L, tableIsEmptyAst as M, tablePrimaryKeyAst as N, pgTable as O, text as P, extensionExistsAst as S, int8 as T, columnTypeAst as _, IndexExistsCheckBuilder as a, createTable as b, TableExistsCheckBuilder as c, alterTable as d, buildControlTableBootstrapQueries as f, columnNullabilityAst as g, columnExistsAst as h, ExtensionExistsCheckBuilder as i, tableExistsAst as j, rlsEnabledAst as k, TablePrimaryKeyCheckBuilder as l, columnDefaultAst as m, ColumnExistsCheckBuilder as n, RlsEnabledCheckBuilder as o, buildSignMarkerBootstrapQueries as p, ConstraintExistsCheckBuilder as r, RlsPolicyExistsCheckBuilder as s, ColumnDefaultCheckBuilder as t, addColumnAction as u, constraintExistsAst as v, int4 as w, dropDefaultAction as x, createSchema as y };
+//# sourceMappingURL=contract-free-DzpGxLfb.d.mts.map

package/dist/contract-free-DzpGxLfb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-free-DzpGxLfb.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/contract-free.d.mts"],"mappings":";;;;;;;;;;;iBAUiB,WAAW,wBAAwB;UAC1C;EACR,eAAe;EACf,gBAAgB;;;;;;;;;;;iBAWD,eAAe,gBAAgB,gBAAgB;UACtD;EACR,qBAAqB;EACrB,oBAAoB;;;;;;;;;;;;;;;;iBAgBL,oBAAoB;WAC1B;WACA;WACA;IACP;UACM;EACR,iBAAiB;EACjB,gBAAgB;;;;;;;iBAOD,gBAAgB;WACtB;WACA;WACA;IACP;;;;;iBAKa,qBAAqB;WAC3B;WACA;WACA;WACA;IACP;UACM;EACR,kBAAkB;EAClB,iBAAiB;EACjB,aAAa;;;;;;;;iBAQE,iBAAiB;WACvB;WACA;WACA;IACP;;;;;;iBAMa,cAAc;WACpB;WACA;WACA;WACA;IACP;UACM;EACR,aAAa;EACb,YAAY;;;;;;;iBAOG,mBAAmB;WACzB;WACA;WACA;IACP;;;;;;iBAMa,gBAAgB,gBAAgB,gBAAgB;;;;;iBAKhD,gBAAgB;WACtB;WACA;WACA;IACP;UACM;EACR,oBAAoB;EACpB,mBAAmB;;;;;;iBAMJ,mBAAmB,wBAAwB;UAClD;EACR,iBAAiB;EACjB,gBAAgB;;;;;;;;iBAQD,mBAAmB;WACzB;WACA;WACA;IACP;UACM;EACR,cAAc;EACd,eAAe;;;;;;;iBAOA,cAAc,gBAAgB,gBAAgB;UACrD;EACR,gBAAgB;EAChB,eAAe;;;;;;iBAMA,eAAe,gBAAgB,oBAAoB;;;KAG/D;WACM;;cAEG,OAAO,OAAO,YAAY;cAC1B,OAAO,OAAO,YAAY;cAC1B,OAAO,OAAO,YAAY;cAC1B,QAAQ,OAAO,YAAY;cAC3B,YAAY,OAAO,YAAY;cAC/B,cAAc,OAAO,YAAY;;;;;;;;;;;;;iBAa9B,QAAQ,eAAe,cAAc;WAC3C;WACA;WACA;GACR,SAAS,SAAS,YAAY;;;iBAGhB,4CAA4C;iBAC5C,8CAA8C;;;;;;;;;;;;;;;;;iBAiB9C,YAAY;WAClB;WACA;WACA;WACA,kBAAkB;WAClB,uBAAuB;IAC9B;;;;;iBAKa,aAAa;WACnB;WACA;IACP;;;;;;iBAMa,gBAAgB,QAAQ,YAAY;;;;;iBAKpC,kBAAkB,qBAAqB;;;;;iBAKvC,WAAW;WACjB;WACA;WACA,kBAAkB;IACzB"}

package/dist/control-2F195jJk.d.mts

@@ -0,0 +1,11 @@
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO-_xPQVPF0.mjs";
+import { StorageColumn } from "@prisma/orm-family-sql/contract/types";
+import { SqlControlTargetDescriptor } from "@prisma/orm-family-sql/family/control";
+import { ColumnDefault } from "@prisma/orm-framework/contract/types";
+//#region ../../../3-targets/3-targets/postgres/dist/control.d.mts
+//#region src/exports/control.d.ts
+declare function postgresRenderDefault(def: ColumnDefault, column: StorageColumn): string;
+declare const postgresTargetDescriptor: SqlControlTargetDescriptor<'postgres', PostgresPlanTargetDetails>;
+//#endregion
+export { postgresTargetDescriptor as n, postgresRenderDefault as t };
+//# sourceMappingURL=control-2F195jJk.d.mts.map

package/dist/control-2F195jJk.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-2F195jJk.d.mts","names":[],"sources":["../../../../3-targets/3-targets/postgres/dist/control.d.mts"],"mappings":";;;;;;iBAKiB,sBAAsB,KAAK,eAAe,QAAQ;cACrD,0BAA0B,uCAAuC"}