@prisma/composer-prisma-cloud 0.9.0 → 0.10.0-dev.2

package/dist/auth/testing.mjs

@@ -23667,10 +23667,7 @@ function _defu(baseObject, defaults, namespace = ".", merger) {
 function createDefu(merger) {
 	return (...arguments_) => arguments_.reduce((p, c) => _defu(p, c, "", merger), {});
 }
-var defu;
-var init_defu = __esmMin((() => {
-	defu = createDefu();
-}));
+const defu = createDefu();
 /**
 * Cloud provider instance metadata service FQDNs. These resolve to link-local
 * IPs (usually `169.254.169.254`) inside their respective clouds and are
@@ -23914,7 +23911,6 @@ function isLoopbackHost(host) {
 }
 init_env();
 init_error();
-init_defu();
 async function runPluginInit(context) {
 	let options = context.options;
 	const plugins = options.plugins || [];
@@ -30586,7 +30582,6 @@ const changeEmail = createAuthEndpoint("/change-email", {
 });
 init_env();
 init_error();
-init_defu();
 init_instrumentation();
 const defuReplaceArrays = createDefu((obj, key, value) => {
 	if (Array.isArray(obj[key]) && Array.isArray(value)) {
@@ -32348,7 +32343,7 @@ function rowChanged(baseRow, cloneRow) {
 	return JSON.stringify(baseRow) !== JSON.stringify(cloneRow);
 }
 var memoryAdapter;
-var init_dist$3 = __esmMin((() => {
+var init_dist$2 = __esmMin((() => {
 	init_adapter();
 	init_env();
 	memoryAdapter = (db, config) => {
@@ -32609,7 +32604,7 @@ async function getBaseAdapter(options, handleDirectDatabase) {
 			acc[key] = [];
 			return acc;
 		}, {});
-		const { memoryAdapter } = await Promise.resolve().then(() => (init_dist$3(), dist_exports));
+		const { memoryAdapter } = await Promise.resolve().then(() => (init_dist$2(), dist_exports));
 		adapter = memoryAdapter(memoryDB)(options);
 	} else if (typeof options.database === "function") adapter = options.database(options);
 	else adapter = await handleDirectDatabase(options);
@@ -49496,7 +49491,7 @@ var init_handle_empty_in_lists = __esmMin((() => {}));
 var init_safe_null_comparison_plugin = __esmMin((() => {}));
 var init_constraint_node = __esmMin((() => {}));
 var init_simple_reference_expression_node = __esmMin((() => {}));
-var init_dist$2 = __esmMin((() => {
+var init_dist$1 = __esmMin((() => {
 	init_kysely();
 	init_query_creator();
 	init_query_finalizer();
@@ -49713,7 +49708,7 @@ var BunSqliteQueryCompiler;
 var BunSqliteDialect;
 var init_bun_sqlite_dialect_DTyyejk1 = __esmMin((() => {
 	init_kysely_migration_tables_B2_rTeXm();
-	init_dist$2();
+	init_dist$1();
 	BunSqliteAdapter = class {
 		get supportsCreateIfNotExists() {
 			return true;
@@ -49882,7 +49877,7 @@ var NodeSqliteQueryCompiler;
 var NodeSqliteDialect;
 var init_node_sqlite_dialect = __esmMin((() => {
 	init_kysely_migration_tables_B2_rTeXm();
-	init_dist$2();
+	init_dist$1();
 	NodeSqliteAdapter = class {
 		get supportsCreateIfNotExists() {
 			return true;
@@ -50050,7 +50045,7 @@ var D1SqliteQueryCompiler;
 var D1SqliteDialect;
 var init_d1_sqlite_dialect_CDCl_qH4 = __esmMin((() => {
 	init_kysely_migration_tables_B2_rTeXm();
-	init_dist$2();
+	init_dist$1();
 	D1SqliteAdapter = class extends SqliteAdapter {};
 	D1SqliteDriver = class {
 		#config;
@@ -50223,8 +50218,8 @@ function insensitiveNe(columnRef, value) {
 }
 var createKyselyAdapter;
 var kyselyAdapter;
-var init_dist$1 = __esmMin((() => {
-	init_dist$2();
+var init_dist = __esmMin((() => {
+	init_dist$1();
 	init_adapter();
 	init_env();
 	init_string();
@@ -50740,7 +50735,7 @@ var kysely_adapter_exports = /* @__PURE__ */ __exportAll({
 	kyselyAdapter: () => kyselyAdapter
 });
 var init_kysely_adapter = __esmMin((() => {
-	init_dist$1();
+	init_dist();
 }));
 init_error();
 async function getAdapter(options) {
@@ -50793,9 +50788,9 @@ function getSchema(config) {
 }
 init_get_tables();
 init_env();
-init_dist$1();
+init_dist();
 init_adapter();
-init_dist$2();
+init_dist$1();
 const map = {
 	postgres: {
 		string: [
@@ -51643,7 +51638,6 @@ init_get_tables();
 init_env();
 init_error();
 init_id();
-init_defu();
 /**
 * Estimates the entropy of a string in bits.
 * This is a simple approximation that helps detect low-entropy secrets.
@@ -51854,7 +51848,7 @@ Most of the features of Better Auth will not work correctly.`);
 	return ctx;
 }
 init_error();
-init_dist$1();
+init_dist();
 const init = async (options) => {
 	const adapter = await getAdapter(options);
 	const getDatabaseType = (database) => getKyselyDatabaseType(database) || "unknown";
@@ -59502,8 +59496,12 @@ function ifDefined(key, value) {
 	return value !== void 0 ? blindCast({ [key]: value }) : {};
 }
 const STRUCTURED_CODE_RE = /^[A-Z][A-Z0-9]*\.[A-Z][A-Z0-9_]*$/;
+/** Whether a bare string is a published `NAMESPACE.SUBCODE` code. */
+function isStructuredErrorCode(code) {
+	return STRUCTURED_CODE_RE.test(code);
+}
 function isStructuredError(e) {
-	return typeof e === "object" && e !== null && "code" in e && typeof e.code === "string" && STRUCTURED_CODE_RE.test(e.code) && "message" in e && typeof e.message === "string";
+	return typeof e === "object" && e !== null && "code" in e && typeof e.code === "string" && isStructuredErrorCode(e.code) && "message" in e && typeof e.message === "string";
 }
 function structuredError(code, message, options) {
 	const error = options?.cause !== void 0 ? new Error(message, { cause: options.cause }) : new Error(message);
@@ -59515,6 +59513,7 @@ function structuredError(code, message, options) {
 		code,
 		...ifDefined("why", options?.why),
 		...ifDefined("fix", options?.fix),
+		...ifDefined("nextActions", options?.nextActions),
 		...ifDefined("where", options?.where),
 		...ifDefined("severity", options?.severity),
 		...ifDefined("meta", options?.meta),
@@ -59540,7 +59539,7 @@ var CliStructuredError = class extends Error {
 	code;
 	severity;
 	constructor(code, summary, options) {
-		super(summary);
+		super(summary, options?.cause !== void 0 ? { cause: options.cause } : void 0);
 		this.name = "CliStructuredError";
 		this.code = code;
 		this.severity = options?.severity ?? "error";
@@ -59552,6 +59551,7 @@ var CliStructuredError = class extends Error {
 		Object.assign(this, {
 			...ifDefined("why", options?.why),
 			...ifDefined("fix", fix),
+			...ifDefined("nextActions", options?.nextActions),
 			...ifDefined("where", where),
 			...ifDefined("meta", options?.meta),
 			...ifDefined("docsUrl", options?.docsUrl)
@@ -59559,6 +59559,9 @@ var CliStructuredError = class extends Error {
 	}
 	/**
 	* Converts this error to a CLI error envelope for output formatting.
+	*
+	* This is the boundary that emits the envelope, so it is where a missing
+	* `nextActions` becomes `[]`.
 	*/
 	toEnvelope() {
 		return {
@@ -59568,6 +59571,7 @@ var CliStructuredError = class extends Error {
 			summary: this.message,
 			...ifDefined("why", this.why),
 			...ifDefined("fix", this.fix),
+			nextActions: this.nextActions ?? [],
 			...ifDefined("where", this.where),
 			...ifDefined("meta", this.meta),
 			...ifDefined("docsUrl", this.docsUrl)
@@ -59589,8 +59593,12 @@ var CliStructuredError = class extends Error {
 function errorConfigValidation(field, options) {
 	return new CliStructuredError("CONFIG.VALIDATION_FAILED", "Config validation error", {
 		why: options?.why ?? `Config must have a "${field}" field`,
-		fix: "Check your prisma-next.config.ts and ensure all required fields are provided",
-		docsUrl: docsUrlFor("CONFIG.VALIDATION_FAILED")
+		fix: "Check your prisma.config.ts and ensure all required fields are provided",
+		docsUrl: docsUrlFor("CONFIG.VALIDATION_FAILED"),
+		meta: {
+			field,
+			...options?.section !== void 0 ? { section: options.section } : {}
+		}
 	});
 }
 function postgresError(code, message, options) {
@@ -59601,7 +59609,7 @@ function postgresError(code, message, options) {
 * — named by `operation` (e.g. `createTable`, `dropColumn`, `dataTransform`) —
 * was invoked, but the migration was constructed without a `ControlStack`.
 * Concrete authoring usage always goes through the migration CLI entrypoint,
-* which assembles a stack from the loaded `prisma-next.config.ts`; reaching this
+* which assembles a stack from the loaded `prisma.config.ts`; reaching this
 * error means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
 * with the no-arg form (legal for `operations` / `describe` introspection only).
 *
@@ -59621,7 +59629,7 @@ function postgresError(code, message, options) {
 function errorPostgresMigrationStackMissing(operation) {
 	return new CliStructuredError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `PostgresMigration.${operation} requires a control adapter`, {
 		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.",
+		fix: "Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.",
 		meta: { operation }
 	});
 }
@@ -59984,6 +59992,22 @@ function normalizeSchemaNativeType(nativeType) {
 	if (trimmed.includes(" without time zone")) return trimmed.replace(" without time zone", "");
 	return trimmed;
 }
+/**
+* A bug in Prisma Next, not a user error. Never catch this except at the
+* outermost boundary for crash reporting — an InternalError means an invariant
+* broke and the process cannot reliably continue. User-facing failures use
+* `structuredError` with a dotted code instead.
+*/
+var InternalError = class extends Error {
+	isPrismaInternalError = true;
+	constructor(message, options) {
+		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.name = "InternalError";
+	}
+};
+function assertNever(value, message) {
+	throw new InternalError(message ?? `Unreachable: unexpected value ${String(value)}`);
+}
 function isJsonArray(value) {
 	return Array.isArray(value);
 }
@@ -60002,170 +60026,6 @@ function frozenCodecRef(codec) {
 		...ifDefined("many", codec.many)
 	});
 }
-function asNamespaceId(value) {
-	return blindCast(value);
-}
-/**
-* Resolves the effective control policy for a storage-plane node.
-*
-* Precedence: node-level value → contract default → `'managed'`.
-*
-* Both parameters are optional raw values so this function stays node-type-agnostic
-* and can be called by any consumer (verifier, planner, etc.) without importing IR classes.
-*/
-function effectiveControlPolicy(nodeControl, defaultControlPolicy) {
-	return nodeControl ?? defaultControlPolicy ?? "managed";
-}
-const CrossReferenceSchema = /* @__PURE__ */ blindCast(/* @__PURE__ */ type({
-	"+": "reject",
-	namespace: "string",
-	model: "string",
-	"space?": "string"
-}));
-/**
-* Runtime predicate for `ColumnDefaultLiteralInputValue`. Authoring layers
-* resolve template values from caller-supplied args (typed `unknown` at the
-* boundary) and need to validate before constructing a `ColumnDefault`.
-* Accepts JSON primitives, plain arrays/objects of JSON values, and `Date`
-* instances. Rejects functions, class instances (other than `Date`),
-* `undefined`, `bigint`, `symbol`, and arrays/objects containing those.
-*/
-function isColumnDefaultLiteralInputValue(value) {
-	if (value === null) return true;
-	const t = typeof value;
-	if (t === "string" || t === "number" || t === "boolean") return true;
-	if (value instanceof Date) return true;
-	if (Array.isArray(value)) return value.every(isColumnDefaultLiteralInputValue);
-	if (t === "object" && Object.getPrototypeOf(value) === Object.prototype) return Object.values(value).every(isColumnDefaultLiteralInputValue);
-	return false;
-}
-function isColumnDefault(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const kind = value.kind;
-	if (kind === "literal") return "value" in value;
-	if (kind === "function") return typeof value.expression === "string";
-	return false;
-}
-var DdlColumnDefault = class {
-	freeze() {
-		Object.freeze(this);
-	}
-};
-var LiteralColumnDefault = class extends DdlColumnDefault {
-	kind = "literal";
-	value;
-	constructor(value) {
-		super();
-		if (!isColumnDefaultLiteralInputValue(value)) throw structuredError("CONTRACT.DEFAULT_INVALID", "Invalid column default literal value");
-		this.value = value;
-		this.freeze();
-	}
-	accept(visitor, ctx) {
-		return visitor.literal(this, ctx);
-	}
-};
-var FunctionColumnDefault = class extends DdlColumnDefault {
-	kind = "function";
-	expression;
-	constructor(expression) {
-		super();
-		this.expression = expression;
-		this.freeze();
-	}
-	accept(visitor, ctx) {
-		return visitor.function(this, ctx);
-	}
-};
-var DdlColumn = class {
-	name;
-	type;
-	notNull;
-	primaryKey;
-	default;
-	/** Codec identity for this column. When present, the DDL walker resolves the codec via `codecLookup.get(codecRef.codecId)` and calls `codec.encode(default.value, {})` to obtain the wire value before inlining the literal default into the DDL string. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */
-	codecRef;
-	constructor(options) {
-		this.name = options.name;
-		this.type = options.type;
-		this.notNull = options.notNull;
-		this.primaryKey = options.primaryKey;
-		this.default = options.default;
-		this.codecRef = options.codecRef;
-		Object.freeze(this);
-	}
-};
-var DdlNode = class {
-	/**
-	* Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}
-	* recognise any `DdlNode` subclass — including target-contributed kinds —
-	* without a central kind registry that subclasses would have to register
-	* into.
-	*/
-	isDdlNode() {
-		return true;
-	}
-	freeze() {
-		Object.freeze(this);
-	}
-	collectParamRefs() {
-		return [];
-	}
-};
-function isDdlNode(value) {
-	return typeof value === "object" && value !== null && "isDdlNode" in value && typeof value.isDdlNode === "function";
-}
-/**
-* A composite (or single-column) PRIMARY KEY constraint on a `CreateTable`
-* node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY
-* (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`.
-*
-* Frozen on construction — immutable after creation.
-*/
-var PrimaryKeyConstraint = class {
-	kind = "primary-key";
-	columns;
-	name;
-	constructor(options) {
-		this.columns = Object.freeze([...options.columns]);
-		this.name = options.name;
-		Object.freeze(this);
-	}
-};
-/**
-* A table-level CHECK constraint carrying a raw SQL predicate expression. Used
-* for checks that are not enum value-set restrictions — e.g. the element-non-null
-* constraint on a scalar-array column (`array_position(col, NULL) IS NULL`).
-* The `expression` is emitted verbatim, so callers must supply safe,
-* pre-validated SQL.
-*
-* Frozen on construction — immutable after creation.
-*/
-var CheckExpressionConstraint = class {
-	kind = "check-expression";
-	name;
-	expression;
-	constructor(options) {
-		this.name = options.name;
-		this.expression = options.expression;
-		Object.freeze(this);
-	}
-};
-/**
-* A bug in Prisma Next, not a user error. Never catch this except at the
-* outermost boundary for crash reporting — an InternalError means an invariant
-* broke and the process cannot reliably continue. User-facing failures use
-* `structuredError` with a dotted code instead.
-*/
-var InternalError = class extends Error {
-	isPrismaInternalError = true;
-	constructor(message, options) {
-		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
-		this.name = "InternalError";
-	}
-};
-function assertNever(value, message) {
-	throw new InternalError(message ?? `Unreachable: unexpected value ${String(value)}`);
-}
 const toAnyExpressionVisitor = {
 	columnRef: (expr) => expr,
 	identifierRef: (expr) => expr,
@@ -60378,7 +60238,7 @@ var FunctionSource = class FunctionSource extends FromSource {
 	ordinality;
 	constructor(fn, args, alias, ordinality = false) {
 		super();
-		if (alias?.columnAliases?.length === 0) throw structuredError("SQL.AST_INVALID", "FunctionSource column aliases must not be empty", { meta: {
+		if (alias?.columnAliases?.length === 0) throw structuredError("RUNTIME.AST_INVALID", "FunctionSource column aliases must not be empty", { meta: {
 			kind: "function-source",
 			field: "columnAliases"
 		} });
@@ -60676,7 +60536,7 @@ var CaseExpr = class CaseExpr extends Expression {
 	elseExpr;
 	constructor(branches, elseExpr) {
 		super();
-		if (branches.length === 0) throw structuredError("SQL.AST_INVALID", "CaseExpr requires at least one branch", { meta: {
+		if (branches.length === 0) throw structuredError("RUNTIME.AST_INVALID", "CaseExpr requires at least one branch", { meta: {
 			kind: "case",
 			field: "branches"
 		} });
@@ -61329,6 +61189,154 @@ var UpdateAst = class UpdateAst extends QueryAst {
 		return this;
 	}
 };
+function asNamespaceId(value) {
+	return blindCast(value);
+}
+/**
+* Resolves the effective control policy for a storage-plane node.
+*
+* Precedence: node-level value → contract default → `'managed'`.
+*
+* Both parameters are optional raw values so this function stays node-type-agnostic
+* and can be called by any consumer (verifier, planner, etc.) without importing IR classes.
+*/
+function effectiveControlPolicy(nodeControl, defaultControlPolicy) {
+	return nodeControl ?? defaultControlPolicy ?? "managed";
+}
+const CrossReferenceSchema = /* @__PURE__ */ blindCast(/* @__PURE__ */ type({
+	"+": "reject",
+	namespace: "string",
+	model: "string",
+	"space?": "string"
+}));
+/**
+* Runtime predicate for `ColumnDefaultLiteralInputValue`. Authoring layers
+* resolve template values from caller-supplied args (typed `unknown` at the
+* boundary) and need to validate before constructing a `ColumnDefault`.
+* Accepts JSON primitives, plain arrays/objects of JSON values, and `Date`
+* instances. Rejects functions, class instances (other than `Date`),
+* `undefined`, `bigint`, `symbol`, and arrays/objects containing those.
+*/
+function isColumnDefaultLiteralInputValue(value) {
+	if (value === null) return true;
+	const t = typeof value;
+	if (t === "string" || t === "number" || t === "boolean") return true;
+	if (value instanceof Date) return true;
+	if (Array.isArray(value)) return value.every(isColumnDefaultLiteralInputValue);
+	if (t === "object" && Object.getPrototypeOf(value) === Object.prototype) return Object.values(value).every(isColumnDefaultLiteralInputValue);
+	return false;
+}
+function isColumnDefault(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const kind = value.kind;
+	if (kind === "literal") return "value" in value;
+	if (kind === "function") return typeof value.expression === "string";
+	return false;
+}
+var DdlColumnDefault = class {
+	freeze() {
+		Object.freeze(this);
+	}
+};
+var LiteralColumnDefault = class extends DdlColumnDefault {
+	kind = "literal";
+	value;
+	constructor(value) {
+		super();
+		if (!isColumnDefaultLiteralInputValue(value)) throw structuredError("CONTRACT.DEFAULT_INVALID", "Invalid column default literal value");
+		this.value = value;
+		this.freeze();
+	}
+	accept(visitor, ctx) {
+		return visitor.literal(this, ctx);
+	}
+};
+var FunctionColumnDefault = class extends DdlColumnDefault {
+	kind = "function";
+	expression;
+	constructor(expression) {
+		super();
+		this.expression = expression;
+		this.freeze();
+	}
+	accept(visitor, ctx) {
+		return visitor.function(this, ctx);
+	}
+};
+var DdlColumn = class {
+	name;
+	type;
+	notNull;
+	primaryKey;
+	default;
+	/** Codec identity for this column. When present, the DDL walker resolves the codec via `codecLookup.get(codecRef.codecId)` and runs the literal default through both declared conversions in order — `codec.encode(codec.decodeJson(default.value), {})` — to obtain the wire value it inlines into the DDL string. The read-back is what makes the pair sound: a contract stores a literal default in the codec's canonical JSON, which is not always the application value `encode` takes (`pg/int8@1` stores decimal text for a `bigint`). A `Date` is the one authored value JSON has no notation for, so it arrives as itself and skips `decodeJson`. When absent, literal defaults follow RawSqlLiteral wire-scalar semantics (string / number / boolean / bigint / null / Uint8Array / Date inlined directly). */
+	codecRef;
+	constructor(options) {
+		this.name = options.name;
+		this.type = options.type;
+		this.notNull = options.notNull;
+		this.primaryKey = options.primaryKey;
+		this.default = options.default;
+		this.codecRef = options.codecRef;
+		Object.freeze(this);
+	}
+};
+var DdlNode = class {
+	/**
+	* Structural brand: every DDL node answers `true`. Lets {@link isDdlNode}
+	* recognise any `DdlNode` subclass — including target-contributed kinds —
+	* without a central kind registry that subclasses would have to register
+	* into.
+	*/
+	isDdlNode() {
+		return true;
+	}
+	freeze() {
+		Object.freeze(this);
+	}
+	collectParamRefs() {
+		return [];
+	}
+};
+function isDdlNode(value) {
+	return typeof value === "object" && value !== null && "isDdlNode" in value && typeof value.isDdlNode === "function";
+}
+/**
+* A composite (or single-column) PRIMARY KEY constraint on a `CreateTable`
+* node. When `name` is set, the adapter renders `CONSTRAINT <name> PRIMARY KEY
+* (…)`; otherwise it renders an anonymous `PRIMARY KEY (…)`.
+*
+* Frozen on construction — immutable after creation.
+*/
+var PrimaryKeyConstraint = class {
+	kind = "primary-key";
+	columns;
+	name;
+	constructor(options) {
+		this.columns = Object.freeze([...options.columns]);
+		this.name = options.name;
+		Object.freeze(this);
+	}
+};
+/**
+* A table-level CHECK constraint carrying a raw SQL predicate expression. Used
+* for checks that are not enum value-set restrictions — e.g. the element-non-null
+* constraint on a scalar-array column (`array_position(col, NULL) IS NULL`).
+* The `expression` is emitted verbatim, so callers must supply safe,
+* pre-validated SQL.
+*
+* Frozen on construction — immutable after creation.
+*/
+var CheckExpressionConstraint = class {
+	kind = "check-expression";
+	name;
+	expression;
+	constructor(options) {
+		this.name = options.name;
+		this.expression = options.expression;
+		Object.freeze(this);
+	}
+};
 /**
 * Walks an AST's parameter references in first-encounter order and dedupes
 * by ParamRef identity. The single canonical helper used by every consumer
@@ -62026,10 +62034,12 @@ const PG_INT_CODEC_ID = "pg/int@1";
 const PG_INT2_CODEC_ID = "pg/int2@1";
 const PG_INT4_CODEC_ID = "pg/int4@1";
 const PG_INT8_CODEC_ID = "pg/int8@1";
+const PG_INT8_NUMBER_CODEC_ID = "pg/int8number@1";
 const PG_FLOAT_CODEC_ID = "pg/float@1";
 const PG_FLOAT4_CODEC_ID = "pg/float4@1";
 const PG_FLOAT8_CODEC_ID = "pg/float8@1";
 const PG_NUMERIC_CODEC_ID = "pg/numeric@1";
+const PG_UNBOUNDED_INT_CODEC_ID = "pg/unboundedint@1";
 const PG_BOOL_CODEC_ID = "pg/bool@1";
 const PG_BIT_CODEC_ID = "pg/bit@1";
 const PG_VARBIT_CODEC_ID = "pg/varbit@1";
@@ -62152,16 +62162,19 @@ function buildPostgresCodecDescriptorRegistry(descriptors) {
 	for (const descriptor of descriptors) {
 		if (!isPostgresCodecDescriptor(descriptor)) {
 			const codecId = candidateCodecId(descriptor);
-			throw structuredError("POSTGRES.CODEC_DESCRIPTOR_INVALID", `Codec descriptor '${codecId}' is not a valid PostgreSQL codec descriptor.`, {
+			throw structuredError("RUNTIME.CODEC_DESCRIPTOR_INVALID", `Codec descriptor '${codecId}' is not a valid PostgreSQL codec descriptor.`, {
 				why: "PostgreSQL codec registries require the postgres-codec discriminant and complete target descriptor methods.",
 				fix: "Extend PostgresCodecDescriptor or adapt a generic descriptor with postgresCodec().",
 				meta: { codecId }
 			});
 		}
-		if (byId.has(descriptor.codecId)) throw structuredError("POSTGRES.CODEC_DESCRIPTOR_DUPLICATE", `Duplicate PostgreSQL codec descriptor id '${descriptor.codecId}'.`, {
+		if (byId.has(descriptor.codecId)) throw structuredError("RUNTIME.DUPLICATE_CODEC", `Duplicate PostgreSQL codec descriptor id '${descriptor.codecId}'.`, {
 			why: "Each codecId must resolve to exactly one PostgreSQL descriptor during registry composition.",
 			fix: "Remove the duplicate target, adapter, or extension contribution.",
-			meta: { codecId: descriptor.codecId }
+			meta: {
+				codecId: descriptor.codecId,
+				target: "postgres"
+			}
 		});
 		byId.set(descriptor.codecId, descriptor);
 	}
@@ -62461,6 +62474,40 @@ function normalizeSqlBody(sql) {
 }
 /**
 * Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+* canonical content tuple for a check constraint:
+*
+*   [normalizeSqlBody(expression)]
+*
+* The predicate is the whole of a check's content — the constraint name,
+* schema, and table are orthogonal to its equivalence. The one-element tuple
+* keeps the encoding in the same shape as the index and RLS tuples so a member
+* can be added later without re-reading which encoding a kind uses.
+*
+* The tuple order and encoding are a stability commitment: any change
+* re-suffixes every wire name.
+*/
+function computeCheckContentHash(expression) {
+	const tuple = JSON.stringify([normalizeSqlBody(expression)]);
+	return createHash("sha256").update(tuple).digest("hex").slice(0, 8);
+}
+/** The trailing segment a check's wire-name prefix carries, per kind. */
+const CHECK_KIND_SUFFIX = {
+	membership: "check",
+	elementNotNull: "elem_not_null"
+};
+/**
+* Composes the wire-name prefix of a derived CHECK constraint:
+* `${table}_${column}_${kindSuffix}`, capped at the wire-name byte budget.
+* Shared by contract authoring (naming emitted checks) and `contract infer`
+* (recomputing the name a derived check would carry), so truncated and
+* multibyte prefixes match by construction.
+*/
+function composeCheckWirePrefix(tableName, columnName, kind) {
+	return truncateToWireNamePrefixBytes(`${tableName}_${columnName}_${CHECK_KIND_SUFFIX[kind]}`);
+}
+Object.keys(CHECK_KIND_SUFFIX).filter((kind) => kind in CHECK_KIND_SUFFIX);
+/**
+* Returns the first 8 lowercase hex characters of the SHA-256 digest over the
 * canonical content tuple for an index:
 *
 *   [normalizeSqlBody(expression), normalizeSqlBody(where), columns, unique, type, sortedOptions]
@@ -62501,17 +62548,40 @@ function computeIndexContentHash(parts) {
 	]);
 	return createHash("sha256").update(tuple).digest("hex").slice(0, 8);
 }
+const utf8 = new TextEncoder();
+/** UTF-8 byte length — the unit Postgres measures identifiers in. */
+function byteLength(value) {
+	return utf8.encode(value).length;
+}
 /**
-* Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_LENGTH}.
+* Rejects a wire-name prefix over {@link WIRE_NAME_PREFIX_MAX_BYTES}.
 * `subject` opens the error message (e.g. `defineContract: policy prefix`).
 */
 function assertWireNamePrefixLength(prefix, subject) {
-	if (prefix.length > 54) throw structuredError("CONTRACT.WIRE_NAME_PREFIX_TOO_LONG", `${subject} "${prefix}" exceeds the 54-character maximum (Postgres identifiers cap at 63 characters and the wire name appends a 9-character hash suffix).`, { meta: {
+	if (byteLength(prefix) > 54) throw structuredError("CONTRACT.WIRE_NAME_PREFIX_TOO_LONG", `${subject} "${prefix}" exceeds the 54-byte maximum (Postgres identifiers cap at 63 bytes and the wire name appends a 9-byte hash suffix).`, { meta: {
 		prefix,
-		maxLength: 54
+		maxBytes: 54
 	} });
 }
 /**
+* Shortens a DERIVED wire-name prefix to {@link WIRE_NAME_PREFIX_MAX_BYTES},
+* cutting on a code-point boundary so a multibyte character is never split.
+* Only derived prefixes truncate — an authored one throws
+* ({@link assertWireNamePrefixLength}), because its author can shorten it.
+*/
+function truncateToWireNamePrefixBytes(prefix) {
+	if (byteLength(prefix) <= 54) return prefix;
+	let out = "";
+	let bytes = 0;
+	for (const character of prefix) {
+		const size = byteLength(character);
+		if (bytes + size > 54) break;
+		out += character;
+		bytes += size;
+	}
+	return out;
+}
+/**
 * SQL family IR node base. Carries the family-level `kind` discriminator
 * `'sql'` and inherits the framework's `freezeNode` affordance.
 *
@@ -62556,6 +62626,41 @@ var SqlNode = class extends IRNodeBase {
 	}
 };
 /**
+* SQL Contract IR node for a table-level check constraint, name-identified:
+* `name` is the full physical name; a present `prefix` marks the constraint as
+* wire-named (`name` is `formatWireName(prefix, <8hex>)` over the expression's
+* content hash), an absent `prefix` marks it exact (the name is adopted
+* verbatim). This is the convention indexes and RLS policies already use — see
+* ADR 234, "Content-addressed wire names for Postgres-normalized objects".
+*
+* The predicate is opaque: one SQL string, never parsed and never rendered
+* from structured parts. A database reprints predicates in its own normalized
+* form, so a wire-named check is compared by name — the hash already commits
+* to the expression the contract declared.
+*/
+var CheckConstraint = class CheckConstraint extends SqlNode {
+	name;
+	expression;
+	constructor(input) {
+		super();
+		const name = nameOf(input.naming);
+		if (name.length === 0) throw new ContractValidationError("CheckConstraint: every check constraint carries a full physical name.", "storage");
+		this.name = name;
+		if (input.naming.kind === "wire") this.prefix = input.naming.prefix;
+		this.expression = input.expression;
+		freezeNode(this);
+	}
+	/**
+	* Normalizes either shape into an instance: an existing `CheckConstraint`
+	* passes through, canonical input is constructed. Callers that accept
+	* "instance or input" go through this, so the constructor keeps one
+	* canonical shape instead of widening to a union.
+	*/
+	static from(value) {
+		return value instanceof CheckConstraint ? value : new CheckConstraint(value);
+	}
+};
+/**
 * SQL Contract IR node for a table-level secondary index, name-identified:
 * `name` is the full physical name; a present `prefix` marks the index as
 * wire-named (`name` is `formatWireName(prefix, <8hex>)`), an absent `prefix`
@@ -62573,7 +62678,7 @@ var SqlNode = class extends IRNodeBase {
 * alias one (e.g.
 * `import { Index as SqlIndexNode } from '@internal/sql-contract/types'`).
 */
-var Index = class extends SqlNode {
+var Index = class Index extends SqlNode {
 	name;
 	unique;
 	constructor(input) {
@@ -62591,31 +62696,8 @@ var Index = class extends SqlNode {
 		if (input.options !== void 0) this.options = input.options;
 		freezeNode(this);
 	}
-};
-/**
-* SQL Contract IR node for a table-level check constraint that restricts
-* a column to the permitted values of a value-set.
-*
-* The constraint is **structured** (names a column and a value-set
-* reference), not a raw SQL expression. Each target renders its own DDL
-* from the structured form, keeping the contract target-agnostic.
-*
-* Construction is idempotent: passing an existing `CheckConstraint`
-* instance as input produces a new instance with identical fields.
-* The constructor does not use `instanceof` for input discrimination —
-* it reads plain named properties, which is sufficient since
-* `CheckConstraintInput` is a structural type.
-*/
-var CheckConstraint = class extends SqlNode {
-	name;
-	column;
-	valueSet;
-	constructor(input) {
-		super();
-		this.name = input.name;
-		this.column = input.column;
-		this.valueSet = input.valueSet;
-		freezeNode(this);
+	static from(value) {
+		return value instanceof Index ? value : new Index(value);
 	}
 };
 /**
@@ -62634,7 +62716,7 @@ var CheckConstraint = class extends SqlNode {
 * Use `UNBOUND_NAMESPACE_ID` from `@internal/framework-components/ir`
 * as the sentinel `namespaceId` for single-namespace (unbound) references.
 */
-var ForeignKeyReference = class extends SqlNode {
+var ForeignKeyReference = class ForeignKeyReference extends SqlNode {
 	namespaceId;
 	tableName;
 	columns;
@@ -62646,6 +62728,9 @@ var ForeignKeyReference = class extends SqlNode {
 		if (input.spaceId !== void 0) this.spaceId = input.spaceId;
 		freezeNode(this);
 	}
+	static from(value) {
+		return value instanceof ForeignKeyReference ? value : new ForeignKeyReference(value);
+	}
 };
 /**
 * SQL Contract IR node for a table-level foreign-key declaration — the
@@ -62667,23 +62752,26 @@ var ForeignKeyReference = class extends SqlNode {
 * regardless of whether the input was a JSON literal or an already-constructed
 * class instance.
 */
-var ForeignKey = class extends SqlNode {
+var ForeignKey = class ForeignKey extends SqlNode {
 	source;
 	target;
 	constructor(input) {
 		super();
-		this.source = input.source instanceof ForeignKeyReference ? input.source : new ForeignKeyReference(input.source);
-		this.target = input.target instanceof ForeignKeyReference ? input.target : new ForeignKeyReference(input.target);
+		this.source = ForeignKeyReference.from(input.source);
+		this.target = ForeignKeyReference.from(input.target);
 		if (input.name !== void 0) this.name = input.name;
 		if (input.onDelete !== void 0) this.onDelete = input.onDelete;
 		if (input.onUpdate !== void 0) this.onUpdate = input.onUpdate;
 		freezeNode(this);
 	}
+	static from(value) {
+		return value instanceof ForeignKey ? value : new ForeignKey(value);
+	}
 };
 /**
 * SQL Contract IR node for a table's primary-key constraint.
 */
-var PrimaryKey$1 = class extends SqlNode {
+var PrimaryKey$1 = class PrimaryKey extends SqlNode {
 	columns;
 	constructor(input) {
 		super();
@@ -62691,6 +62779,9 @@ var PrimaryKey$1 = class extends SqlNode {
 		if (input.name !== void 0) this.name = input.name;
 		freezeNode(this);
 	}
+	static from(value) {
+		return value instanceof PrimaryKey ? value : new PrimaryKey(value);
+	}
 };
 /**
 * SQL Contract IR node for a single column entry in `StorageTable.columns`.
@@ -62705,7 +62796,7 @@ var PrimaryKey$1 = class extends SqlNode {
 * in the parent `StorageTable.columns: Record<string, StorageColumn>`
 * map, so a `name` field would be redundant with the key.
 */
-var StorageColumn = class extends SqlNode {
+var StorageColumn = class StorageColumn extends SqlNode {
 	nativeType;
 	codecId;
 	nullable;
@@ -62715,6 +62806,7 @@ var StorageColumn = class extends SqlNode {
 		this.codecId = input.codecId;
 		this.nullable = input.nullable;
 		if (input.many !== void 0) this.many = input.many;
+		if (input.noCheck !== void 0) this.noCheck = input.noCheck;
 		if (input.typeParams !== void 0) this.typeParams = input.typeParams;
 		if (input.typeRef !== void 0) this.typeRef = input.typeRef;
 		if (input.default !== void 0) this.default = input.default;
@@ -62722,11 +62814,14 @@ var StorageColumn = class extends SqlNode {
 		if (input.valueSet !== void 0) this.valueSet = input.valueSet;
 		freezeNode(this);
 	}
+	static from(value) {
+		return value instanceof StorageColumn ? value : new StorageColumn(value);
+	}
 };
 /**
 * SQL Contract IR node for a table-level unique constraint.
 */
-var UniqueConstraint = class extends SqlNode {
+var UniqueConstraint = class UniqueConstraint extends SqlNode {
 	columns;
 	constructor(input) {
 		super();
@@ -62734,6 +62829,9 @@ var UniqueConstraint = class extends SqlNode {
 		if (input.name !== void 0) this.name = input.name;
 		freezeNode(this);
 	}
+	static from(value) {
+		return value instanceof UniqueConstraint ? value : new UniqueConstraint(value);
+	}
 };
 /**
 * SQL Contract IR node for a single table entry in a namespace's
@@ -62754,13 +62852,13 @@ var StorageTable = class StorageTable extends SqlNode {
 	foreignKeys;
 	constructor(input) {
 		super();
-		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([name, col]) => [name, col instanceof StorageColumn ? col : new StorageColumn(col)])));
-		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey$1 ? input.primaryKey : new PrimaryKey$1(input.primaryKey);
-		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof UniqueConstraint ? u : new UniqueConstraint(u)));
-		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof Index ? i : new Index(i)));
-		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof ForeignKey ? fk : new ForeignKey(fk)));
+		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([name, col]) => [name, StorageColumn.from(col)])));
+		if (input.primaryKey !== void 0) this.primaryKey = PrimaryKey$1.from(input.primaryKey);
+		this.uniques = Object.freeze(input.uniques.map(UniqueConstraint.from));
+		this.indexes = Object.freeze(input.indexes.map(Index.from));
+		this.foreignKeys = Object.freeze(input.foreignKeys.map(ForeignKey.from));
 		if (input.control !== void 0) this.control = input.control;
-		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((cc) => new CheckConstraint(cc)));
+		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map(CheckConstraint.from));
 		freezeNode(this);
 	}
 	/**
@@ -62806,6 +62904,16 @@ var StorageValueSet = class extends SqlNode {
 	}
 };
 /**
+* Hydrates one stored check constraint into constructor input. `parseNaming`
+* is what rejects a hand-edited file whose `prefix` and `name` disagree.
+*/
+function checkConstraintInputFromSerialized(flat) {
+	return {
+		naming: parseNaming(flat.name, flat.prefix),
+		expression: flat.expression
+	};
+}
+/**
 * Hydrates one stored index into constructor input. The parameter is typed
 * but the values are whatever the file held, so each field the union depends
 * on is checked here rather than downstream — by the time `Index` sees the
@@ -62978,22 +63086,119 @@ const pgNumericDecode = (wire) => {
 	return wire;
 };
 const DECIMAL_INTEGER = /^-?\d+$/;
-/** Reads an `int8` wire or JSON value as a `bigint`, rejecting anything `BigInt()` would misread. */
-const pgInt8Decode = (wire) => {
+/**
+* Requires an application value to be of the JS type the codec reads.
+*
+* A range check reads a value of the wrong type as a value out of range, and
+* reports a number plainly inside the range as outside it — so the type is
+* established first and answered for on its own terms, naming what a caller
+* has to change.
+*/
+const requireJsType = (codecId, expected, value) => {
+	if (typeof value === expected) return;
+	throw postgresError("RUNTIME.ENCODE_FAILED", `${codecId} value must be a ${expected}, got ${typeof value} ${String(value)}`, { meta: {
+		codecId,
+		received: typeof value
+	} });
+};
+/** Writes a `bigint` application value as the decimal text the wire form of the exact integer codecs carries. */
+const pgBigintEncode = (codecId, value) => {
+	requireJsType(codecId, "bigint", value);
+	return value.toString();
+};
+/**
+* Writes an application value as the decimal text these codecs carry as their
+* canonical JSON.
+*
+* A schema-written literal default (`BigInt @default(0)`) arrives here as a
+* `number`, since a number literal is the only integer a schema language
+* writes, and one that is a safe integer names its value exactly. Past that
+* range the literal was rounded before any of this ran, so the value written is
+* not the value meant — which this refuses rather than minting an exact-looking
+* total from it. A non-integral number is refused on the same terms.
+*/
+const pgBigintEncodeJson = (codecId, value) => {
+	if (typeof value !== "number") return pgBigintEncode(codecId, value);
+	if (!Number.isSafeInteger(value)) throw postgresError("RUNTIME.ENCODE_FAILED", `${codecId} number literal must be an integer within the safe integer range, got ${String(value)}`, { meta: {
+		codecId,
+		received: String(value)
+	} });
+	return BigInt(value).toString();
+};
+/**
+* Reads a wire or JSON value as a `bigint`, rejecting anything `BigInt()` would
+* misread. A number-typed wire value must also be a safe integer: past
+* ±(2^53 − 1) the driver's `number` has already rounded, so stringifying it
+* would mint a spuriously-exact `bigint` that need not equal the stored value.
+*/
+const decimalIntegerDecode = (codecId, wire) => {
 	if (typeof wire === "bigint") return wire;
 	const text = String(wire);
-	if (!DECIMAL_INTEGER.test(text)) throw postgresError("RUNTIME.DECODE_FAILED", "pg/int8@1 value must be a decimal integer", { meta: {
-		codecId: "pg/int8@1",
+	if (!DECIMAL_INTEGER.test(text)) throw postgresError("RUNTIME.DECODE_FAILED", `${codecId} value must be a decimal integer`, { meta: {
+		codecId,
+		received: text
+	} });
+	if (typeof wire === "number" && !Number.isSafeInteger(wire)) throw postgresError("RUNTIME.DECODE_FAILED", `${codecId} wire number must be an integer within the safe integer range, got ${text}`, { meta: {
+		codecId,
 		received: text
 	} });
 	return BigInt(text);
 };
+/** Reads an `int8` wire or JSON value as a `bigint`, rejecting anything `BigInt()` would misread. */
+const pgInt8Decode = (wire) => decimalIntegerDecode("pg/int8@1", wire);
 /**
-* Renders an `int8` default as a `bigint` literal. The canonical JSON is decimal
-* text but the application type is `bigint`, so a plain string literal would not
+* Reads an unconstrained-`numeric` wire or JSON value as a `bigint`, rejecting
+* non-integral values — including `NaN` and the infinities, which are `numeric`
+* values but not integers.
+*/
+const pgUnboundedIntDecode = (wire) => decimalIntegerDecode("pg/unboundedint@1", wire);
+const MIN_SAFE_INTEGER_BIGINT = BigInt(Number.MIN_SAFE_INTEGER);
+const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+/**
+* Requires an integer within ±(2^53 − 1), the range a JS `number` holds
+* exactly. The guard throws rather than rounding: past the boundary a `number`
+* silently loses digits, which is the failure mode this codec exists to refuse.
+*/
+const pgInt8NumberGuard = (code, value) => {
+	if (!Number.isSafeInteger(value)) throw postgresError(code, `pg/int8number@1 value must be an integer within the safe integer range, got ${String(value)}`, { meta: {
+		codecId: "pg/int8number@1",
+		received: String(value)
+	} });
+	return value;
+};
+const pgInt8NumberEncodeJson = (value) => {
+	requireJsType("pg/int8number@1", "number", value);
+	return pgInt8NumberGuard("RUNTIME.ENCODE_FAILED", value);
+};
+const pgInt8NumberEncode = (value) => String(pgInt8NumberEncodeJson(value));
+/**
+* Reads an `int8` wire value as a `number`, throwing outside ±(2^53 − 1) and on
+* non-integral input. Decimal text goes through `BigInt` before the range check
+* so an out-of-range value is compared exactly rather than after rounding.
+*/
+const pgInt8NumberDecode = (wire) => {
+	if (typeof wire === "number") return pgInt8NumberGuard("RUNTIME.DECODE_FAILED", wire);
+	const value = decimalIntegerDecode("pg/int8number@1", wire);
+	if (value < MIN_SAFE_INTEGER_BIGINT || value > MAX_SAFE_INTEGER_BIGINT) throw postgresError("RUNTIME.DECODE_FAILED", `pg/int8number@1 value must be an integer within the safe integer range, got ${value}`, { meta: {
+		codecId: "pg/int8number@1",
+		received: value.toString()
+	} });
+	return Number(value);
+};
+const pgInt8NumberDecodeJson = (json) => {
+	if (typeof json !== "number") throw postgresError("RUNTIME.DECODE_FAILED", "pg/int8number@1 database JSON value must be a number", { meta: {
+		codecId: "pg/int8number@1",
+		received: typeof json
+	} });
+	return pgInt8NumberGuard("RUNTIME.DECODE_FAILED", json);
+};
+/**
+* Renders a decimal-text default as a `bigint` literal, for the codecs whose
+* canonical JSON is decimal text while the application type is `bigint`
+* (`pg/int8@1`, `pg/unboundedint@1`) — a plain string literal would not
 * typecheck against the emitted column type.
 */
-const pgInt8RenderValueLiteral = (value) => typeof value === "string" && DECIMAL_INTEGER.test(value) ? `${value}n` : void 0;
+const decimalTextBigintLiteral = (value) => typeof value === "string" && DECIMAL_INTEGER.test(value) ? `${value}n` : void 0;
 const pgNumericRenderOutputType = (typeParams) => {
 	const precision = typeParams.precision;
 	if (precision === void 0) return void 0;
@@ -63653,13 +63858,13 @@ const pgInt2Descriptor = new PgInt2Descriptor();
 */
 var PgInt8Codec = class extends CodecImpl {
 	async encode(value, _ctx) {
-		return value.toString();
+		return pgBigintEncode(PG_INT8_CODEC_ID, value);
 	}
 	async decode(wire, _ctx) {
 		return pgInt8Decode(wire);
 	}
 	encodeJson(value) {
-		return value.toString();
+		return pgBigintEncodeJson(PG_INT8_CODEC_ID, value);
 	}
 	decodeJson(json) {
 		if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", "pg/int8@1 database JSON value must be a decimal string", { meta: {
@@ -63685,13 +63890,59 @@ var PgInt8Descriptor = class extends PostgresCodecDescriptor {
 	targetTypes = ["int8"];
 	paramsSchema = voidParamsSchema;
 	renderValueLiteral(value) {
-		return pgInt8RenderValueLiteral(value);
+		return decimalTextBigintLiteral(value);
 	}
 	factory() {
 		return () => new PgInt8Codec(this);
 	}
 };
 const pgInt8Descriptor = new PgInt8Descriptor();
+/**
+* A Postgres `int8` decoded as a JS `number`, for columns whose values stay
+* within the safe integer range ±(2^53 − 1). Both directions guard rather than
+* round: decode (wire and JSON) and encode throw a structured error on
+* out-of-range or non-integral input. The canonical JSON is a JSON number —
+* the deliberate exception to the decimal-text rule for 64-bit integers, and
+* the codec's purpose. The descriptor claims no target type, so `int8` in type
+* position stays `pg/int8@1`.
+*/
+var PgInt8NumberCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgInt8NumberEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return pgInt8NumberDecode(wire);
+	}
+	encodeJson(value) {
+		return pgInt8NumberEncodeJson(value);
+	}
+	decodeJson(json) {
+		return pgInt8NumberDecodeJson(json);
+	}
+};
+var PgInt8NumberDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_INT8_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return expression;
+	}
+	codecId = PG_INT8_NUMBER_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = [];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return renderTsLiteral(value);
+	}
+	factory() {
+		return () => new PgInt8NumberCodec(this);
+	}
+};
+const pgInt8NumberDescriptor = new PgInt8NumberDescriptor();
 var PgFloat4Codec = class extends CodecImpl {
 	async encode(value, _ctx) {
 		return value;
@@ -63845,6 +64096,53 @@ var PgNumericDescriptor = class extends PostgresCodecDescriptor {
 };
 const pgNumericDescriptor = new PgNumericDescriptor();
 /**
+* A genuinely unbounded integer over unconstrained Postgres `numeric` storage.
+* Application values are `bigint` and the canonical JSON is decimal text, like
+* `pg/int8@1`; decode rejects non-integral values. The descriptor claims no
+* target type, so `numeric` and `decimal` in type position stay `pg/numeric@1`.
+*/
+var PgUnboundedIntCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return pgBigintEncode(PG_UNBOUNDED_INT_CODEC_ID, value);
+	}
+	async decode(wire, _ctx) {
+		return pgUnboundedIntDecode(wire);
+	}
+	encodeJson(value) {
+		return pgBigintEncodeJson(PG_UNBOUNDED_INT_CODEC_ID, value);
+	}
+	decodeJson(json) {
+		if (typeof json !== "string") throw postgresError("RUNTIME.DECODE_FAILED", "pg/unboundedint@1 database JSON value must be a decimal string", { meta: {
+			codecId: PG_UNBOUNDED_INT_CODEC_ID,
+			received: typeof json
+		} });
+		return pgUnboundedIntDecode(json);
+	}
+};
+var PgUnboundedIntDescriptor = class extends PostgresCodecDescriptor {
+	nativeType() {
+		return PG_NUMERIC_NATIVE_TYPE;
+	}
+	jsonProjection(expression) {
+		return decimalTextJsonProjection(expression);
+	}
+	codecId = PG_UNBOUNDED_INT_CODEC_ID;
+	traits = [
+		"equality",
+		"order",
+		"numeric"
+	];
+	targetTypes = [];
+	paramsSchema = voidParamsSchema;
+	renderValueLiteral(value) {
+		return decimalTextBigintLiteral(value);
+	}
+	factory() {
+		return () => new PgUnboundedIntCodec(this);
+	}
+};
+const pgUnboundedIntDescriptor = new PgUnboundedIntDescriptor();
+/**
 * 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
@@ -64381,9 +64679,11 @@ const codecDescriptors = definePostgresCodecs([
 	pgInt4Descriptor,
 	pgInt2Descriptor,
 	pgInt8Descriptor,
+	pgInt8NumberDescriptor,
 	pgFloat4Descriptor,
 	pgFloat8Descriptor,
 	pgNumericDescriptor,
+	pgUnboundedIntDescriptor,
 	pgDateDescriptor,
 	pgTimestampDescriptor,
 	pgTimestamptzDescriptor,
@@ -64577,14 +64877,6 @@ const ColumnDefaultFunctionSchema = type.declare().type({
 	kind: functionKindSchema,
 	expression: "string"
 });
-const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
-const StorageValueSetRefSchema = type({
-	plane: "'storage'",
-	namespaceId: "string",
-	entityKind: "'valueSet'",
-	entityName: "string",
-	"spaceId?": "string"
-});
 const StorageColumnSchema = type({
 	"+": "reject",
 	nativeType: "string",
@@ -64593,11 +64885,26 @@ const StorageColumnSchema = type({
 	"many?": "boolean",
 	"typeParams?": "Record<string, unknown>",
 	"typeRef?": "string",
-	"default?": ColumnDefaultSchema,
+	"default?": ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema),
 	"control?": ControlPolicySchema$1,
-	"valueSet?": StorageValueSetRefSchema
+	"valueSet?": type({
+		plane: "'storage'",
+		namespaceId: "string",
+		entityKind: "'valueSet'",
+		entityName: "string",
+		"spaceId?": "string"
+	}),
+	"noCheck?": "(\"membership\" | \"elementNotNull\")[]"
 }).narrow((col, ctx) => {
 	if (col.typeParams !== void 0 && col.typeRef !== void 0) return ctx.mustBe("a column with either typeParams or typeRef, not both");
+	if (col.noCheck !== void 0) {
+		if (col.noCheck.length === 0) return ctx.mustBe("a column whose noCheck array is non-empty (omit the key when enforced)");
+		for (let i = 1; i < col.noCheck.length; i += 1) {
+			const previous = col.noCheck[i - 1];
+			const current = col.noCheck[i];
+			if (previous !== void 0 && current !== void 0 && previous >= current) return ctx.mustBe("a column whose noCheck kinds are unique and sorted ascending lexicographically");
+		}
+	}
 	return true;
 });
 /**
@@ -64651,8 +64958,8 @@ const ForeignKeySchema = type.declare().type({
 const CheckConstraintSchema = type({
 	"+": "reject",
 	name: "string",
-	column: "string",
-	valueSet: StorageValueSetRefSchema
+	"prefix?": "string",
+	expression: "string"
 });
 const tableEntityKind = {
 	kind: "table",
@@ -64668,7 +64975,8 @@ const tableEntityKind = {
 	}),
 	construct: (input) => new StorageTable({
 		...input,
-		indexes: input.indexes.map((i) => i instanceof Index ? i : indexInputFromSerialized(i))
+		indexes: input.indexes.map((i) => i instanceof Index ? i : indexInputFromSerialized(i)),
+		...ifDefined("checks", input.checks?.map((c) => c instanceof CheckConstraint ? c : checkConstraintInputFromSerialized(c)))
 	})
 };
 const valueSetEntityKind = {
@@ -66682,6 +66990,7 @@ function isAggregateDescriptor(value) {
 	if (!isObjectLike(value)) return false;
 	if (!("operation" in value) || !isNonEmptyString(value.operation)) return false;
 	if (!("nullable" in value) || typeof value.nullable !== "boolean") return false;
+	if (value.nullable === false && (!("emptyResultJson" in value) || value.emptyResultJson === void 0)) return false;
 	if (!("input" in value) || !isAggregateInputMatch(value.input)) return false;
 	if (!("output" in value) || !isAggregateOutputCodec(value.output)) return false;
 	return value.input.kind === "codec" || value.input.kind === "trait" || value.output.kind === "codec";
@@ -66930,7 +67239,7 @@ function collectAggregateDescriptors(descriptors) {
 	for (const descriptor of descriptors) {
 		const descriptorId = descriptor.id ?? "<unknown>";
 		for (const contributed of descriptor.types?.aggregateDescriptors ?? []) {
-			if (!isAggregateDescriptor(contributed)) throw runtimeError("CONTRACT.AGGREGATE_DESCRIPTOR_INVALID", `Malformed aggregate descriptor contributed by "${descriptorId}". A descriptor declares a non-empty \`operation\`, an \`input\` match of kind \`none\`/\`any\`/\`codec\`/\`trait\`, an \`output\` of kind \`self\`/\`codec\`, and a boolean \`nullable\`; a \`self\` output needs an input to reuse.`, {
+			if (!isAggregateDescriptor(contributed)) throw runtimeError("CONTRACT.AGGREGATE_DESCRIPTOR_INVALID", `Malformed aggregate descriptor contributed by "${descriptorId}". A descriptor declares a non-empty \`operation\`, an \`input\` match of kind \`none\`/\`any\`/\`codec\`/\`trait\`, an \`output\` of kind \`self\`/\`codec\`, and a boolean \`nullable\` — plus \`emptyResultJson\`, in the result codec's canonical JSON, where \`nullable\` is false; a \`self\` output needs an input to reuse.`, {
 				contributedBy: descriptorId,
 				descriptor: contributed
 			});
@@ -67737,6 +68046,9 @@ var PrimaryKey = class PrimaryKey extends SqlSchemaIRNode {
 	children() {
 		return [];
 	}
+	static from(value) {
+		return value instanceof PrimaryKey ? value : new PrimaryKey(value);
+	}
 	static is(node) {
 		return node.nodeKind === RelationalSchemaNodeKind.primaryKey;
 	}
@@ -67747,27 +68059,28 @@ var PrimaryKey = class PrimaryKey extends SqlSchemaIRNode {
 	}
 };
 /**
-* Schema IR node for a table-level check constraint that restricts a
-* column to a set of permitted values (an enum-style `IN (...)` check).
-*
-* Carries the **resolved values** rather than a raw SQL predicate so
-* callers can compare value-sets without parsing SQL.
+* Schema IR node for a table-level check constraint, carried as an opaque
+* predicate. The expression is never parsed — a database reprints predicates
+* in its own normalized form, so any structured reading of it would drift.
 *
-* Implements `DiffableNode` so a check constraint is directly a table's
-* diff-tree child: `id` is the constraint name. `isEqualTo` compares
-* `column` and the permitted-value set (order-insensitive — the database
-* does not guarantee `IN (...)` ordering).
+* Implements `DiffableNode` so a check is directly a table's diff-tree child;
+* `id` is `check:<name>`. `isEqualTo` is mode-selected by the receiver's
+* `prefix` (the differ always calls `expected.isEqualTo(actual)`): a
+* wire-named receiver compares ids only — the wire name's hash already
+* commits to the predicate — while an exact-named receiver byte-compares the
+* expression, which is reliable precisely when both sides came from the same
+* reprint.
 */
 var SqlCheckConstraintIR = class SqlCheckConstraintIR extends SqlSchemaIRNode {
 	nodeKind = RelationalSchemaNodeKind.check;
 	name;
-	column;
-	permittedValues;
+	expression;
 	constructor(input) {
 		super();
-		this.name = input.name;
-		this.column = input.column;
-		this.permittedValues = Object.freeze([...input.permittedValues]);
+		this.name = nameOf(input.naming);
+		if (input.naming.kind === "wire") this.prefix = input.naming.prefix;
+		this.expression = input.expression;
+		defineNonEnumerable(this, "dependsOn", input.dependsOn);
 		freezeNode(this);
 	}
 	get id() {
@@ -67776,23 +68089,17 @@ var SqlCheckConstraintIR = class SqlCheckConstraintIR extends SqlSchemaIRNode {
 	children() {
 		return [];
 	}
+	static from(value) {
+		return value instanceof SqlCheckConstraintIR ? value : new SqlCheckConstraintIR(value);
+	}
 	static is(node) {
 		return node.nodeKind === RelationalSchemaNodeKind.check;
 	}
-	/**
-	* Compares the permitted-value sets only (unordered), matching the
-	* relational walk's `verifyCheckConstraints`: two checks pairing by name
-	* compare their value sets — the `column` field is descriptive, not part
-	* of the comparison, so a name-paired check with equal values verifies
-	* regardless of which column carries it.
-	*/
 	isEqualTo(other) {
 		const node = blindCast(other);
 		assertNode(node, "SqlCheckConstraintIR", SqlCheckConstraintIR.is);
-		const thisValues = new Set(this.permittedValues);
-		const otherValues = new Set(node.permittedValues);
-		if (thisValues.size !== otherValues.size) return false;
-		return [...thisValues].every((v) => otherValues.has(v));
+		if (this.prefix !== void 0) return this.id === node.id;
+		return this.expression === node.expression;
 	}
 };
 /**
@@ -68081,6 +68388,9 @@ var SqlIndexIR = class SqlIndexIR extends SqlSchemaIRNode {
 	children() {
 		return [];
 	}
+	static from(value) {
+		return value instanceof SqlIndexIR ? value : new SqlIndexIR(value);
+	}
 	static is(node) {
 		return node.nodeKind === RelationalSchemaNodeKind.index;
 	}
@@ -68229,10 +68539,10 @@ var SqlTableIR = class extends SqlSchemaIRNode {
 		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([key, col]) => [key, col instanceof SqlColumnIR ? col : new SqlColumnIR(col)])));
 		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk)));
 		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u)));
-		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof SqlIndexIR ? i : new SqlIndexIR(i)));
-		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);
+		this.indexes = Object.freeze(input.indexes.map(SqlIndexIR.from));
+		if (input.primaryKey !== void 0) this.primaryKey = PrimaryKey.from(input.primaryKey);
 		if (input.annotations !== void 0) this.annotations = input.annotations;
-		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((c) => c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c)));
+		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map(SqlCheckConstraintIR.from));
 		freezeNode(this);
 	}
 	get id() {
@@ -68693,15 +69003,16 @@ var PostgresRoleSchemaNode = class PostgresRoleSchemaNode extends SqlSchemaIRNod
 * - `'decode'` — abort fired during `decodeRow` / `decodeField`.
 * - `'stream'` — abort fired between rows or before any codec call
 *   (already-aborted at entry).
-* - `'beforeExecute'` / `'afterExecute'` / `'onRow'` — abort fired
-*   on entry to or during the corresponding middleware phase
+* - `'beforeQuery'` / `'beforeExecute'` / `'afterQuery'` /
+*   `'afterExecute'` / `'onRow'` — abort fired on entry to or during
+*   the corresponding middleware phase
 *   (cooperative cancellation per the param-transform seam).
 */
 const RUNTIME_ABORTED = "RUNTIME.ABORTED";
 /**
 * Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the
 * abort was observed — codec call sites (`encode` / `decode` / `stream`)
-* or middleware seams (`beforeExecute` / `afterExecute` / `onRow`), as
+* or operation-specific middleware seams, as
 * enumerated on {@link RuntimeAbortedPhase}. Cause carries
 * `signal.reason` verbatim from the platform — native abort produces a
 * `DOMException`, explicit `controller.abort(reason)` produces whatever
@@ -68866,8 +69177,8 @@ function renderLoweredSql(ast, contract, codecDescriptorRegistry) {
 		case "delete":
 			sql = renderDelete(node, contract, pim);
 			break;
-		case "raw-sql":
-			sql = renderRawSql(node, contract, pim);
+		case "raw-query":
+			sql = renderParts(node.parts, contract, pim);
 			break;
 		// v8 ignore next 4
 		default: assertNever(node, `Unsupported AST node kind: ${unreachableKind(node)}`);
@@ -68918,7 +69229,7 @@ function collectTableSources(ast) {
 /**
 * Ordered, codec-encoded values of the value-set a storage column restricts to, or `undefined` when the referenced column carries no value-set (the common, non-enum case). Resolves the column's storage coordinate from the SELECT's table sources, then the column's `valueSet` ref to the value-set's `values`.
 */
-function allStrings$1(values) {
+function allStrings(values) {
 	return values.every((value) => typeof value === "string");
 }
 function resolveEnumOrderValues(ref, sourcesByRef, contract) {
@@ -68956,11 +69267,11 @@ function resolveEnumOrderValuesForIdentifier(name, sourcesByRef, contract) {
 function renderOrderByExpr(expr, sourcesByRef, contract, pim) {
 	if (expr.kind === "column-ref") {
 		const orderValues = resolveEnumOrderValues(expr, sourcesByRef, contract);
-		if (orderValues !== void 0 && allStrings$1(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${renderColumn(expr)})`;
+		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${renderColumn(expr)})`;
 	}
 	if (expr.kind === "identifier-ref") {
 		const orderValues = resolveEnumOrderValuesForIdentifier(expr.name, sourcesByRef, contract);
-		if (orderValues !== void 0 && allStrings$1(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${quoteIdentifier(expr.name)})`;
+		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${quoteIdentifier(expr.name)})`;
 	}
 	return renderExpr(expr, contract, pim);
 }
@@ -69332,19 +69643,11 @@ function renderUpdate(ast, contract, pim) {
 function renderDelete(ast, contract, pim) {
 	return `DELETE FROM ${qualifyTableFromNamespaceCoordinate(ast.table, contract)}${ast.where ? ` WHERE ${renderWhere(ast.where, contract, pim)}` : ""}${ast.returning?.length ? ` RETURNING ${renderReturning(ast.returning, contract, pim)}` : ""}`;
 }
-function renderRawSql(ast, contract, pim) {
-	const out = [];
-	for (let i = 0; i < ast.fragments.length; i++) {
-		out.push(ast.fragments[i] ?? "");
-		if (i < ast.args.length) {
-			const arg = ast.args[i];
-			if (arg !== void 0) out.push(renderExpr(arg, contract, pim));
-		}
-	}
-	return out.join("");
+function renderParts(parts, contract, pim) {
+	return parts.map((part) => typeof part === "string" ? part : renderExpr(part, contract, pim)).join("");
 }
 function renderRawExpr(node, contract, pim) {
-	return node.parts.map((part) => typeof part === "string" ? part : renderExpr(part, contract, pim)).join("");
+	return renderParts(node.parts, contract, pim);
 }
 /**
 * Maps each `ReferentialAction` value to the SQL keyword used in ON DELETE /
@@ -69364,8 +69667,15 @@ const REFERENTIAL_ACTION_SQL = {
 function errorMarkerRowCorrupt(options) {
 	return new CliStructuredError("CONTRACT.MARKER_ROW_CORRUPT", "Marker row is corrupt or incompatible", {
 		why: options.why,
-		fix: `The ${options.markerLocation} row for space "${options.space}" contains invalid data. Delete the row, then run \`prisma-next db sign --db <url>\` to write a fresh marker.`,
-		meta: { space: options.space }
+		fix: `The ${options.markerLocation} row for space "${options.space}" contains invalid data. Delete the row, then run \`prisma db sign --db <url>\` to write a fresh marker.`,
+		nextActions: [{
+			kind: "run-command",
+			label: "Write a fresh marker",
+			command: "{bin} db sign --db <url>",
+			reason: `Delete the invalid ${options.markerLocation} row for space "${options.space}" first — this command then writes a valid one.`
+		}],
+		meta: { space: options.space },
+		...ifDefined("cause", options.cause)
 	});
 }
 /**
@@ -69375,7 +69685,8 @@ function errorMarkerReadFailed(options) {
 	return new CliStructuredError("CONTRACT.MARKER_READ_FAILED", "Database error while reading contract marker", {
 		why: options.why,
 		fix: `Could not read marker at ${options.markerLocation} for space "${options.space}". Verify read permissions, connectivity, and locks, then retry.`,
-		meta: { space: options.space }
+		meta: { space: options.space },
+		...ifDefined("cause", options.cause)
 	});
 }
 function isMarkerRowParseError(err) {
@@ -69386,10 +69697,17 @@ function isLegacyMarkerShapeReadError(message) {
 	return normalized.includes("column \"space\" does not exist") || normalized.includes("no such column: space");
 }
 function errorLegacyMarkerShape(options) {
-	return errorRunnerFailed(`Legacy marker-table shape detected on ${options.markerLocation} (no \`space\` column). Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop \`${options.markerLocation}\` and re-run \`prisma-next db init\` to reinitialise from a clean baseline.`, {
+	return errorRunnerFailed(`Legacy marker-table shape detected on ${options.markerLocation} (no \`space\` column). Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop \`${options.markerLocation}\` and re-run \`prisma db init\` to reinitialise from a clean baseline.`, {
 		why: options.why,
-		fix: "Legacy marker-table shape detected. Drop `prisma_contract.marker` (Postgres) or `_prisma_marker` (SQLite) and re-run `prisma-next db init` to recreate it with the current per-space schema.",
-		meta: { runnerErrorCode: "MIGRATION.LEGACY_MARKER_SHAPE" }
+		fix: "Legacy marker-table shape detected. Drop `prisma_contract.marker` (Postgres) or `_prisma_marker` (SQLite) and re-run `prisma db init` to recreate it with the current per-space schema.",
+		nextActions: [{
+			kind: "run-command",
+			label: "Reinitialise the marker table from a clean baseline",
+			command: "{bin} db init",
+			reason: `Drop \`${options.markerLocation}\` first — it has the legacy shape (no \`space\` column) and this command recreates it with the current per-space schema.`
+		}],
+		meta: { runnerErrorCode: "MIGRATION.LEGACY_MARKER_SHAPE" },
+		...ifDefined("cause", options.cause)
 	});
 }
 function rethrowMarkerReadError(err, context) {
@@ -69397,17 +69715,20 @@ function rethrowMarkerReadError(err, context) {
 	if (isMarkerRowParseError(err)) throw errorMarkerRowCorrupt({
 		why: err.message,
 		space: context.space,
-		markerLocation: context.markerLocation
+		markerLocation: context.markerLocation,
+		cause: err
 	});
 	const message = err instanceof Error ? err.message : String(err);
 	if (isLegacyMarkerShapeReadError(message)) throw errorLegacyMarkerShape({
 		why: message,
-		markerLocation: context.markerLocation
+		markerLocation: context.markerLocation,
+		cause: err
 	});
 	throw errorMarkerReadFailed({
 		why: message,
 		space: context.space,
-		markerLocation: context.markerLocation
+		markerLocation: context.markerLocation,
+		cause: err
 	});
 }
 async function withMarkerReadErrorHandling(operation, context) {
@@ -69431,17 +69752,20 @@ function errorRunnerFailed(summary, options) {
 	return new CliStructuredError("MIGRATION.RUNNER_FAILED", summary, {
 		why: options?.why ?? "Migration runner failed",
 		fix: options?.fix ?? "Inspect the reported conflict and reconcile schema drift",
-		...options?.meta ? { meta: options.meta } : {}
+		...ifDefined("nextActions", options?.nextActions),
+		...options?.meta ? { meta: options.meta } : {},
+		...ifDefined("cause", options?.cause)
 	});
 }
 /**
-* Generic runtime error.
+* Generic runtime error carrying a caller-provided dotted code.
 */
-function errorRuntime(summary, options) {
-	return new CliStructuredError("CONTRACT.VERIFY_FAILED", summary, {
-		...options?.why ? { why: options.why } : { why: "Verification failed" },
-		...options?.fix ? { fix: options.fix } : { fix: "Check contract and database state" },
-		...options?.meta ? { meta: options.meta } : {}
+function errorRuntime(code, summary, options) {
+	return new CliStructuredError(code, summary, {
+		...ifDefined("why", options?.why),
+		...ifDefined("fix", options?.fix),
+		...ifDefined("meta", options?.meta),
+		...ifDefined("cause", options?.cause)
 	});
 }
 function sqlFamilyError(code, message, options) {
@@ -69495,7 +69819,16 @@ function parseContractMarkerRow(row) {
 		const messages = result.map((p) => p.message).join("; ");
 		throw sqlFamilyError("CONTRACT.MARKER_ROW_CORRUPT", `Invalid contract marker row: ${messages}`, {
 			why: "The contract marker row read from the database does not match the expected marker shape.",
-			fix: "Re-sign the database with `prisma-next db sign`, or repair the marker table.",
+			fix: "Re-sign the database with `prisma db sign`, or repair the marker table.",
+			nextActions: [{
+				kind: "run-command",
+				label: "Re-sign the database",
+				command: "{bin} db sign"
+			}, {
+				kind: "user-choice",
+				label: "Repair the marker table by hand",
+				reason: messages
+			}],
 			meta: { issues: messages }
 		});
 	}
@@ -70284,12 +70617,14 @@ var PostgresControlAdapter = class {
 		const checkResult = await driver.query(`SELECT
            cl.relname AS table_name,
            c.conname AS constraint_name,
-           pg_get_constraintdef(c.oid) AS constraintdef
+           pg_get_expr(c.conbin, c.conrelid) AS check_expression
          FROM pg_catalog.pg_constraint c
          JOIN pg_catalog.pg_class cl ON cl.oid = c.conrelid
          JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
          WHERE ns.nspname = $1
            AND c.contype = 'c'
+           AND c.conislocal
+           AND c.conrelid <> 0
          ORDER BY cl.relname, c.conname`, [schema]);
 		const columnsByTable = groupBy(columnsResult.rows, "table_name");
 		const pksByTable = groupBy(pkResult.rows, "table_name");
@@ -70431,15 +70766,11 @@ var PostgresControlAdapter = class {
 					columns: Object.freeze([...columnNames])
 				};
 			});
-			const checksForTable = [];
-			for (const checkRow of checksByTable.get(tableName) ?? []) {
-				const parsed = parseCheckConstraintDef(checkRow.constraintdef);
-				if (parsed) checksForTable.push({
-					name: checkRow.constraint_name,
-					column: parsed.column,
-					permittedValues: parsed.permittedValues
-				});
-			}
+			const checksForTable = (checksByTable.get(tableName) ?? []).map((checkRow) => ({
+				naming: namingOfLiveName(checkRow.constraint_name),
+				expression: checkRow.check_expression,
+				dependsOn: postgresColumnDependsOn(schema, tableName, Object.keys(columns))
+			}));
 			tableInputs[tableName] = {
 				name: tableName,
 				columns,
@@ -70730,75 +71061,6 @@ function groupBy(items, key) {
 	}
 	return map;
 }
-/**
-* Parses a Postgres check-constraint definition string (as returned by
-* `pg_get_constraintdef`) into a column name and permitted values array.
-*
-* Handles two shapes that Postgres emits for enum-style checks:
-*
-* 1. `= ANY (ARRAY[...])` — Postgres rewrites `col IN ('a','b')` to this form:
-*    `CHECK ((col = ANY (ARRAY['a'::text, 'b'::text])))`
-*
-* 2. `IN (...)` — stays as-is when written directly:
-*    `CHECK ((col IN ('a', 'b')))`
-*
-* Column names may be plain identifiers (`status`) or double-quoted identifiers
-* (`"my-col"`). Double-quoted identifiers with embedded `""` are un-escaped to a
-* single `"`.
-*
-* String literal values may contain Postgres-style doubled single-quotes (`''`),
-* which are un-escaped to a single `'` (e.g. `O''Brien` → `O'Brien`).
-*
-* Returns `{ column, permittedValues }` when the predicate matches one of
-* the two recognised shapes. Returns `undefined` for anything else (e.g.
-* a free-form SQL predicate that wasn't emitted by this slice).
-*/
-function parseCheckConstraintDef(constraintdef) {
-	const afterCheck = constraintdef.replace(/^CHECK\s*\(/i, "").replace(/\)$/, "").trim();
-	const inner = afterCheck.startsWith("(") && afterCheck.endsWith(")") ? afterCheck.slice(1, -1).trim() : afterCheck;
-	const anyArrayMatch = inner.match(/^(?:"((?:[^"]|"")*)"|(\w+))\s*=\s*ANY\s*\(\s*ARRAY\s*\[(.+)\]\s*\)\s*$/i);
-	if (anyArrayMatch) {
-		const column = anyArrayMatch[1] !== void 0 ? anyArrayMatch[1].replace(/""/g, "\"") : anyArrayMatch[2];
-		const arrayBody = anyArrayMatch[3];
-		if (!column || !arrayBody) return void 0;
-		const permittedValues = extractArrayLiterals(arrayBody);
-		return permittedValues ? {
-			column,
-			permittedValues
-		} : void 0;
-	}
-	const inMatch = inner.match(/^(?:"((?:[^"]|"")*)"|(\w+))\s+IN\s*\((.+)\)\s*$/i);
-	if (inMatch) {
-		const column = inMatch[1] !== void 0 ? inMatch[1].replace(/""/g, "\"") : inMatch[2];
-		const listBody = inMatch[3];
-		if (!column || !listBody) return void 0;
-		const permittedValues = extractQuotedLiterals(listBody);
-		return permittedValues ? {
-			column,
-			permittedValues
-		} : void 0;
-	}
-}
-/**
-* Extracts string literals from an `ARRAY[...]` body.
-* Handles `'value'::type` casts by stripping the cast part.
-* Postgres stores single quotes inside values as doubled single-quotes (`''`);
-* each extracted value is un-escaped so `O''Brien` becomes `O'Brien`.
-*/
-function extractArrayLiterals(arrayBody) {
-	const values = [...arrayBody.matchAll(/'((?:[^'\\]|\\.|'')*)'\s*(?:::[^\s,\]]+)?/g)].map((m) => (m[1] ?? "").replace(/''/g, "'"));
-	return values.length > 0 ? values : void 0;
-}
-/**
-* Extracts string literals from an `IN (...)` list.
-* Handles single-quoted literals with possible escaped quotes.
-* Postgres stores single quotes inside values as doubled single-quotes (`''`);
-* each extracted value is un-escaped so `O''Brien` becomes `O'Brien`.
-*/
-function extractQuotedLiterals(listBody) {
-	const values = [...listBody.matchAll(/'((?:[^'\\]|\\.|'')*)'/g)].map((m) => (m[1] ?? "").replace(/''/g, "'"));
-	return values.length > 0 ? values : void 0;
-}
 function pgIsTextLikeNativeType(nativeType) {
 	return nativeType === "text" || nativeType === "varchar" || nativeType.startsWith("varchar(") || nativeType === "character varying" || nativeType.startsWith("character varying(") || nativeType === "char" || nativeType.startsWith("char(") || nativeType === "character" || nativeType.startsWith("character(");
 }
@@ -70837,14 +71099,28 @@ function pgInlineLiteral(wire, nativeType) {
 		nativeType
 	} });
 }
+const SERIAL_FAMILY_TYPES = /* @__PURE__ */ new Set([
+	"serial",
+	"serial4",
+	"bigserial",
+	"serial8",
+	"smallserial",
+	"serial2"
+]);
 async function pgRenderDdlColumnDefault(def, nativeType, codecLookup, codecRef) {
 	if (def.kind === "function") {
-		if (def.expression === "autoincrement()") return "";
+		if (def.expression === "autoincrement()") {
+			if (!SERIAL_FAMILY_TYPES.has(nativeType.toLowerCase())) throw postgresError("CONTRACT.DEFAULT_INVALID", `Column type "${nativeType}" has an autoincrement() default but is not a SERIAL-family pseudo-type. Autoincrement columns must declare their type as SERIAL (or SERIAL4), BIGSERIAL (or SERIAL8), or SMALLSERIAL (or SERIAL2) — e.g. col(name, "SERIAL", { default: fn("autoincrement()") }).`, { meta: { nativeType } });
+			return "";
+		}
 		return `DEFAULT (${def.expression})`;
 	}
 	if (codecRef !== void 0) {
 		const codec = codecLookup.get(codecRef.codecId);
-		if (codec !== void 0) return `DEFAULT ${pgInlineLiteral(await codec.encode(def.value, {}), nativeType)}`;
+		if (codec !== void 0) {
+			const value = def.value instanceof Date ? def.value : codec.decodeJson(def.value);
+			return `DEFAULT ${pgInlineLiteral(await codec.encode(value, {}), nativeType)}`;
+		}
 	}
 	return `DEFAULT ${pgInlineLiteral(def.value, nativeType)}`;
 }
@@ -71045,15 +71321,28 @@ const produces = (operation, input, codecId) => ({
 	},
 	nullable: true
 });
-/** Integer codecs whose `sum` widens to `bigint` — every built-in integer bar `int8`, whose sum goes to `numeric` instead. */
+/** The same, for an operation that builds its own expression. */
+const producesVia = (operation, input, codecId, lower) => ({
+	...produces(operation, input, codecId),
+	lower
+});
+/** The SQL aggregate a lossless variant computes with. `sumBigInt` is a `sum` read exactly, `countBigInt` a `count`, `avgDecimal` an `avg`: the variants differ in how the result is read, never in what the database computes. */
+const computedWith = (fn) => ({ expr }) => new AggregateExpr(fn, expr);
+/** `avg` over an integer column, rounded once. PostgreSQL computes the exact `numeric` mean and the cast turns that one value into the `double precision` the result codec reads; casting the input instead would round every value before it was accumulated. */
+const avgCastToFloat8 = ({ expr }) => CastExpr.as(new AggregateExpr("avg", expr), "float8");
+/** Integer codecs whose `sum` widens to `bigint` — every built-in integer bar the 64-bit ones, whose sum goes to `numeric` instead. */
 const SUM_WIDENS_TO_INT8 = [
 	PG_INT2_CODEC_ID,
 	PG_INT4_CODEC_ID,
 	PG_INT_CODEC_ID,
 	SQL_INT_CODEC_ID
 ];
-/** Every built-in integer codec: `avg` over any of them is `numeric`. */
-const AVG_IS_NUMERIC = [...SUM_WIDENS_TO_INT8, PG_INT8_CODEC_ID];
+/** The 64-bit integer codecs: PostgreSQL computes their `sum` as a `numeric`, a total free to leave the range an `int8` holds. */
+const SUM_WIDENS_TO_NUMERIC = [PG_INT8_CODEC_ID, PG_INT8_NUMBER_CODEC_ID];
+/** The integer codecs a `sum` reads back as a `number`: every fixed-width one, whatever its own application type. */
+const FIXED_WIDTH_INTEGER_CODECS = [...SUM_WIDENS_TO_INT8, ...SUM_WIDENS_TO_NUMERIC];
+/** Every built-in integer codec, the unbounded one included: `avg` over any of them is a `numeric` mean. */
+const INTEGER_CODECS = [...FIXED_WIDTH_INTEGER_CODECS, PG_UNBOUNDED_INT_CODEC_ID];
 /** Codecs over `double precision`, whose `sum` and `avg` stay there. */
 const DOUBLE_PRECISION_CODECS = [
 	PG_FLOAT8_CODEC_ID,
@@ -71091,20 +71380,36 @@ const postgresAggregateDescriptors = [
 	{
 		operation: "count",
 		input: { kind: "any" },
+		output: {
+			kind: "codec",
+			codecId: PG_INT8_NUMBER_CODEC_ID
+		},
+		nullable: false,
+		emptyResultJson: 0
+	},
+	{
+		operation: "countBigInt",
+		input: { kind: "any" },
 		output: {
 			kind: "codec",
 			codecId: PG_INT8_CODEC_ID
 		},
-		nullable: false
+		nullable: false,
+		emptyResultJson: "0",
+		lower: computedWith("count")
 	},
-	...SUM_WIDENS_TO_INT8.map((codecId) => produces("sum", overCodec(codecId), PG_INT8_CODEC_ID)),
-	produces("sum", overCodec(PG_INT8_CODEC_ID), PG_NUMERIC_CODEC_ID),
+	...FIXED_WIDTH_INTEGER_CODECS.map((codecId) => produces("sum", overCodec(codecId), PG_INT8_NUMBER_CODEC_ID)),
+	...SUM_WIDENS_TO_INT8.map((codecId) => producesVia("sumBigInt", overCodec(codecId), PG_INT8_CODEC_ID, computedWith("sum"))),
+	...SUM_WIDENS_TO_NUMERIC.map((codecId) => producesVia("sumBigInt", overCodec(codecId), PG_UNBOUNDED_INT_CODEC_ID, computedWith("sum"))),
+	producesVia("sumBigInt", overCodec(PG_UNBOUNDED_INT_CODEC_ID), PG_UNBOUNDED_INT_CODEC_ID, computedWith("sum")),
 	produces("sum", overCodec(PG_FLOAT4_CODEC_ID), PG_FLOAT4_CODEC_ID),
 	...DOUBLE_PRECISION_CODECS.map((codecId) => produces("sum", overCodec(codecId), PG_FLOAT8_CODEC_ID)),
 	produces("sum", overCodec(PG_NUMERIC_CODEC_ID), PG_NUMERIC_CODEC_ID),
+	produces("sum", overCodec(PG_UNBOUNDED_INT_CODEC_ID), PG_UNBOUNDED_INT_CODEC_ID),
 	produces("sum", overCodec(PG_INTERVAL_CODEC_ID), PG_INTERVAL_CODEC_ID),
 	produces("sum", overCodec(PG_TIME_CODEC_ID), PG_INTERVAL_CODEC_ID),
-	...AVG_IS_NUMERIC.map((codecId) => produces("avg", overCodec(codecId), PG_NUMERIC_CODEC_ID)),
+	...INTEGER_CODECS.map((codecId) => producesVia("avg", overCodec(codecId), PG_FLOAT8_CODEC_ID, avgCastToFloat8)),
+	...[...INTEGER_CODECS, PG_NUMERIC_CODEC_ID].map((codecId) => producesVia("avgDecimal", overCodec(codecId), PG_NUMERIC_CODEC_ID, computedWith("avg"))),
 	...[PG_FLOAT4_CODEC_ID, ...DOUBLE_PRECISION_CODECS].map((codecId) => produces("avg", overCodec(codecId), PG_FLOAT8_CODEC_ID)),
 	produces("avg", overCodec(PG_NUMERIC_CODEC_ID), PG_NUMERIC_CODEC_ID),
 	produces("avg", overCodec(PG_INTERVAL_CODEC_ID), PG_INTERVAL_CODEC_ID),
@@ -71196,7 +71501,8 @@ const postgresAdapterDescriptorMeta = {
 			returning: true,
 			defaultInInsert: true,
 			lateral: true,
-			scalarList: true
+			scalarList: true,
+			checkConstraint: true
 		}
 	},
 	types: {
@@ -71513,9 +71819,9 @@ function classifyDiffEntityKind(issue, entityKindOf) {
 * issue reason. The vocabulary maps one-to-one: an undeclared live entity or
 * namespace is `extraTopLevelObject`, an undeclared live field
 * `extraNestedElement`, undeclared auxiliaries (constraints, indexes,
-* defaults) and structural leaves (policies) `extraAuxiliary`; a value-set
-* drift on a check node is `valueDrift`; every other paired divergence is
-* `declaredIncompatible`; anything the database lacks is `declaredMissing`.
+* defaults) and structural leaves (policies) `extraAuxiliary`; every paired
+* divergence is `declaredIncompatible`; anything the database lacks is
+* `declaredMissing`.
 * `granularityOf` is the target's classifier, so target and extension node
 * kinds classify without the family importing them.
 */
@@ -71527,7 +71833,6 @@ function classifySqlDiffIssue(issue, granularityOf) {
 		if (granularity === "field") return "extraNestedElement";
 		return "extraAuxiliary";
 	}
-	if (issueNode$1(issue)?.nodeKind === RelationalSchemaNodeKind.check) return "valueDrift";
 	return "declaredIncompatible";
 }
 /**
@@ -71929,7 +72234,11 @@ const sortTargets = [{
 		"table",
 		"*"
 	],
-	arrayKeys: ["indexes", "uniques"]
+	arrayKeys: [
+		"checks",
+		"indexes",
+		"uniques"
+	]
 }];
 const matchesPreserveEmptyPattern = createPreserveEmptyPredicate(preserveEmptyPatterns);
 const shouldPreserveEmpty = (path) => isColumnDefaultValuePath(path) || matchesPreserveEmptyPattern(path);
@@ -72731,27 +73040,29 @@ function generateStorageNamespacesType(namespaces) {
 }
 const EXACT_NAME_BODY_PREAMBLE = "Drift detection compares the authored SQL text byte-for-byte against Postgres's reprinted form, which is only reliable when the text was captured by contract infer.";
 /**
-* Per-subject remediation: an index moves to wire naming via `name:`;
-* a policy has no such parameter — dropping `@@map` makes the block's head
-* the wire prefix.
+* Per-subject remediation: an index or check moves to wire naming via
+* `name:`; a policy has no such parameter — dropping `@@map` makes the
+* block's head the wire prefix.
 */
 const EXACT_NAME_BODY_REMEDIATION = {
 	index: "For hand-authored definitions, use name: and let Prisma Next manage the physical name; to migrate an adopted object to wire naming, replace map: with name: (keeping the body text unchanged) and apply the resulting rename migration.",
-	policy: "For hand-authored definitions, drop @@map and let the policy block's head name the policy; to migrate an adopted policy to wire naming, remove @@map (keeping the body text unchanged) and apply the resulting rename migration."
+	policy: "For hand-authored definitions, drop @@map and let the policy block's head name the policy; to migrate an adopted policy to wire naming, remove @@map (keeping the body text unchanged) and apply the resulting rename migration.",
+	check: "For hand-authored definitions, use name: and let Prisma Next manage the physical name; to migrate an adopted check to wire naming, replace map: with name: (keeping the body text unchanged) and apply the resulting rename migration."
 };
-/** What the user actually wrote, per subject: index `map:`, policy `@@map`. */
+/** What the user actually wrote, per subject: index and check `map:`, policy `@@map`. */
 const EXACT_NAME_FEATURE = {
 	index: "map:",
-	policy: "@@map"
+	policy: "@@map",
+	check: "map:"
 };
 const EXACT_NAME_BODY_WARNING_CODE = "PN_EXACT_NAME_BODY_COMPARISON";
 /**
 * Mints the exact-name body-comparison warning for a `map:`-named object
 * carrying a hand-authorable SQL body — fully formed, so the transport and
-* the flush stay generic. `subject` is `index` here and `policy` where
-* policies mint the same warning; the feature name and the remediation are
-* subject-specific end to end, so a batched summary (grouped on
-* code + summary) is true of every object it covers.
+* the flush stay generic. `subject` distinguishes the index, policy, and
+* check callers that mint this same warning; the feature name and the
+* remediation are subject-specific end to end, so a batched summary
+* (grouped on code + summary) is true of every object it covers.
 */
 function exactNameBodyWarning(subject, exactName) {
 	const item = `${subject} "${exactName}"`;
@@ -73119,6 +73430,26 @@ function rejectDuplicateWireNamedIndexContent(indexes, coordinate, errors) {
 		seenContent.add(content);
 	}
 }
+/**
+* Two wire-named checks with the same predicate are one check written twice —
+* the content hash is their identity, so neither spelling can survive, and
+* whitespace variants of one predicate collapse onto the same hash. An
+* exact-named check is identified by its name instead, so content twins under
+* two names are legal (the legacy shape a database adopts from) and a repeated
+* name is rejected by the named-object check.
+*/
+function rejectDuplicateWireNamedCheckContent(checks, coordinate, errors) {
+	const seenContent = /* @__PURE__ */ new Set();
+	for (const check of checks) {
+		if (check.prefix === void 0) continue;
+		const content = computeCheckContentHash(check.expression);
+		if (seenContent.has(content)) {
+			errors.push(`${coordinate}: duplicate check constraint definition (expression "${check.expression}")`);
+			continue;
+		}
+		seenContent.add(content);
+	}
+}
 function isContractFieldType(value) {
 	if (!isPlainRecord(value)) return false;
 	const kind = value["kind"];
@@ -73308,18 +73639,7 @@ function validateStorageSemantics(storage) {
 			if (fk.onDelete === "setDefault" && !column.nullable && column.default === void 0) errors.push(`Namespace "${namespaceId}" table "${tableName}": onDelete setDefault on foreign key column "${colName}" which is NOT NULL and has no DEFAULT`);
 			if (fk.onUpdate === "setDefault" && !column.nullable && column.default === void 0) errors.push(`Namespace "${namespaceId}" table "${tableName}": onUpdate setDefault on foreign key column "${colName}" which is NOT NULL and has no DEFAULT`);
 		}
-		const seenCheckDefinitions = /* @__PURE__ */ new Set();
-		for (const check of table.checks ?? []) {
-			const signature = JSON.stringify({
-				column: check.column,
-				valueSet: check.valueSet
-			});
-			if (seenCheckDefinitions.has(signature)) {
-				errors.push(`Namespace "${namespaceId}" table "${tableName}": duplicate check constraint definition on column "${check.column}"`);
-				continue;
-			}
-			seenCheckDefinitions.add(signature);
-		}
+		rejectDuplicateWireNamedCheckContent(table.checks ?? [], tableCoordinate, errors);
 	}
 	return errors;
 }
@@ -73369,7 +73689,6 @@ function validateSqlStorageConsistency(contract) {
 		}
 		for (const unique of table.uniques) for (const colName of unique.columns) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" unique constraint references non-existent column "${colName}"`, "storage");
 		for (const index of table.indexes) for (const colName of index.columns ?? []) if (!columnNames.has(colName)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" index references non-existent column "${colName}"`, "storage");
-		for (const check of table.checks ?? []) if (!columnNames.has(check.column)) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" check constraint "${check.name}" references non-existent column "${check.column}"`, "storage");
 		for (const [colName, column] of Object.entries(table.columns)) if (!column.nullable && column.default?.kind === "literal" && column.default.value === null) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" column "${colName}" is NOT NULL but has a literal null default`, "storage");
 		for (const fk of table.foreignKeys) {
 			if (fk.source.namespaceId !== namespaceId || fk.source.tableName !== tableName) throw new ContractValidationError(`Namespace "${namespaceId}" table "${tableName}" contains foreignKey with mismatched source coordinates (${fk.source.namespaceId}.${fk.source.tableName})`, "storage");
@@ -74289,14 +74608,65 @@ const OK_VOID = ResultImpl.ok(void 0);
 function okVoid() {
 	return OK_VOID;
 }
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
 	if (!input) return input;
 	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
 }
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join$1 = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
 function cwd() {
 	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
 	return "/";
 }
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
 function normalizeString(path, allowAboveRoot) {
 	let res = "";
 	let lastSegmentLength = 0;
@@ -74347,107 +74717,38 @@ function normalizeString(path, allowAboveRoot) {
 	}
 	return res;
 }
-var _DRIVE_LETTER_START_RE;
-var _UNC_REGEX;
-var _IS_ABSOLUTE_RE;
-var _DRIVE_LETTER_RE;
-var _ROOT_FOLDER_RE;
-var normalize;
-var join$1;
-var resolve;
-var isAbsolute;
-var relative;
-var dirname$1;
-var basename;
-var init_pathe_M_eThtNZ = __esmMin((() => {
-	_DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
-	_UNC_REGEX = /^[/\\]{2}/;
-	_IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
-	_DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-	_ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
-	normalize = function(path) {
-		if (path.length === 0) return ".";
-		path = normalizeWindowsPath(path);
-		const isUNCPath = path.match(_UNC_REGEX);
-		const isPathAbsolute = isAbsolute(path);
-		const trailingSeparator = path[path.length - 1] === "/";
-		path = normalizeString(path, !isPathAbsolute);
-		if (path.length === 0) {
-			if (isPathAbsolute) return "/";
-			return trailingSeparator ? "./" : ".";
-		}
-		if (trailingSeparator) path += "/";
-		if (_DRIVE_LETTER_RE.test(path)) path += "/";
-		if (isUNCPath) {
-			if (!isPathAbsolute) return `//./${path}`;
-			return `//${path}`;
-		}
-		return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
-	};
-	join$1 = function(...segments) {
-		let path = "";
-		for (const seg of segments) {
-			if (!seg) continue;
-			if (path.length > 0) {
-				const pathTrailing = path[path.length - 1] === "/";
-				const segLeading = seg[0] === "/";
-				if (pathTrailing && segLeading) path += seg.slice(1);
-				else path += pathTrailing || segLeading ? seg : `/${seg}`;
-			} else path += seg;
-		}
-		return normalize(path);
-	};
-	resolve = function(...arguments_) {
-		arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
-		let resolvedPath = "";
-		let resolvedAbsolute = false;
-		for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
-			const path = index >= 0 ? arguments_[index] : cwd();
-			if (!path || path.length === 0) continue;
-			resolvedPath = `${path}/${resolvedPath}`;
-			resolvedAbsolute = isAbsolute(path);
-		}
-		resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
-		if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
-		return resolvedPath.length > 0 ? resolvedPath : ".";
-	};
-	isAbsolute = function(p) {
-		return _IS_ABSOLUTE_RE.test(p);
-	};
-	relative = function(from, to) {
-		const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
-		const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
-		if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
-		const _fromCopy = [..._from];
-		for (const segment of _fromCopy) {
-			if (_to[0] !== segment) break;
-			_from.shift();
-			_to.shift();
-		}
-		return [..._from.map(() => ".."), ..._to].join("/");
-	};
-	dirname$1 = function(p) {
-		const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
-		if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
-		return segments.join("/") || (isAbsolute(p) ? "/" : ".");
-	};
-	basename = function(p, extension) {
-		const segments = normalizeWindowsPath(p).split("/");
-		let lastSegment = "";
-		for (let i = segments.length - 1; i >= 0; i--) {
-			const val = segments[i];
-			if (val) {
-				lastSegment = val;
-				break;
-			}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname$1 = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
 		}
-		return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
-	};
-}));
-var init_dist = __esmMin((() => {
-	init_pathe_M_eThtNZ();
-}));
-init_dist();
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
 /**
 * Build the canonical "re-emit this package" remediation hint.
 *
@@ -74476,40 +74777,30 @@ function reemitHint(dir, fallback) {
 * - category: Always 'MIGRATION'
 * - why:      Explains the cause in plain language
 * - fix:      Actionable remediation step
-* - details:  Machine-readable structured data for agents
+* - meta:     Machine-readable structured data for agents
 */
-var MigrationToolsError = class extends Error {
-	code;
-	category = "MIGRATION";
-	why;
-	fix;
-	details;
+var MigrationToolsError = class extends CliStructuredError {
+	category;
 	constructor(code, summary, options) {
-		super(summary);
-		this.name = "MigrationToolsError";
-		this.code = code;
-		this.why = options.why;
-		this.fix = options.fix;
-		this.details = options.details;
+		super(code, summary, options);
+		this.category = "MIGRATION";
 	}
 	static is(error) {
-		if (!(error instanceof Error)) return false;
-		const candidate = error;
-		return candidate.name === "MigrationToolsError" && typeof candidate.code === "string";
+		return CliStructuredError.is(error) && "category" in error && error.category === "MIGRATION" && error.code.startsWith("MIGRATION.");
 	}
 };
 function errorDirectoryExists(dir) {
 	return new MigrationToolsError("MIGRATION.DIR_EXISTS", "Migration directory already exists", {
 		why: `The directory "${dir}" already exists. Each migration must have a unique directory.`,
 		fix: "Use --name to pick a different name, or delete the existing directory and re-run.",
-		details: { dir }
+		meta: { dir }
 	});
 }
 function errorMissingFile(file, dir) {
 	return new MigrationToolsError("MIGRATION.FILE_MISSING", `Missing ${file}`, {
 		why: `Expected "${file}" in "${dir}" but the file does not exist.`,
 		fix: reemitHint(dir, "or delete the directory if the migration is unwanted and the source TypeScript is gone."),
-		details: {
+		meta: {
 			file,
 			dir
 		}
@@ -74519,7 +74810,7 @@ function errorInvalidJson(filePath, parseError) {
 	return new MigrationToolsError("MIGRATION.INVALID_JSON", "Invalid JSON in migration file", {
 		why: `Failed to parse "${filePath}": ${parseError}`,
 		fix: reemitHint(dirname$1(filePath), "or restore the directory from version control."),
-		details: {
+		meta: {
 			filePath,
 			parseError
 		}
@@ -74529,7 +74820,7 @@ function errorInvalidManifest(filePath, reason) {
 	return new MigrationToolsError("MIGRATION.INVALID_MANIFEST", "Invalid migration manifest", {
 		why: `Migration manifest at "${filePath}" is invalid: ${reason}`,
 		fix: reemitHint(dirname$1(filePath), "or restore the directory from version control."),
-		details: {
+		meta: {
 			filePath,
 			reason
 		}
@@ -74539,21 +74830,21 @@ function errorDescribeMissingEndContract() {
 	return new MigrationToolsError("MIGRATION.DESCRIBE_INVALID", "Migration.describe(): provide endContractJson or override describe() — a migration needs a destination contract hash.", {
 		why: "Migration.describe() was called on a migration that carries no endContractJson and does not override describe(), so no destination contract hash can be derived.",
 		fix: "Set endContractJson on the migration, or override describe() to return the { from, to } metadata explicitly.",
-		details: { reason: "missing-end-contract" }
+		meta: { reason: "missing-end-contract" }
 	});
 }
 function errorSpaceHeadRefMissing(spaceId) {
 	return new MigrationToolsError("MIGRATION.CHECK_HEAD_REF_MISSING", `Contract space "${spaceId}" has no head ref; its contract cannot be resolved from the snapshot store without one.`, {
 		why: `Contract space "${spaceId}" declares no refs/head.json, so there is no hash to resolve its contract against the snapshot store.`,
 		fix: "Re-emit the contract-space migrations and head-ref artifacts (the extension's contract-space build), or restore refs/head.json from version control.",
-		details: { spaceId }
+		meta: { spaceId }
 	});
 }
 function errorInvalidSpaceId(spaceId) {
 	return new MigrationToolsError("MIGRATION.INVALID_SPACE_ID", "Invalid contract space identifier", {
 		why: `The space id "${spaceId}" does not match the required pattern /^[a-z][a-z0-9_-]{0,63}$/. Space ids are used as filesystem directory names under \`migrations/\`, so the pattern is conservative on purpose.`,
 		fix: "Pick a lowercase identifier that begins with a letter and contains only lowercase letters, digits, hyphens, or underscores; max 64 characters total.",
-		details: { spaceId }
+		meta: { spaceId }
 	});
 }
 function errorDescriptorHeadHashMismatch(args) {
@@ -74561,7 +74852,7 @@ function errorDescriptorHeadHashMismatch(args) {
 	return new MigrationToolsError("MIGRATION.DESCRIPTOR_HEAD_HASH_MISMATCH", "Extension descriptor's headRef.hash does not match its contractJson", {
 		why: `Extension "${extensionId}" publishes a \`contractSpace\` whose \`headRef.hash\` (${headRefHash}) does not match the canonical hash recomputed from \`contractSpace.contractJson\` (${recomputedHash}). This means the extension descriptor was published with stale \`headRef.hash\` — typically because the contract was bumped without rerunning the extension's emit pipeline.`,
 		fix: "Re-run the extension authoring pipeline so `contractJson.storage.storageHash` and `headRef.hash` agree, then republish the extension. If you are the extension author and you intentionally bumped `contractJson`, recompute and update `headRef.hash` (and refresh any on-disk migration metadata that derives from it).",
-		details: {
+		meta: {
 			extensionId,
 			recomputedHash,
 			headRefHash
@@ -74572,7 +74863,7 @@ function errorInvalidRefFile(filePath, reason) {
 	return new MigrationToolsError("MIGRATION.INVALID_REF_FILE", "Invalid ref file", {
 		why: `Ref file at "${filePath}" is invalid: ${reason}`,
 		fix: "Ensure the ref file contains valid JSON with { \"hash\": \"<64 hex chars>\", \"invariants\": [\"...\"] }.",
-		details: {
+		meta: {
 			path: filePath,
 			reason
 		}
@@ -74582,21 +74873,21 @@ function errorInvalidRefName(refName) {
 	return new MigrationToolsError("MIGRATION.INVALID_REF_NAME", "Invalid ref name", {
 		why: `Ref name "${refName}" is invalid. Names must be lowercase alphanumeric with hyphens or forward slashes (no "." or ".." segments).`,
 		fix: `Use a valid ref name (e.g., "staging", "envs/production").`,
-		details: { refName }
+		meta: { refName }
 	});
 }
 function errorInvalidInvariantId(invariantId) {
 	return new MigrationToolsError("MIGRATION.INVALID_INVARIANT_ID", "Invalid invariantId", {
 		why: `invariantId ${JSON.stringify(invariantId)} is invalid. Ids must be non-empty and contain no whitespace or control characters (including Unicode whitespace like NBSP); other content (kebab-case, camelCase, namespaced, Unicode letters) is allowed.`,
 		fix: "Pick an invariantId without spaces, tabs, newlines, or control characters — e.g. \"backfill-user-phone\", \"users/backfill-phone\", or \"BackfillUserPhone\".",
-		details: { invariantId }
+		meta: { invariantId }
 	});
 }
 function errorDuplicateInvariantInEdge(invariantId) {
 	return new MigrationToolsError("MIGRATION.DUPLICATE_INVARIANT_IN_EDGE", "Duplicate invariantId on a single migration", {
 		why: `invariantId "${invariantId}" is declared by more than one dataTransform on the same migration. The marker stores invariants as a set and the routing layer treats them as edge-level, so two ops cannot share a routing identity.`,
 		fix: "Rename one of the conflicting dataTransform invariantIds, or drop invariantId on the op that does not need to be routing-visible.",
-		details: { invariantId }
+		meta: { invariantId }
 	});
 }
 function errorProvidedInvariantsMismatch(filePath, stored, derived) {
@@ -74607,7 +74898,7 @@ function errorProvidedInvariantsMismatch(filePath, stored, derived) {
 	return new MigrationToolsError("MIGRATION.PROVIDED_INVARIANTS_MISMATCH", "providedInvariants on migration.json disagrees with ops.json", {
 		why: missing.length === 0 && extra.length === 0 ? `migration.json at "${filePath}" stores providedInvariants ${JSON.stringify(stored)}, but the canonical value derived from ops.json is ${JSON.stringify(derived)} — same ids, different order. Canonical providedInvariants is sorted ascending.` : `migration.json at "${filePath}" stores providedInvariants ${JSON.stringify(stored)}, but the value derived from ops.json is ${JSON.stringify(derived)}. The manifest copy was likely hand-edited without re-emitting.`,
 		fix: reemitHint(dirname$1(filePath), "or restore the directory from version control."),
-		details: {
+		meta: {
 			filePath,
 			stored,
 			derived,
@@ -74625,7 +74916,7 @@ function errorNoInvariantPath(args) {
 	return new MigrationToolsError("MIGRATION.NO_INVARIANT_PATH", "No path covers the required invariants", {
 		why: `${refClause} requires invariants the reachable path doesn't cover. required=[${required.map((id) => JSON.stringify(id)).join(", ")}], missing=[${missingList}].`,
 		fix: "Add a migration on the path that runs `dataTransform({ invariantId: \"<id>\", … })` for each missing invariant, or retarget the ref to a hash whose path already provides them.",
-		details: {
+		meta: {
 			required,
 			missing,
 			structuralPath,
@@ -74637,7 +74928,7 @@ function errorMigrationHashMismatch(dir, storedHash, computedHash) {
 	return new MigrationToolsError("MIGRATION.HASH_MISMATCH", "Migration package is corrupt", {
 		why: `Stored migrationHash "${storedHash}" does not match the recomputed hash "${computedHash}" for "${relative(process.cwd(), dir)}". The migration.json or ops.json has been edited or partially written since emit.`,
 		fix: reemitHint(dir, "or restore the directory from version control."),
-		details: {
+		meta: {
 			dir,
 			storedHash,
 			computedHash
@@ -74653,8 +74944,24 @@ function errorMigrationHashMismatch(dir, storedHash, computedHash) {
 function errorRefNotResolvable(refName) {
 	return new MigrationToolsError("MIGRATION.REF_NOT_RESOLVABLE", `Ref "${refName}" is not resolvable`, {
 		why: `Ref "${refName}" has no pointer file, and the hash being resolved is not a node in the migration graph either — there is nothing to materialize a contract from.`,
-		fix: `Create the ref with "prisma-next ref set ${refName} <hash>" (or advance it via "prisma-next db update --advance-ref ${refName}"), or pass a hash that is a node in the migration graph.`,
-		details: {
+		fix: `Create the ref with "prisma ref set ${refName} <hash>" (or advance it via "prisma db update --advance-ref ${refName}"), or pass a hash that is a node in the migration graph.`,
+		nextActions: [
+			{
+				kind: "run-command",
+				label: `Create the ref "${refName}"`,
+				command: `{bin} ref set ${refName} <hash>`
+			},
+			{
+				kind: "run-command",
+				label: `Advance the ref "${refName}" as part of an update`,
+				command: `{bin} db update --advance-ref ${refName}`
+			},
+			{
+				kind: "user-choice",
+				label: "Pass a hash that is already a node in the migration graph"
+			}
+		],
+		meta: {
 			refName,
 			identifier: refName
 		}
@@ -74664,20 +74971,21 @@ function errorBundleNotFoundForGraphNode(hash, explicitLabel) {
 	return new MigrationToolsError("MIGRATION.BUNDLE_NOT_FOUND_FOR_GRAPH_NODE", explicitLabel ? `No migration bundle found for reference "${explicitLabel}" (resolved hash: ${hash})` : `No migration bundle found for graph node ${hash}`, {
 		why: `The hash ${hash} is a graph node but no on-disk migration package has a destination (\`to\`) hash matching it.`,
 		fix: "Provide a ref or hash that corresponds to an existing migration package, or run `migration list` to see available migrations.",
-		details: {
+		meta: {
 			hash,
 			...explicitLabel ? { explicitLabel } : {}
 		}
 	});
 }
-function errorContractDeserializationFailed(filePath, message) {
+function errorContractDeserializationFailed(filePath, message, options) {
 	return new MigrationToolsError("MIGRATION.CONTRACT_DESERIALIZATION_FAILED", "Contract failed to deserialize", {
 		why: `Contract at "${filePath}" failed to deserialize: ${message}`,
 		fix: reemitHint(dirname$1(filePath), "or restore the directory from version control."),
-		details: {
+		meta: {
 			filePath,
 			message
-		}
+		},
+		...ifDefined("cause", options?.cause)
 	});
 }
 function errorHashNotInGraph(hash, graph) {
@@ -74685,8 +74993,17 @@ function errorHashNotInGraph(hash, graph) {
 	const reachableList = reachableHashes.length > 0 ? reachableHashes.join(", ") : "(none)";
 	return new MigrationToolsError("MIGRATION.HASH_NOT_IN_GRAPH", `Hash "${hash}" is not a node in the migration graph`, {
 		why: `The migration graph contains nodes ${reachableList}; "${hash}" isn't one of them.`,
-		fix: `Pass a hash that's the from-or-to of an on-disk migration bundle, use --from with a graph-node hash, or run "prisma-next migration plan" to introduce it.`,
-		details: {
+		fix: `Pass a hash that's the from-or-to of an on-disk migration bundle, use --from with a graph-node hash, or run "prisma migration plan" to introduce it.`,
+		nextActions: [{
+			kind: "user-choice",
+			label: "Pass a hash that is the from-or-to of an on-disk migration bundle, or use --from with a graph-node hash",
+			reason: `Graph nodes: ${reachableList}.`
+		}, {
+			kind: "run-command",
+			label: `Introduce "${hash}" by planning a migration for it`,
+			command: "{bin} migration plan"
+		}],
+		meta: {
 			hash,
 			reachableHashes
 		}
@@ -74695,8 +75012,23 @@ function errorHashNotInGraph(hash, graph) {
 function errorContractSnapshotMissing(storageHash, expectedPath) {
 	return new MigrationToolsError("MIGRATION.CONTRACT_SNAPSHOT_MISSING", "Contract snapshot is missing", {
 		why: `Expected a contract snapshot for ${storageHash} at "${expectedPath}" but the file does not exist.`,
-		fix: "Re-emit the contract snapshot by re-running the command that authored the migration referencing this hash (`prisma-next migration plan` for app-space migrations; the extension's contract-space build for extension spaces), or restore migrations/snapshots/ from version control.",
-		details: {
+		fix: "Re-emit the contract snapshot by re-running the command that authored the migration referencing this hash (`prisma migration plan` for app-space migrations; the extension's contract-space build for extension spaces), or restore migrations/snapshots/ from version control.",
+		nextActions: [
+			{
+				kind: "run-command",
+				label: "Re-emit the snapshot for an app-space migration",
+				command: "{bin} migration plan"
+			},
+			{
+				kind: "user-choice",
+				label: "For an extension space, re-run that extension's contract-space build instead"
+			},
+			{
+				kind: "user-choice",
+				label: "Restore migrations/snapshots/ from version control"
+			}
+		],
+		meta: {
 			storageHash,
 			expectedPath
 		}
@@ -74706,7 +75038,7 @@ function errorContractSnapshotHashMismatch(storageHash, actualHash, dir) {
 	return new MigrationToolsError("MIGRATION.CONTRACT_SNAPSHOT_HASH_MISMATCH", "Contract snapshot hash mismatch", {
 		why: `The contract JSON's inner storage.storageHash ("${actualHash}") does not match the requested storage hash ("${storageHash}") for snapshot directory "${dir}".`,
 		fix: "Pass a contractJson whose storage.storageHash equals the storageHash argument passed to writeContractSnapshot — the two must agree by construction.",
-		details: {
+		meta: {
 			storageHash,
 			actualHash,
 			dir
@@ -74717,14 +75049,13 @@ function errorMigrationContractViewMissing(className, accessor, jsonField) {
 	return new MigrationToolsError("MIGRATION.CONTRACT_VIEW_MISSING", `${className}.${accessor} requires ${jsonField}`, {
 		why: `${className}.${accessor} was read, but this instance has no ${jsonField} to build the view from.`,
 		fix: `Set ${jsonField} to the migration's committed contract JSON, or avoid reading ${accessor} on a migration that overrides describe() and carries no contract.`,
-		details: {
+		meta: {
 			className,
 			accessor,
 			jsonField
 		}
 	});
 }
-init_dist();
 const CONTRACT_JSON_FILE = "contract.json";
 const CONTRACT_DTS_FILE = "contract.d.ts";
 function hasErrnoCode$3(error, code) {
@@ -74942,7 +75273,6 @@ const MigrationOpsSchema = type({
 	operationClass: "'additive' | 'widening' | 'destructive' | 'data'",
 	"invariantId?": "string"
 }).array();
-init_dist();
 const MANIFEST_FILE = "migration.json";
 const OPS_FILE = "ops.json";
 function hasErrnoCode$2(error, code) {
@@ -75178,14 +75508,14 @@ async function readMigrationsDir(migrationsRoot, options) {
 			const dirName = entry;
 			if (MigrationToolsError.is(error)) {
 				if (error.code === "MIGRATION.HASH_MISMATCH") {
-					const details = error.details;
+					const meta = error.meta;
 					const rawPkg = await readMigrationPackageRaw(entryPath);
 					if (rawPkg !== null) packages.push(rawPkg);
 					problems.push({
 						kind: "hashMismatch",
 						dirName,
-						stored: typeof details?.["storedHash"] === "string" ? details["storedHash"] : "",
-						computed: typeof details?.["computedHash"] === "string" ? details["computedHash"] : ""
+						stored: typeof meta?.["storedHash"] === "string" ? meta["storedHash"] : "",
+						computed: typeof meta?.["computedHash"] === "string" ? meta["computedHash"] : ""
 					});
 					continue;
 				}
@@ -75213,7 +75543,6 @@ async function readMigrationsDir(migrationsRoot, options) {
 		problems
 	};
 }
-init_dist();
 /**
 * Pattern a contract-space identifier must match. The constraint is
 * filesystem-friendly: lowercase letters / digits / hyphen / underscore,
@@ -75709,7 +76038,6 @@ function invariantViableAlternativesAtStep(required, coverageBeforeTakingEdge, o
 	if (required.size === 0) return [...outgoing];
 	return outgoing.filter((e) => [...required].every((id) => coverageBeforeTakingEdge.has(id) || e.invariants.includes(id)));
 }
-init_dist();
 /**
 * Assert that an extension descriptor is self-consistent: the
 * `headRef.hash` it publishes must match the canonical hash recomputed
@@ -75726,7 +76054,7 @@ init_dist();
 *
 * Synchronous, pure, no I/O. Throws
 * `MIGRATION.DESCRIPTOR_HEAD_HASH_MISMATCH` on failure with both the
-* recomputed and published hashes in `details` so callers can surface a
+* recomputed and published hashes in `meta` so callers can surface a
 * clear remediation hint without re-deriving them.
 */
 function assertDescriptorSelfConsistency(inputs) {
@@ -76411,70 +76739,11 @@ function resolveColumnTypeMetadata$1(column, storageTypes) {
 	};
 	throw new InternalError(`Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`);
 }
-/**
-* Resolves a `ValueSetRef` to its permitted values from the contract storage.
-*
-* Throws when the referenced namespace or value-set is absent — this indicates
-* the contract was built incorrectly (the check and the value-set must be
-* co-emitted by the lowering step). Used by `convertCheck` (schema-IR
-* projection), `verifyCheckConstraints` (verification), and
-* `checkConstraintPlanCallStrategy` (migration planning) so all three agree on
-* the resolved values and the error behavior on a missing reference.
-*/
-function allStrings(values) {
-	return values.every((value) => typeof value === "string");
-}
-function resolveValueSetValues(ref, storage, contextLabel) {
-	const ns = storage.namespaces[ref.namespaceId];
-	if (!ns) throw sqlFamilyError("CONTRACT.NAMESPACE_UNKNOWN", `resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`, {
-		why: "A value-set reference names a namespace the contract storage does not declare.",
-		fix: "Regenerate the contract from its authoring source; do not hand-edit contract JSON.",
-		meta: {
-			namespaceId: ref.namespaceId,
-			context: contextLabel
-		}
-	});
-	const valueSet = ns.entries.valueSet?.[ref.entityName];
-	if (!valueSet) throw sqlFamilyError("CONTRACT.ENUM_UNKNOWN", `resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`, {
-		why: "A value-set reference names an entry its namespace does not declare.",
-		fix: "Regenerate the contract from its authoring source; do not hand-edit contract JSON.",
-		meta: {
-			valueSet: ref.entityName,
-			namespaceId: ref.namespaceId,
-			context: contextLabel
-		}
-	});
-	const values = valueSet.values;
-	if (!allStrings(values)) throw sqlFamilyError("CONTRACT.ENUM_INVALID", `resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`, {
-		why: "Only string value-sets can be rendered as CHECK constraints; this value-set carries a non-string value.",
-		fix: "Use string enum values, or drop the CHECK-constrained enum until numeric enums are supported.",
-		meta: {
-			valueSet: ref.entityName,
-			namespaceId: ref.namespaceId,
-			context: contextLabel
-		}
-	});
-	return values;
-}
-/**
-* Projects a `CheckConstraint` IR into an `SqlCheckConstraintIRInput` by
-* resolving the permitted values from the storage value-set it references.
-*
-* The `CheckConstraint.valueSet` ref points to
-* `storage.namespaces[namespaceId].entries.valueSet[name]`. The resolved
-* values are lifted directly from `StorageValueSet.values` so verification
-* compares value sets, not SQL predicate strings.
-*
-* Throws if the referenced namespace or value-set is absent — this
-* indicates the contract was built incorrectly (the check and the
-* value-set must be co-emitted by the lowering step).
-*/
-function convertCheck(check, storage) {
-	const permittedValues = resolveValueSetValues(check.valueSet, storage, `check "${check.name}"`);
+function convertCheck(check, tableName, tableColumns) {
 	return {
-		name: check.name,
-		column: check.column,
-		permittedValues
+		naming: namingOf(check.name, check.prefix),
+		expression: check.expression,
+		dependsOn: flatColumnDependsOn(tableName, tableColumns)
 	};
 }
 function convertUnique(unique, tableName) {
@@ -76572,7 +76841,7 @@ function convertForeignKey(fk, storage) {
 function convertTable(name, table, storageTypes, expandNativeType, renderDefault, resolveDefault, storage) {
 	const columns = {};
 	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault, resolveDefault);
-	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, storage)) : void 0;
+	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, name, Object.keys(table.columns))) : void 0;
 	return new SqlTableIR({
 		name,
 		columns,
@@ -76947,6 +77216,19 @@ function runnerFailure(code, summary, options) {
 Object.freeze({ allowedOperationClasses: Object.freeze(["additive"]) });
 var control_default = new SqlFamilyDescriptor();
 /**
+* Name of the synthesised namespace bucket the framework parser uses for
+* top-level declarations that appear outside any `namespace { … }` block.
+* The double-underscore decoration signals that the identifier is parser-
+* synthesised and never appears in user-authored PSL source — writing
+* `namespace __unspecified__ { … }` is a parse error.
+*
+* Distinct from the IR sentinel `__unbound__`: the PSL bucket describes
+* syntactic absence at the parser layer; the IR sentinel describes a late-
+* bound storage slot at the IR layer. Per-target interpreters decide how
+* (or whether) to map the PSL bucket to the IR sentinel.
+*/
+const UNSPECIFIED_PSL_NAMESPACE_ID = "__unspecified__";
+/**
 * Stores `entries`; exposes `models`/`enums`/`compositeTypes` as getters over
 * it. The getters are prototype members (non-enumerable), so spreading or
 * `JSON.stringify`-ing a namespace copies only `entries`, never a duplicate view.
@@ -78193,6 +78475,10 @@ var PostgresControlDriver = class {
 			throw normalizePgError(error);
 		}
 	}
+	async databaseName() {
+		const name = (await this.query("select current_database() as name")).rows[0]?.name;
+		return typeof name === "string" && name.length > 0 ? name : void 0;
+	}
 	async close() {
 		await this.client.end().catch(() => {});
 	}
@@ -78216,18 +78502,53 @@ const postgresDriverDescriptor = {
 			} catch {}
 			const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : void 0;
 			const causeCode = "cause" in normalized && normalized.cause ? normalized.cause.code : void 0;
-			const code = codeFromSqlState ?? causeCode;
-			throw errorRuntime("Database connection failed", {
+			const sqlState = codeFromSqlState ?? causeCode;
+			throw errorRuntime("DRIVER.CONNECTION_FAILED", "Database connection failed", {
 				why: normalized.message,
 				fix: "Verify the database URL, ensure the database is reachable, and confirm credentials/permissions",
 				meta: {
-					...ifDefined("code", code),
+					...ifDefined("sqlState", sqlState),
 					...redacted
-				}
+				},
+				cause: error
 			});
 		}
 	}
 };
+/**
+* Renders the checks a Postgres column needs, as opaque predicate text.
+*
+* A text-backed domain enum has no type-level enforcement, so membership is a
+* predicate: `IN` for a scalar, and `<@` containment for an array — an array
+* column cannot use `IN` at all (`operator does not exist: text[] = text`),
+* and containment additionally rejects NULL elements. Every list column also
+* gets an element-non-null check, which no Postgres column type can express.
+*
+* The array side casts the COLUMN to `text[]` rather than assuming its element
+* type already is: `<@` needs both operands in one type, so a `varchar[]` or
+* `char[]` column meeting a bare `text[]` literal raises the same
+* `operator does not exist` this project exists to eliminate. The scalar `IN`
+* form needs no cast — `varchar = text` resolves on its own.
+*/
+function postgresRenderCheckExpressions(input) {
+	const candidates = [];
+	const column = quoteIdentifier(input.columnName);
+	if (input.memberValues !== void 0) {
+		invariant(input.memberValues.length > 0, `check for "${input.tableName}"."${input.columnName}": empty member set; both authoring surfaces reject a member-less enum before rendering`);
+		const members = input.memberValues.map((value) => `'${escapeLiteral(value)}'`).join(", ");
+		candidates.push({
+			kind: "membership",
+			columnName: input.columnName,
+			expression: input.many ? `${column}::text[] <@ ARRAY[${members}]::text[]` : `${column} IN (${members})`
+		});
+	}
+	if (input.many) candidates.push({
+		kind: "elementNotNull",
+		columnName: input.columnName,
+		expression: `array_position(${column}, NULL) IS NULL`
+	});
+	return candidates;
+}
 /** Postgres's default schema; `postgresTargetDescriptorMeta.defaultNamespaceId` is this value. */
 const DEFAULT_NAMESPACE_ID = "public";
 /**
@@ -78298,14 +78619,30 @@ const PSL_ROLE_BLOCK_OUTSIDE_UNBOUND_NAMESPACE = "PSL_ROLE_BLOCK_OUTSIDE_UNBOUND
 * descriptor's `columnFromEntity` hook (see `codecs.ts`) converts that
 * entity into the column's `typeParams` and native type.
 */
-const postgresAuthoringTypes = { pg: { enum: {
-	kind: "typeConstructor",
-	entityRefArg: {
-		index: 0,
-		entityKind: "native_enum"
+const postgresAuthoringTypes = {
+	BigIntNumber: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "pg/int8number@1",
+			nativeType: "int8"
+		}
 	},
-	output: { codecId: PG_ENUM_CODEC_ID }
-} } };
+	UnboundedInt: {
+		kind: "typeConstructor",
+		output: {
+			codecId: "pg/unboundedint@1",
+			nativeType: "numeric"
+		}
+	},
+	pg: { enum: {
+		kind: "typeConstructor",
+		entityRefArg: {
+			index: 0,
+			entityKind: "native_enum"
+		},
+		output: { codecId: PG_ENUM_CODEC_ID }
+	} }
+};
 /**
 * Maps a `policy_<op>` keyword to the RLS operation it authors. The keyword
 * IS the operation (per the project's rejection of a `policy { operation = … }`
@@ -79042,6 +79379,7 @@ const postgresTargetDescriptorMeta = {
 		modelAttributes: postgresAuthoringModelAttributes,
 		createNamespace: postgresCreateNamespace,
 		qualifyColumnType: postgresQualifyColumnType,
+		renderCheckExpressions: postgresRenderCheckExpressions,
 		lowerEntityHandles: postgresLowerEntityHandles
 	}
 };
@@ -79651,9 +79989,8 @@ async function addForeignKey(schemaName, tableName, fk, lowerer) {
 		postcheck: [step(`verify FK "${fk.name}" exists`, present.sql, present.params)]
 	};
 }
-async function addCheckConstraint(schemaName, tableName, constraintName, column, values, lowerer) {
+async function addCheckConstraint(schemaName, tableName, constraintName, expression, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
-	const valueList = values.map((v) => `'${escapeLiteral(v)}'`).join(", ");
 	const { absent, present } = await constraintCheckSteps(lowerer, {
 		constraintName,
 		schema: schemaName,
@@ -79661,14 +79998,36 @@ async function addCheckConstraint(schemaName, tableName, constraintName, column,
 	});
 	return {
 		id: `checkConstraint.${tableName}.${constraintName}`,
-		label: `Add check constraint "${constraintName}" on "${tableName}"."${column}"`,
+		label: `Add check constraint "${constraintName}" on "${tableName}"`,
 		operationClass: "additive",
 		target: targetDetails("checkConstraint", constraintName, schemaName, tableName),
 		precheck: [step(`ensure constraint "${constraintName}" does not exist`, absent.sql, absent.params)],
-		execute: [step(`add check constraint "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} CHECK (${quoteIdentifier(column)} IN (${valueList}))`)],
+		execute: [step(`add check constraint "${constraintName}"`, `ALTER TABLE ${qualified} ADD CONSTRAINT ${quoteIdentifier(constraintName)} CHECK (${expression})`)],
 		postcheck: [step(`verify constraint "${constraintName}" exists`, present.sql, present.params)]
 	};
 }
+async function renameCheckConstraint(schemaName, tableName, fromName, toName, lowerer) {
+	const qualified = qualifyTableName(schemaName, tableName);
+	const from = await constraintCheckSteps(lowerer, {
+		constraintName: fromName,
+		schema: schemaName,
+		table: tableName
+	});
+	const to = await constraintCheckSteps(lowerer, {
+		constraintName: toName,
+		schema: schemaName,
+		table: tableName
+	});
+	return {
+		id: `checkConstraint.${schemaName}.${tableName}.${fromName}.rename`,
+		label: `Rename check constraint "${fromName}" to "${toName}" on "${tableName}"`,
+		operationClass: "widening",
+		target: targetDetails("checkConstraint", toName, schemaName, tableName),
+		precheck: [step(`ensure constraint "${fromName}" exists`, from.present.sql, from.present.params), step(`ensure constraint "${toName}" does not exist`, to.absent.sql, to.absent.params)],
+		execute: [step(`rename check constraint "${fromName}" to "${toName}"`, `ALTER TABLE ${qualified} RENAME CONSTRAINT ${quoteIdentifier(fromName)} TO ${quoteIdentifier(toName)}`)],
+		postcheck: [step(`verify constraint "${toName}" exists`, to.present.sql, to.present.params)]
+	};
+}
 async function dropCheckConstraint(schemaName, tableName, constraintName, lowerer) {
 	const qualified = qualifyTableName(schemaName, tableName);
 	const { absent, present } = await constraintCheckSteps(lowerer, {
@@ -80750,31 +81109,63 @@ var DropConstraintCall = class extends PostgresOpFactoryCallNode {
 		return [];
 	}
 };
+var RenameCheckConstraintCall = class extends PostgresOpFactoryCallNode {
+	factoryName = "renameCheckConstraint";
+	operationClass = "widening";
+	schemaName;
+	tableName;
+	oldConstraintName;
+	newConstraintName;
+	label;
+	constructor(schemaName, tableName, oldConstraintName, newConstraintName) {
+		super();
+		this.schemaName = schemaName;
+		this.tableName = tableName;
+		this.oldConstraintName = oldConstraintName;
+		this.newConstraintName = newConstraintName;
+		this.label = `Rename check constraint "${oldConstraintName}" to "${newConstraintName}" on "${tableName}"`;
+		this.freeze();
+	}
+	async toOp(lowerer) {
+		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `RenameCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.oldConstraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "RenameCheckConstraintCall" } });
+		return renameCheckConstraint(this.schemaName, this.tableName, this.oldConstraintName, this.newConstraintName, lowerer);
+	}
+	renderTypeScript() {
+		const opts = [];
+		if (this.schemaName !== "__unbound__") opts.push(`schema: ${jsonToTsSource(this.schemaName)}`);
+		opts.push(`table: ${jsonToTsSource(this.tableName)}`);
+		opts.push(`from: ${jsonToTsSource(this.oldConstraintName)}`);
+		opts.push(`to: ${jsonToTsSource(this.newConstraintName)}`);
+		return `this.renameCheckConstraint({ ${opts.join(", ")} })`;
+	}
+	importRequirements() {
+		return [];
+	}
+};
 var AddCheckConstraintCall = class extends PostgresOpFactoryCallNode {
 	factoryName = "addCheckConstraint";
 	operationClass = "additive";
 	schemaName;
 	tableName;
 	constraintName;
-	column;
-	values;
+	/** Opaque SQL: the predicate body, rendered verbatim inside `CHECK (…)`. */
+	expression;
 	label;
-	constructor(schemaName, tableName, constraintName, column, values) {
+	constructor(schemaName, tableName, constraintName, expression) {
 		super();
 		this.schemaName = schemaName;
 		this.tableName = tableName;
 		this.constraintName = constraintName;
-		this.column = column;
-		this.values = values;
-		this.label = `Add check constraint "${constraintName}" on "${tableName}"."${column}"`;
+		this.expression = expression;
+		this.label = `Add check constraint "${constraintName}" on "${tableName}"`;
 		this.freeze();
 	}
 	async toOp(lowerer) {
 		if (lowerer === void 0) throw postgresError("MIGRATION.POSTGRES_CONTROL_STACK_MISSING", `AddCheckConstraintCall.toOp: a lowerer is required on the Postgres planner path (constraint "${this.constraintName}" on table "${this.tableName}"). Pass the control adapter to createPostgresMigrationPlanner.`, { meta: { factory: "AddCheckConstraintCall" } });
-		return addCheckConstraint(this.schemaName, this.tableName, this.constraintName, this.column, this.values, lowerer);
+		return addCheckConstraint(this.schemaName, this.tableName, this.constraintName, this.expression, lowerer);
 	}
 	renderTypeScript() {
-		return `this.addCheckConstraint({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)}, column: ${jsonToTsSource(this.column)}, values: ${jsonToTsSource(this.values)} })`;
+		return `this.addCheckConstraint({ ${constraintCallOptions(this.schemaName, this.tableName, this.constraintName)}, expression: ${jsonToTsSource(this.expression)} })`;
 	}
 	importRequirements() {
 		return [];
@@ -81542,21 +81933,6 @@ function tableAt(storage, namespaceId, tableName) {
 	return ns.entries.table?.[tableName];
 }
 /**
-* Resolve the DDL schema name for a namespace coordinate. Postgres-aware
-* namespaces dispatch to their polymorphic `ddlSchemaName` override —
-* named schemas return their own id; the unbound singleton returns
-* `UNBOUND_NAMESPACE_ID`. Legacy single-namespace contracts whose
-* `__unbound__` slot is the framework-default `SqlUnboundNamespace`
-* (rather than the Postgres-aware `PostgresUnboundSchema`) flow the
-* coordinate through unchanged so downstream `qualifyTableName`
-* resolves polymorphically.
-*/
-function resolveDdlSchemaForNamespace(ctx, namespaceId) {
-	const namespace = ctx.toContract.storage.namespaces[namespaceId];
-	if (isPostgresSchema(namespace)) return namespace.ddlSchemaName(ctx.toContract.storage);
-	return namespaceId;
-}
-/**
 * Recovers the contract namespace id for a DDL schema name embedded in a
 * diff-issue path (`path[1]`). The strategies need the CONTRACT column/table
 * (for codec-hook reads and eligibility probes the retained subsystems still
@@ -81709,90 +82085,6 @@ const nullableTighteningCallStrategy = (issues, ctx) => {
 	};
 };
 /**
-* Collects every check constraint from a table in the contract storage.
-* Returns an empty array when the table has no checks or the table is absent.
-*/
-function collectContractChecks(storage, namespaceId, tableName) {
-	const ns = storage.namespaces[namespaceId];
-	const tableRaw = ns !== void 0 ? ns.entries.table?.[tableName] : void 0;
-	if (!(tableRaw instanceof StorageTable)) return [];
-	const checks = tableRaw.checks;
-	if (!checks || checks.length === 0) return [];
-	return checks.map((c) => ({
-		name: c.name,
-		column: c.column,
-		permittedValues: resolveValueSetValues(c.valueSet, storage, `check "${c.name}" on "${tableName}"`)
-	}));
-}
-/**
-* Compares two value arrays as unordered sets.
-*/
-function checkValueSetsEqual(a, b) {
-	if (a.length !== b.length) return false;
-	const bSet = new Set(b);
-	return a.every((v) => bSet.has(v));
-}
-/**
-* Plans check-constraint migrations for `enumType`-authored columns.
-*
-* Walks every namespace's tables in the target contract (the check nodes'
-* resolved `permittedValues` are ultimately sourced from the same
-* contract-declared value sets, so walking the contract directly is the
-* simplest faithful port — the strategy's decisions never depend on which
-* ISSUES happen to be in the input list, only on the contract + live schema
-* shapes). For each table that carries `checks`, diffs the contract-expected
-* checks against the live schema's checks:
-*
-* - Check in contract, absent from live DB → `AddCheckConstraintCall`.
-* - Check in live DB, absent from contract → `DropCheckConstraintCall`.
-* - Check on both sides but value sets differ → `DropCheckConstraintCall`
-*   then `AddCheckConstraintCall` (drop + recreate; a check predicate cannot
-*   be altered in place).
-*
-* Consumes every `sql-check-constraint` issue on a table this walk handles
-* (not-found/not-expected/not-equal), leaving check issues on tables with
-* NO contract checks to `mapNodeIssueToCall`'s `not-expected` fallback.
-*/
-const checkConstraintPlanCallStrategy = (issues, ctx) => {
-	const calls = [];
-	const handledIssueKeys = /* @__PURE__ */ new Set();
-	for (const [namespaceId, ns] of Object.entries(ctx.toContract.storage.namespaces)) for (const tableName of Object.keys(ns.entries.table ?? {})) {
-		const contractChecks = collectContractChecks(ctx.toContract.storage, namespaceId, tableName);
-		if (contractChecks.length === 0) continue;
-		const liveChecks = ctx.schema.tables[tableName]?.checks ?? [];
-		const ddlSchema = resolveDdlSchemaForNamespace(ctx, namespaceId);
-		for (const contractCheck of contractChecks) {
-			const liveCheck = liveChecks.find((c) => c.name === contractCheck.name);
-			const issueKey = `${tableName} ${contractCheck.name}`;
-			if (!liveCheck) {
-				calls.push(new AddCheckConstraintCall(ddlSchema, tableName, contractCheck.name, contractCheck.column, contractCheck.permittedValues));
-				handledIssueKeys.add(issueKey);
-			} else if (!checkValueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) {
-				calls.push(new DropCheckConstraintCall(ddlSchema, tableName, contractCheck.name), new AddCheckConstraintCall(ddlSchema, tableName, contractCheck.name, contractCheck.column, contractCheck.permittedValues));
-				handledIssueKeys.add(issueKey);
-			} else handledIssueKeys.add(issueKey);
-		}
-		for (const liveCheck of liveChecks) if (!contractChecks.some((c) => c.name === liveCheck.name)) {
-			const issueKey = `${tableName} ${liveCheck.name}`;
-			calls.push(new DropCheckConstraintCall(ddlSchema, tableName, liveCheck.name));
-			handledIssueKeys.add(issueKey);
-		}
-	}
-	if (calls.length === 0 && handledIssueKeys.size === 0) return { kind: "no_match" };
-	return {
-		kind: "match",
-		issues: issues.filter((issue) => {
-			const node = issueNode(issue);
-			if (node === void 0 || node.nodeKind !== RelationalSchemaNodeKind.check) return true;
-			const tableName = issueTableName(issue);
-			if (tableName === void 0) return true;
-			const checkName = blindCast(node).name;
-			return !handledIssueKeys.has(`${tableName} ${checkName}`);
-		}),
-		calls
-	};
-};
-/**
 * Dispatches codec-typed storage types through their codec's
 * `planTypeOperations` hook (the authoritative source for codec-driven DDL
 * such as custom type creation). Codec extension/type ops are not modeled as
@@ -81938,28 +82230,9 @@ const postgresPlannerStrategies = [
 	notNullBackfillCallStrategy,
 	typeChangeCallStrategy,
 	nullableTighteningCallStrategy,
-	checkConstraintPlanCallStrategy,
 	storageTypePlanCallStrategy,
 	notNullAddColumnCallStrategy
 ];
-/**
-* Deterministic name for the element-non-null CHECK constraint on a scalar-array
-* column. Distinct `_elem_not_null` suffix avoids collision with the enum
-* value-set `_check` constraints. Re-emitting the same schema produces the same
-* name, so `pg_get_constraintdef`-based verify sees no drift.
-*/
-function elementNonNullCheckName(tableName, columnName) {
-	return `${tableName}_${columnName}_elem_not_null`;
-}
-/**
-* Predicate enforcing that a scalar-array column carries no NULL element. The
-* array column itself may be NULL (container nullability is the column's NOT NULL
-* clause); `array_position` over a NULL array yields NULL, which a CHECK treats
-* as satisfied, so a nullable array column is unaffected.
-*/
-function elementNonNullCheckExpression(columnName) {
-	return `array_position(${quoteIdentifier(columnName)}, NULL) IS NULL`;
-}
 function issueConflict(kind, summary, location) {
 	return {
 		kind,
@@ -81994,7 +82267,8 @@ function classifyCall(call) {
 		case "dropCheckConstraint":
 		case "dropIndex":
 		case "dropDefault": return "drop";
-		case "addCheckConstraint": return "unique";
+		case "addCheckConstraint":
+		case "renameCheckConstraint": return "unique";
 		case "createTable": return "table";
 		case "enableRowLevelSecurity":
 		case "disableRowLevelSecurity": return "rlsEnable";
@@ -82055,6 +82329,7 @@ function locationForCall(call) {
 	if (anyCall.indexName) location.index = anyCall.indexName;
 	else if (anyCall.newIndexName) location.index = anyCall.newIndexName;
 	if (anyCall.constraintName) location.constraint = anyCall.constraintName;
+	else if (anyCall.newConstraintName) location.constraint = anyCall.newConstraintName;
 	if (anyCall.policyName) location.rlsPolicy = anyCall.policyName;
 	else if (anyCall.policy?.name) location.rlsPolicy = anyCall.policy.name;
 	else if (anyCall.newPolicyName) location.rlsPolicy = anyCall.newPolicyName;
@@ -82105,17 +82380,6 @@ function issueColumnName(issue) {
 function emissionSchemaName(ctx, ddlSchemaName) {
 	return resolveNamespaceIdForDdlSchema(ctx.toContract, ddlSchemaName) === "__unbound__" ? UNBOUND_NAMESPACE_ID : ddlSchemaName;
 }
-/**
-* Whether a column node is a scalar-array (`many: true`) column. The family
-* converter (`contractToSchemaIR`'s `convertColumn`) never stamps `many` on
-* the derived node — array-ness is folded into the `[]` suffix on
-* `nativeType` instead — so the node-derived check reads the suffix; `.many`
-* is still checked first for nodes a caller stamps directly (e.g. hand-built
-* test fixtures, or an adapter that populates it at introspection).
-*/
-function isManyColumn(column) {
-	return column.many === true || column.nativeType.endsWith("[]");
-}
 /** Whether the expected/actual native type (resolved, or raw+many fallback) differs — mirrors `SqlColumnIR.isEqualTo`'s type comparison. */
 function columnTypeChanged(expected, actual) {
 	if (expected.resolvedNativeType !== void 0 && actual.resolvedNativeType !== void 0) return expected.resolvedNativeType !== actual.resolvedNativeType;
@@ -82156,7 +82420,7 @@ function fkSpecFromNode(fk, tableName) {
 /**
 * Builds the `CreateTable` + child `CreateIndex` / `AddForeignKey` / `AddUnique`
 * calls for a newly-expected table, reading only the table node's children. The
-* PK and element-non-null CHECKs go inline as table constraints; indexes
+* PK and every declared CHECK go inline as table constraints; indexes
 * (declared + FK-backing, already merged and ordered at derivation) and the
 * FK / unique constraints are separate calls (re-bucketed downstream). Every
 * column's DDL is resolved from its `codecRef` via `renderColumnDdl`.
@@ -82164,8 +82428,8 @@ function fkSpecFromNode(fk, tableName) {
 function buildCreateTableCallsFromNode(schemaName, ddlSchemaName, table, codecHooks) {
 	const ddlColumns = Object.values(table.columns).map((c) => renderColumnDdl(c.name, c, codecHooks));
 	const primaryKeyConstraints = table.primaryKey ? [primaryKey([...table.primaryKey.columns], { ...ifDefined("name", table.primaryKey.name) })] : [];
-	const elementNonNullChecks = Object.values(table.columns).filter((c) => isManyColumn(c)).map((c) => checkExpression(elementNonNullCheckName(table.name, c.name), elementNonNullCheckExpression(c.name)));
-	const allTableConstraints = [...primaryKeyConstraints, ...elementNonNullChecks];
+	const declaredChecks = (table.checks ?? []).map((c) => checkExpression(c.name, c.expression));
+	const allTableConstraints = [...primaryKeyConstraints, ...declaredChecks];
 	const calls = [new CreateTableCall(schemaName, table.name, ddlColumns, allTableConstraints.length > 0 ? allTableConstraints : void 0)];
 	for (const index of table.indexes) calls.push(createIndexCallFromNode(index, schemaName, table.name));
 	for (const fk of table.foreignKeys) calls.push(new AddForeignKeyCall(schemaName, table.name, fkSpecFromNode(fk, table.name)));
@@ -82307,9 +82571,20 @@ function mapIndexNodeIssue(issue, schemaName, tableName) {
 	if (issueOutcome(issue) === "not-expected") return ok$1([new DropIndexCall(schemaName, tableName, blindCast(issue.actual).name)]);
 	return notOk(nodeConflict("indexIncompatible", issue.path.join("/")));
 }
+/**
+* The index treatment: a missing check is added, an undeclared live check is
+* dropped, and a paired divergence is a conflict. `not-equal` is reachable only
+* for an exact-named expected check — a wire-named one compares by name, so a
+* changed predicate re-suffixes the name and arrives as missing + extra
+* instead.
+*/
 function mapCheckNodeIssue(issue, schemaName, tableName) {
+	if (issueOutcome(issue) === "not-found") {
+		const check = blindCast(issue.expected);
+		return ok$1([new AddCheckConstraintCall(schemaName, tableName, check.name, check.expression)]);
+	}
 	if (issueOutcome(issue) === "not-expected") return ok$1([new DropCheckConstraintCall(schemaName, tableName, blindCast(issue.actual).name)]);
-	return notOk(nodeConflict("unsupportedOperation", `Check constraint drift on "${tableName}" — handled by checkConstraintPlanCallStrategy: ${issue.path.join("/")}`));
+	return notOk(nodeConflict("unsupportedOperation", issue.path.join("/")));
 }
 /**
 * Maps one node-typed diff issue to its migration call(s), dispatching on the
@@ -83554,7 +83829,10 @@ var PostgresMigration = class extends SqlMigration {
 		return new AddForeignKeyCall(options.schema, options.table, options.foreignKey).toOp(this.controlAdapterFor("addForeignKey"));
 	}
 	addCheckConstraint(options) {
-		return new AddCheckConstraintCall(options.schema, options.table, options.constraint, options.column, options.values).toOp(this.controlAdapterFor("addCheckConstraint"));
+		return new AddCheckConstraintCall(options.schema, options.table, options.constraint, options.expression).toOp(this.controlAdapterFor("addCheckConstraint"));
+	}
+	renameCheckConstraint(options) {
+		return new RenameCheckConstraintCall(options.schema ?? "__unbound__", options.table, options.from, options.to).toOp(this.controlAdapterFor("renameCheckConstraint"));
 	}
 	dropCheckConstraint(options) {
 		return new DropCheckConstraintCall(options.schema, options.table, options.constraint).toOp(this.controlAdapterFor("dropCheckConstraint"));
@@ -214683,7 +214961,7 @@ function shebangLineFor(runtime) {
 *   to `'postgres'`, so user-authored migrations don't need to thread
 *   target-details or redeclare `targetId`.
 * - `MigrationCLI` — the migration-file CLI entrypoint, re-exported from
-*   `@internal/cli/migration-cli`. Loads `prisma-next.config.ts`,
+*   `@internal/cli/migration-cli`. Loads `prisma.config.ts`,
 *   assembles a `ControlStack`, and instantiates the migration class.
 *   The migration file owns this dependency directly: pulling CLI
 *   machinery in at script run time is acceptable because the script's
@@ -214945,7 +215223,9 @@ var PostgresMigrationPlanner = class {
 			schema: options.schema
 		}), ...gated];
 		const indexRenames = this.pairIndexRenames(options, schemaIssues);
-		const plannableIssues = indexRenames.consumed.size === 0 ? schemaIssues : schemaIssues.filter((issue) => !indexRenames.consumed.has(issue));
+		const checkRenames = this.pairCheckRenames(options, schemaIssues);
+		const renameConsumed = /* @__PURE__ */ new Set([...indexRenames.consumed, ...checkRenames.consumed]);
+		const plannableIssues = renameConsumed.size === 0 ? schemaIssues : schemaIssues.filter((issue) => !renameConsumed.has(issue));
 		const codecHooks = extractCodecControlHooks(options.frameworkComponents);
 		const storageTypes = options.contract.storage.types ?? {};
 		const relationalSchema = relationalNamespaceNode(options.schema, schemaName);
@@ -214970,7 +215250,7 @@ var PostgresMigrationPlanner = class {
 		const schemaDiff = this.planPostgresSchemaDiff(options, policyDiffIssues);
 		if (!result.ok || schemaDiff.conflicts.length > 0) return plannerFailure([...result.ok ? [] : result.failure, ...schemaDiff.conflicts]);
 		const indexRenamePartition = partitionCallsByControlPolicy({
-			calls: indexRenames.calls,
+			calls: [...indexRenames.calls, ...checkRenames.calls],
 			contract: options.contract,
 			resolveControlPolicySubject: (call) => resolvePostgresCallControlPolicySubject(call, options.contract),
 			resolveFactoryName: (call) => call.factoryName
@@ -215078,11 +215358,101 @@ var PostgresMigrationPlanner = class {
 			finding.tableName,
 			hash
 		]);
-		const rename = (missingFinding, candidate) => {
-			consumed.add(missingFinding.issue);
-			consumed.add(candidate.issue);
-			calls.push(new RenameIndexCall(emissionSchema(missingFinding.ddlSchema), missingFinding.tableName, candidate.node.name, missingFinding.node.name));
-		};
+		const rename = (missingFinding, candidate) => {
+			consumed.add(missingFinding.issue);
+			consumed.add(candidate.issue);
+			calls.push(new RenameIndexCall(emissionSchema(missingFinding.ddlSchema), missingFinding.tableName, candidate.node.name, missingFinding.node.name));
+		};
+		const sortedMissing = [...missing].sort(byName);
+		const extrasByHash = /* @__PURE__ */ new Map();
+		for (const finding of extra) {
+			const parsed = parseWireName(finding.node.name);
+			if (parsed === void 0) continue;
+			const key = pairingKey(finding, parsed.hash);
+			const group = extrasByHash.get(key) ?? [];
+			group.push(finding);
+			extrasByHash.set(key, group);
+		}
+		for (const group of extrasByHash.values()) group.sort(byName);
+		for (const missingFinding of sortedMissing) {
+			const parsed = parseWireName(missingFinding.node.name);
+			if (parsed === void 0) continue;
+			const candidate = extrasByHash.get(pairingKey(missingFinding, parsed.hash))?.shift();
+			if (candidate === void 0) continue;
+			rename(missingFinding, candidate);
+		}
+		const sortedExtras = [...extra].sort(byName);
+		for (const missingFinding of sortedMissing) {
+			if (consumed.has(missingFinding.issue)) continue;
+			if (missingFinding.node.prefix === void 0) continue;
+			const candidate = sortedExtras.find((extraFinding) => !consumed.has(extraFinding.issue) && extraFinding.ddlSchema === missingFinding.ddlSchema && extraFinding.tableName === missingFinding.tableName && missingFinding.node.contentEquals(extraFinding.node, {
+				columnPresence: "matching",
+				bodies: "verbatim"
+			}));
+			if (candidate === void 0) continue;
+			rename(missingFinding, candidate);
+		}
+		return {
+			calls,
+			consumed
+		};
+	}
+	/**
+	* Check-constraint rename post-pass: a `not-found` and a `not-expected`
+	* check on the same table whose wire-name content hashes match but whose
+	* prefixes differ is a prefix-only rename, and collapses into one
+	* `ALTER TABLE … RENAME CONSTRAINT`.
+	*
+	* This is the index pass's hash-pairing phase and nothing else. There is
+	* deliberately no content-pairing phase: a live check body is whatever
+	* Postgres reprinted, so it never byte-matches the authored text, and
+	* pairing an exact-named live check by content would bless whatever
+	* predicate is actually live. Adoption of an old exact-named check stays
+	* drop + add.
+	*
+	* Runs only when the policy allows `widening` (rename's class). Without it
+	* the pass no-ops and the pair degrades to the slice-1 behavior: an add,
+	* plus a drop when `destructive` is allowed too.
+	*/
+	pairCheckRenames(options, issues) {
+		const consumed = /* @__PURE__ */ new Set();
+		const calls = [];
+		if (!options.policy.allowedOperationClasses.includes("widening")) return {
+			calls,
+			consumed
+		};
+		const missing = [];
+		const extra = [];
+		for (const issue of issues) {
+			const node = issueNode(issue);
+			if (node === void 0 || !SqlCheckConstraintIR.is(node)) continue;
+			const ddlSchema = issue.path[1];
+			const tableName = issue.path[2];
+			if (ddlSchema === void 0 || tableName === void 0) continue;
+			if (issueOutcome(issue) === "not-found") missing.push({
+				issue,
+				node,
+				ddlSchema,
+				tableName
+			});
+			else if (issueOutcome(issue) === "not-expected") extra.push({
+				issue,
+				node,
+				ddlSchema,
+				tableName
+			});
+		}
+		if (missing.length === 0 || extra.length === 0) return {
+			calls,
+			consumed
+		};
+		const byName = (a, b) => a.node.name < b.node.name ? -1 : a.node.name > b.node.name ? 1 : 0;
+		const emissionSchema = (ddlSchema) => resolveNamespaceIdForDdlSchema(options.contract, ddlSchema) === "__unbound__" ? UNBOUND_NAMESPACE_ID : ddlSchema;
+		const pairingKey = (finding, hash) => JSON.stringify([
+			finding.ddlSchema,
+			finding.tableName,
+			hash
+		]);
 		const sortedMissing = [...missing].sort(byName);
 		const extrasByHash = /* @__PURE__ */ new Map();
 		for (const finding of extra) {
@@ -215099,18 +215469,9 @@ var PostgresMigrationPlanner = class {
 			if (parsed === void 0) continue;
 			const candidate = extrasByHash.get(pairingKey(missingFinding, parsed.hash))?.shift();
 			if (candidate === void 0) continue;
-			rename(missingFinding, candidate);
-		}
-		const sortedExtras = [...extra].sort(byName);
-		for (const missingFinding of sortedMissing) {
-			if (consumed.has(missingFinding.issue)) continue;
-			if (missingFinding.node.prefix === void 0) continue;
-			const candidate = sortedExtras.find((extraFinding) => !consumed.has(extraFinding.issue) && extraFinding.ddlSchema === missingFinding.ddlSchema && extraFinding.tableName === missingFinding.tableName && missingFinding.node.contentEquals(extraFinding.node, {
-				columnPresence: "matching",
-				bodies: "verbatim"
-			}));
-			if (candidate === void 0) continue;
-			rename(missingFinding, candidate);
+			consumed.add(missingFinding.issue);
+			consumed.add(candidate.issue);
+			calls.push(new RenameCheckConstraintCall(emissionSchema(missingFinding.ddlSchema), missingFinding.tableName, candidate.node.name, missingFinding.node.name));
 		}
 		return {
 			calls,
@@ -216945,6 +217306,20 @@ function buildIndexAttribute(index, fieldNames) {
 	}
 	return buildAttribute("model", "index", args);
 }
+/**
+* Emits one `@@check` attribute for a live, non-derived check, always in the
+* `map:` form. Re-detecting `name:` is not attempted: the live expression is
+* Postgres's own reprint, but a wire-named check's hash was taken over the
+* author's original text, so recomputing the hash from the reprint would
+* essentially never match. `map:` plus the verbatim reprint is correct
+* regardless — a reprint compared against a later reprint of the same
+* expression is stable, so the emitted contract signs the live database with
+* zero pending operations. `buildPolicyBlocks` makes the same call for
+* `@@map` on adopted RLS policies, for the same reason.
+*/
+function buildCheckAttribute(check) {
+	return buildAttribute("model", "check", [namedArg("expression", `"${escapePslString(check.expression)}"`), namedArg("map", `"${escapePslString(check.name)}"`)]);
+}
 function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMapping, rawDefaultParser, relationFields, danglingForeignKeys, rlsEnabled = false, policySkipNotes = []) {
 	const { name: modelName, map: mapName } = toModelName(table.name);
 	const fieldNameMap = fieldNamesByTable.get(table.name);
@@ -216957,8 +217332,9 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMappi
 		const existingConstraintName = uniqueColumns.get(columnName);
 		if (!uniqueColumns.has(columnName) || existingConstraintName === void 0 && unique.name) uniqueColumns.set(columnName, unique.name);
 	}
+	const derivedCheckNames = computeDerivedCheckNames(table);
 	const fields = [];
-	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
+	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns, derivedCheckNames));
 	const usedFieldNames = new Set(fields.map((field) => field.name));
 	for (const rel of relationFields) fields.push(buildRelationField(rel, table.name, fieldNamesByTable, usedFieldNames));
 	const modelAttributes = [];
@@ -216974,6 +217350,7 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMappi
 		const indexFieldNames = index.columns?.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
 		modelAttributes.push(buildIndexAttribute(index, indexFieldNames));
 	}
+	for (const check of table.checks ?? []) if (!derivedCheckNames.has(check.name)) modelAttributes.push(buildCheckAttribute(check));
 	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
 	if (rlsEnabled) modelAttributes.push(buildAttribute("model", "rls", []));
 	const warnings = [];
@@ -216990,7 +217367,35 @@ function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMappi
 		...comment !== void 0 ? { comment } : {}
 	};
 }
-function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
+/**
+* The live check names that are derived: a live check's name matches
+* `formatWireName(composeCheckWirePrefix(table, column, kind), computeCheckContentHash(expression))`
+* for some column of the table and some candidate `postgresRenderCheckExpressions`
+* would render for that column. Never by comparing expressions — the live
+* body is a Postgres reprint, never the authored text. One set serves both
+* the `@noCheck` waiver below and `@@check` exclusion in `buildModel`, so the
+* two decisions cannot drift apart.
+*
+* `membership` is unreachable here today: infer never emits domain enums
+* (`enumType()` is not inferred), so no inferred column has member values and
+* no membership check is ever derived. The day domain-enum inference exists,
+* its slice extends this by threading the column's member values through.
+*/
+function computeDerivedCheckNames(table) {
+	const liveCheckNames = new Set((table.checks ?? []).map((check) => check.name));
+	const derivedCheckNames = /* @__PURE__ */ new Set();
+	for (const column of Object.values(table.columns)) for (const candidate of postgresRenderCheckExpressions({
+		tableName: table.name,
+		columnName: column.name,
+		many: column.many === true,
+		memberValues: void 0
+	})) {
+		const derivedName = formatWireName(composeCheckWirePrefix(table.name, column.name, candidate.kind), computeCheckContentHash(candidate.expression));
+		if (liveCheckNames.has(derivedName)) derivedCheckNames.add(derivedName);
+	}
+	return derivedCheckNames;
+}
+function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns, derivedCheckNames) {
 	const resolvedField = fieldNameMap?.get(column.name);
 	const fieldName = resolvedField?.fieldName ?? toFieldName(column.name).name;
 	const fieldMap = resolvedField?.fieldMap;
@@ -217043,6 +217448,15 @@ function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, def
 		const uniqueConstraintName = uniqueColumns.get(column.name);
 		attributes.push(buildSimpleConstraintFieldAttribute("unique", uniqueConstraintName));
 	}
+	if (column.many === true) {
+		const waivedKinds = postgresRenderCheckExpressions({
+			tableName: table.name,
+			columnName: column.name,
+			many: true,
+			memberValues: void 0
+		}).filter((candidate) => !derivedCheckNames.has(formatWireName(composeCheckWirePrefix(table.name, column.name, candidate.kind), computeCheckContentHash(candidate.expression)))).map((candidate) => candidate.kind);
+		if (waivedKinds.length > 0) attributes.push(buildAttribute("field", "noCheck", waivedKinds.map(positionalArg)));
+	}
 	if (fieldMap !== void 0) attributes.push(buildMapAttribute("field", fieldMap));
 	return {
 		kind: "field",
@@ -217299,11 +217713,15 @@ function createPostgresTypeMap(enumTypeNames) {
 * Relation inference, name transforms, generic default mapping, and raw-default
 * parsing are shape-neutral utilities imported from the SQL family.
 *
-* This slice emits relational-only PSL, byte-identical to the prior flat
-* inference: the tree's tables (across its namespaces — `contract infer`
-* introspects a single live namespace) are gathered into the model set and
-* emitted as one `UNSPECIFIED_PSL_NAMESPACE_ID` bucket. Top-level entities
-* (policies/roles → PSL extension blocks) are a later slice.
+* The tree's tables (across its namespaces — `contract infer` introspects a
+* single live namespace) are gathered into the model set and emitted in one
+* bucket, alongside native-enum and RLS policy blocks. That bucket is named
+* after the introspected schema when the content needs a `namespace { … }`
+* wrap, and is the flat `UNSPECIFIED_PSL_NAMESPACE_ID` bucket otherwise. This
+* entry point emits nothing else, so its output is always exactly one bucket
+* and byte-identical to the prior flat inference. {@link buildPslDocumentAst}
+* can emit a second, always-flat bucket for content that must stay top-level
+* even under a wrap; no caller asks for one yet.
 *
 * `describedContracts` — the stack's extension packs' already-assembled
 * contracts, each paired with its space id — is consulted while gathering
@@ -217391,7 +217809,24 @@ function inferPostgresPslContract(tree, describedContracts) {
 		policiesByTable
 	});
 }
-function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName, rlsExtras) {
+/**
+* Builds the PSL document for one introspected schema.
+*
+* `namespaceName` wraps the output in `namespace <name> { … }`; omit it for
+* flat output. `topLevelExtensionBlocks` are declarations that must stay
+* top-level even when a wrap applies, such as a recovered domain enum — a
+* family `enum` inside a namespace is a hard diagnostic. They land in their
+* own always-flat bucket when a wrap applies, and in the single flat bucket
+* when none does; either way they print unwrapped.
+*
+* Their names are reserved before the policy blocks are built, so a policy
+* renames itself out of the way. Against the rest of the top-level scope — the
+* models, the native enums, PSL's scalar type names, and the other blocks in
+* the list — a clash throws instead: a block's name is its contract key
+* (`entries.valueSet[name]`, with no `@@map` escape), so it cannot be rewritten
+* here.
+*/
+function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName, rlsExtras, topLevelExtensionBlocks = []) {
 	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
 	const { extraRelationsByTable, crossSpaceFieldNamesByTable, danglingForeignKeysByTable } = foreignKeyExtras;
 	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
@@ -217401,19 +217836,48 @@ function buildPslDocumentAst(schemaIR, options, foreignKeyExtras, namespaceName,
 	if (namespaceName !== void 0) for (const [typeName, pslName] of bareEnumNameMap) enumNameMap.set(`${namespaceName}.${typeName}`, pslName);
 	const fieldNamesByTable = new Map([...crossSpaceFieldNamesByTable, ...buildFieldNamesByTable(schemaIR.tables)]);
 	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-	const policyEmission = buildPolicyBlocks(rlsExtras?.policiesByTable ?? /* @__PURE__ */ new Map(), modelNameMap, /* @__PURE__ */ new Set([...modelNameMap.values(), ...bareEnumNameMap.values()]));
+	const policyEmission = buildPolicyBlocks(rlsExtras?.policiesByTable ?? /* @__PURE__ */ new Map(), modelNameMap, /* @__PURE__ */ new Set([
+		...modelNameMap.values(),
+		...bareEnumNameMap.values(),
+		...topLevelExtensionBlocks.map((block) => block.name)
+	]));
+	const claimedTopLevelNames = /* @__PURE__ */ new Set([
+		...PSL_SCALAR_TYPE_NAMES,
+		...modelNameMap.values(),
+		...bareEnumNameMap.values()
+	]);
+	for (const block of topLevelExtensionBlocks) {
+		if (claimedTopLevelNames.has(block.name)) throw postgresError("CONTRACT.NAME_DUPLICATE", `contract infer: recovered ${block.keyword} "${block.name}" collides with a model, a native enum, a PSL scalar type, or another recovered declaration of the same name. Rename the recovered declaration, or exclude it.`, { meta: {
+			kind: block.keyword,
+			name: block.name
+		} });
+		claimedTopLevelNames.add(block.name);
+	}
 	const models = [];
 	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, enumNameMap, fieldNamesByTable, defaultMapping, rawDefaultParser, [...relationsByTable.get(table.name) ?? [], ...extraRelationsByTable.get(table.name) ?? []], danglingForeignKeysByTable.get(table.name) ?? [], rlsExtras?.rlsEnabledTables.has(table.name) ?? false, policyEmission.skipNotesByTable.get(table.name) ?? []));
 	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
+	const separateTopLevelBucket = namespaceName !== void 0 && namespaceName !== "__unspecified__" && topLevelExtensionBlocks.length > 0;
+	const namespaces = [];
+	if (separateTopLevelBucket) namespaces.push(makePslNamespace({
+		kind: "namespace",
+		name: UNSPECIFIED_PSL_NAMESPACE_ID,
+		entries: makePslNamespaceEntries([], [], topLevelExtensionBlocks),
+		span: SYNTHETIC_SPAN
+	}));
+	namespaces.push(makePslNamespace({
+		kind: "namespace",
+		name: namespaceName ?? "__unspecified__",
+		entries: makePslNamespaceEntries(sortedModels, [], [
+			...separateTopLevelBucket ? [] : topLevelExtensionBlocks,
+			...enumBlocks,
+			...policyEmission.blocks
+		]),
+		span: SYNTHETIC_SPAN
+	}));
 	return {
 		kind: "document",
 		sourceId: "<sql-schema-ir>",
-		namespaces: [makePslNamespace({
-			kind: "namespace",
-			name: namespaceName ?? "__unspecified__",
-			entries: makePslNamespaceEntries(sortedModels, [], [...enumBlocks, ...policyEmission.blocks]),
-			span: SYNTHETIC_SPAN
-		})],
+		namespaces,
 		span: SYNTHETIC_SPAN
 	};
 }
@@ -217472,107 +217936,6 @@ const postgresTargetDescriptor = {
 		return createPostgresMigrationRunner(family);
 	}
 };
-/**
-* Asserts that all framework components are compatible with the expected family and target.
-*
-* This function validates that each component in the framework components array:
-* - Has kind 'target', 'adapter', 'extension', or 'driver'
-* - Has familyId matching expectedFamilyId
-* - Has targetId matching expectedTargetId
-*
-* This validation happens at the CLI composition boundary, before passing components
-* to typed planner/runner instances. It fills the gap between runtime validation
-* (via `validateConfig()`) and compile-time type enforcement.
-*
-* @param expectedFamilyId - The expected family ID (e.g., 'sql')
-* @param expectedTargetId - The expected target ID (e.g., 'postgres')
-* @param frameworkComponents - Array of framework components to validate
-* @returns The same array typed as TargetBoundComponentDescriptor
-* @throws CliStructuredError if any component is incompatible
-*
-* @example
-* ```ts
-* const config = await loadConfig();
-* const frameworkComponents = [config.target, config.adapter, ...(config.extensions ?? [])];
-*
-* // Validate and type-narrow components before passing to planner
-* const typedComponents = assertFrameworkComponentsCompatible(
-*   config.family.familyId,
-*   config.target.targetId,
-*   frameworkComponents
-* );
-*
-* const planner = target.migrations.createPlanner(familyInstance);
-* planner.plan({ contract, schema, policy, frameworkComponents: typedComponents });
-* ```
-*/
-function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId, frameworkComponents) {
-	for (let i = 0; i < frameworkComponents.length; i++) {
-		const component = frameworkComponents[i];
-		if (typeof component !== "object" || component === null) throw errorConfigValidation("frameworkComponents[]", { why: `Framework component at index ${i} must be an object` });
-		const record = component;
-		if (!Object.hasOwn(record, "kind")) throw errorConfigValidation("frameworkComponents[].kind", { why: `Framework component at index ${i} must have 'kind' property` });
-		const kind = record["kind"];
-		if (kind !== "target" && kind !== "adapter" && kind !== "extension" && kind !== "driver") throw errorConfigValidation("frameworkComponents[].kind", { why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')` });
-		if (!Object.hasOwn(record, "familyId")) throw errorConfigValidation("frameworkComponents[].familyId", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property` });
-		const familyId = record["familyId"];
-		if (familyId !== expectedFamilyId) throw errorConfigValidation("frameworkComponents[].familyId", { why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'` });
-		if (!Object.hasOwn(record, "targetId")) throw errorConfigValidation("frameworkComponents[].targetId", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property` });
-		const targetId = record["targetId"];
-		if (targetId !== expectedTargetId) throw errorConfigValidation("frameworkComponents[].targetId", { why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'` });
-	}
-	return frameworkComponents;
-}
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function sortDeep(value) {
-	if (Array.isArray(value)) return value.map(sortDeep);
-	if (!isPlainObject(value)) return value;
-	const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
-	const next = {};
-	for (const [key, child] of entries) next[key] = sortDeep(child);
-	return next;
-}
-function sortDeepTyped(value) {
-	return sortDeep(value);
-}
-function extractExtensionPackMeta(component) {
-	const { kind, id, version, capabilities, types } = component;
-	const base = {
-		kind,
-		id,
-		familyId: component.familyId,
-		targetId: component.targetId,
-		version
-	};
-	if (capabilities) base["capabilities"] = capabilities;
-	if (types) if (types.codecTypes) {
-		const { controlPlaneHooks: _, codecDescriptors: _cd, ...cleanedCodecTypes } = types.codecTypes;
-		base["types"] = {
-			...types,
-			codecTypes: cleanedCodecTypes
-		};
-	} else base["types"] = types;
-	return base;
-}
-/**
-* Enriches a raw contract with framework-derived metadata: capabilities from all component descriptors and extension pack metadata from extension descriptors. Produces deterministically sorted output.
-*/
-function enrichContract(ir, components) {
-	const mergedCapabilities = mergeCapabilityMatrices(ir.capabilities, components);
-	const extensionsMeta = {};
-	for (const component of components) if (component.kind === "extension") extensionsMeta[component.id] = extractExtensionPackMeta(component);
-	const extensions = Object.keys(extensionsMeta).length > 0 ? {
-		...ir.extensions,
-		...extensionsMeta
-	} : ir.extensions;
-	return {
-		...ir,
-		capabilities: sortDeepTyped(mergedCapabilities),
-		extensions: sortDeepTyped(extensions)
-	};
-}
 const JSON_EXTENSION = ".json";
 function getEmittedArtifactPaths(outputJsonPath) {
 	if (!outputJsonPath.endsWith(JSON_EXTENSION)) throw emitterError("CONFIG.VALIDATION_FAILED", "Contract output path must end with .json", { meta: {
@@ -217633,8 +217996,8 @@ function generateContractDts(contract, emitter, codecTypeImports, hashes, option
 	const extraTypeExports = emitter.getStorageTypeExports?.(contract, codecLookup);
 	const contractWrapper = emitter.getContractWrapper("ContractBase", "TypeMaps");
 	return `// ⚠️  GENERATED FILE - DO NOT EDIT
-// This file is automatically generated by 'prisma-next contract emit'.
-// To regenerate, run: prisma-next contract emit
+// This file is automatically generated by 'prisma contract emit'.
+// To regenerate, run: prisma contract emit
 ${importLines.join("\n")}
 
 ${familyImportLines.join("\n")}
@@ -217694,8 +218057,8 @@ async function emit(contract, stack, targetFamily, options) {
 		...canonicalized,
 		_generated: {
 			warning: "⚠️  GENERATED FILE - DO NOT EDIT",
-			message: "This file is automatically generated by \"prisma-next contract emit\".",
-			regenerate: "To regenerate, run: prisma-next contract emit"
+			message: "This file is automatically generated by \"prisma contract emit\".",
+			regenerate: "To regenerate, run: prisma contract emit"
 		}
 	}, null, 2);
 	const generateOptions = {
@@ -217725,7 +218088,6 @@ function isGraphNode(hash, graph) {
 	if (hash === "empty") return true;
 	return graph.nodes.has(hash);
 }
-init_dist();
 /**
 * The system head ref lives at `refs/head.json`. It is read (and its
 * corruption judged) through `readContractSpaceHeadRef`, not as a
@@ -217766,8 +218128,13 @@ async function readRef(refsDir, name) {
 	} catch (error) {
 		if (error instanceof Error && error.code === "ENOENT") throw new MigrationToolsError("MIGRATION.UNKNOWN_REF", `Unknown ref "${name}"`, {
 			why: `No ref file found at "${filePath}".`,
-			fix: `Create the ref with: prisma-next ref set ${name} <hash>`,
-			details: {
+			fix: `Create the ref with: prisma ref set ${name} <hash>`,
+			nextActions: [{
+				kind: "run-command",
+				label: `Create the ref "${name}"`,
+				command: `{bin} ref set ${name} <hash>`
+			}],
+			meta: {
 				refName: name,
 				filePath
 			}
@@ -217850,7 +218217,6 @@ async function readRefsTolerant(refsDir) {
 		problems
 	};
 }
-init_dist();
 function contractAtMemoKey(hash, refName) {
 	return `${hash}\0${refName ?? ""}`;
 }
@@ -218844,6 +219210,109 @@ function runVerifyMigration(input) {
 	});
 }
 /**
+* Asserts that all framework components are compatible with the expected family and target.
+*
+* This function validates that each component in the framework components array:
+* - Has kind 'target', 'adapter', 'extension', or 'driver'
+* - Has familyId matching expectedFamilyId
+* - Has targetId matching expectedTargetId
+*
+* This validation happens at the CLI composition boundary, before passing components
+* to typed planner/runner instances. It fills the gap between runtime validation
+* (via the config loader's `collectConfigIssues` diagnostics) and compile-time
+* type enforcement.
+*
+* @param expectedFamilyId - The expected family ID (e.g., 'sql')
+* @param expectedTargetId - The expected target ID (e.g., 'postgres')
+* @param frameworkComponents - Array of framework components to validate
+* @returns The same array typed as TargetBoundComponentDescriptor
+* @throws CliStructuredError if any component is incompatible
+*
+* @example
+* ```ts
+* const configResult = await loadConfigForSections(undefined, ['family', 'target', 'adapter', 'extensions']);
+* const config = configResult.assertOk();
+* const frameworkComponents = [config.target, config.adapter, ...(config.extensions ?? [])];
+*
+* // Validate and type-narrow components before passing to planner
+* const typedComponents = assertFrameworkComponentsCompatible(
+*   config.family.familyId,
+*   config.target.targetId,
+*   frameworkComponents
+* );
+*
+* const planner = target.migrations.createPlanner(familyInstance);
+* planner.plan({ contract, schema, policy, frameworkComponents: typedComponents });
+* ```
+*/
+function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId, frameworkComponents) {
+	for (let i = 0; i < frameworkComponents.length; i++) {
+		const component = frameworkComponents[i];
+		if (typeof component !== "object" || component === null) throw errorConfigValidation("frameworkComponents[]", { why: `Framework component at index ${i} must be an object` });
+		const record = component;
+		if (!Object.hasOwn(record, "kind")) throw errorConfigValidation("frameworkComponents[].kind", { why: `Framework component at index ${i} must have 'kind' property` });
+		const kind = record["kind"];
+		if (kind !== "target" && kind !== "adapter" && kind !== "extension" && kind !== "driver") throw errorConfigValidation("frameworkComponents[].kind", { why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')` });
+		if (!Object.hasOwn(record, "familyId")) throw errorConfigValidation("frameworkComponents[].familyId", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property` });
+		const familyId = record["familyId"];
+		if (familyId !== expectedFamilyId) throw errorConfigValidation("frameworkComponents[].familyId", { why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'` });
+		if (!Object.hasOwn(record, "targetId")) throw errorConfigValidation("frameworkComponents[].targetId", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property` });
+		const targetId = record["targetId"];
+		if (targetId !== expectedTargetId) throw errorConfigValidation("frameworkComponents[].targetId", { why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'` });
+	}
+	return frameworkComponents;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortDeep(value) {
+	if (Array.isArray(value)) return value.map(sortDeep);
+	if (!isPlainObject(value)) return value;
+	const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+	const next = {};
+	for (const [key, child] of entries) next[key] = sortDeep(child);
+	return next;
+}
+function sortDeepTyped(value) {
+	return sortDeep(value);
+}
+function extractExtensionPackMeta(component) {
+	const { kind, id, version, capabilities, types } = component;
+	const base = {
+		kind,
+		id,
+		familyId: component.familyId,
+		targetId: component.targetId,
+		version
+	};
+	if (capabilities) base["capabilities"] = capabilities;
+	if (types) if (types.codecTypes) {
+		const { controlPlaneHooks: _, codecDescriptors: _cd, ...cleanedCodecTypes } = types.codecTypes;
+		base["types"] = {
+			...types,
+			codecTypes: cleanedCodecTypes
+		};
+	} else base["types"] = types;
+	return base;
+}
+/**
+* Enriches a raw contract with framework-derived metadata: capabilities from all component descriptors and extension pack metadata from extension descriptors. Produces deterministically sorted output.
+*/
+function enrichContract(ir, components) {
+	const mergedCapabilities = mergeCapabilityMatrices(ir.capabilities, components);
+	const extensionsMeta = {};
+	for (const component of components) if (component.kind === "extension") extensionsMeta[component.id] = extractExtensionPackMeta(component);
+	const extensions = Object.keys(extensionsMeta).length > 0 ? {
+		...ir.extensions,
+		...extensionsMeta
+	} : ir.extensions;
+	return {
+		...ir,
+		capabilities: sortDeepTyped(mergedCapabilities),
+		extensions: sortDeepTyped(extensions)
+	};
+}
+/**
 * Minimal aggregate-loader projection that extracts `id` + `targetId`
 * from raw extension pack descriptors **without invoking any
 * `contractSpace` accessor**. Inspects the own-property descriptor so
@@ -218962,7 +219431,7 @@ function mapIntegrityViolations(violations) {
 	const contractUnreadable = violations.find((v) => v.kind === "contractUnreadable");
 	if (contractUnreadable && contractUnreadable.kind === "contractUnreadable") return contractSpaceViolationError(`Contract-space contract validation failed for "${contractUnreadable.spaceId}"`, {
 		why: contractUnreadable.detail,
-		fix: "Re-emit the extension contract with `prisma-next contract emit`, or fix the extension pack descriptor producing the invalid contract.",
+		fix: "Re-emit the extension contract with `prisma-cli contract emit`, or fix the extension pack descriptor producing the invalid contract.",
 		violations: [contractUnreadable]
 	});
 	const structural = violations[0];
@@ -219036,6 +219505,20 @@ function stripOperations(operations) {
 	}));
 }
 /**
+* Content identity of a `db update` plan: what it does (the ordered display
+* operations) and where it lands (the destination storage hash). A
+* `DESTRUCTIVE_CHANGES` refusal names the refused plan by this hash, and the
+* apply that carries the consent back recomputes it to prove it is still
+* applying the plan that was consented to.
+*/
+function computePlanHash(plan) {
+	const canonical = canonicalizeJson({
+		operations: plan.operations,
+		destination: { storageHash: plan.destination.storageHash }
+	});
+	return createHash("sha256").update(canonical).digest("hex");
+}
+/**
 * Span id emitted via `onProgress` for the run phase. Stable
 * identifier consumed by the structured-output renderer and by tests.
 */
@@ -219094,7 +219577,8 @@ async function runMigration(inputs) {
 				...runnerResult.failure.meta ?? {},
 				failingSpace: runnerResult.failure.failingSpace,
 				runnerErrorCode: runnerResult.failure.code
-			}
+			},
+			cause: runnerResult.failure
 		});
 	}
 	onProgress?.({
@@ -219287,6 +219771,24 @@ async function executeRun(options) {
 			...ifDefined("warnings", plannerWarnings)
 		});
 	}
+	if (options.consentedPlanHash !== void 0) {
+		const planHash = computePlanHash({
+			operations: stripOperations(orderedResolutions.flatMap((r) => r.entry.displayOps)),
+			destination: appPlan.destination
+		});
+		if (planHash !== options.consentedPlanHash) return notOk({
+			code: "CONSENT_PLAN_MISMATCH",
+			summary: "The plan changed between consent and apply",
+			why: "The plan recomputed for the consented apply is not the plan that was consented to, so applying it could destroy something nobody agreed to.",
+			conflicts: void 0,
+			meta: void 0,
+			consentPlanMismatch: {
+				consentedPlanHash: options.consentedPlanHash,
+				planHash
+			},
+			...ifDefined("warnings", plannerWarnings)
+		});
+	}
 	const applied = await runMigration({
 		aggregate,
 		perSpacePlans: planResult.value.perSpace,
@@ -219303,7 +219805,8 @@ async function executeRun(options) {
 		summary: applied.failure.summary,
 		...ifDefined("why", applied.failure.why),
 		meta: applied.failure.meta,
-		...ifDefined("warnings", plannerWarnings)
+		...ifDefined("warnings", plannerWarnings),
+		...ifDefined("cause", applied.failure.cause)
 	});
 	const aggregateOps = applied.value.orderedResolutions.flatMap((r) => r.entry.displayOps);
 	const summary = action === "dbInit" ? `Applied ${applied.value.totalOpsExecuted} operation(s) across ${applied.value.orderedResolutions.length} space(s), database signed` : applied.value.totalOpsExecuted === 0 ? `Database already matches contract across ${applied.value.orderedResolutions.length} space(s), signature updated` : `Applied ${applied.value.totalOpsExecuted} operation(s) across ${applied.value.orderedResolutions.length} space(s), signature updated`;
@@ -219426,7 +219929,8 @@ function buildRunnerFailure(args) {
 		why: args.why,
 		meta: args.meta,
 		conflicts: void 0,
-		...ifDefined("warnings", args.warnings)
+		...ifDefined("warnings", args.warnings),
+		...ifDefined("cause", args.cause)
 	}));
 }
 /**
@@ -219482,13 +219986,14 @@ async function executeDbUpdate(options) {
 		action: "dbUpdate",
 		...ifDefined("onProgress", options.onProgress)
 	};
-	if (options.mode === "apply" && !options.acceptDataLoss) {
-		const gate = await guardDestructiveChanges(sharedInputs);
-		if (gate !== null) return gate;
+	if (options.mode === "apply" && !options.acceptDataLoss && options.consent === void 0) {
+		const refusal = await guardDestructiveChanges(sharedInputs);
+		if (refusal !== null) return refusal;
 	}
 	return await executeRun({
 		...sharedInputs,
-		mode: options.mode
+		mode: options.mode,
+		...ifDefined("consentedPlanHash", options.consent?.planHash)
 	});
 }
 /**
@@ -219509,12 +220014,22 @@ async function guardDestructiveChanges(sharedInputs) {
 		label: op.label
 	}));
 	if (destructiveOps.length === 0) return null;
+	const databaseName = await sharedInputs.driver.databaseName?.();
 	return notOk({
 		code: "DESTRUCTIVE_CHANGES",
 		summary: `Planned ${destructiveOps.length} destructive operation(s) that require confirmation`,
-		why: "Destructive operations require confirmation — re-run with -y to accept",
+		why: "Destructive operations require explicit consent, which the caller has not given",
 		conflicts: void 0,
-		meta: { destructiveOperations: destructiveOps }
+		meta: void 0,
+		destructiveChanges: {
+			destructiveOperations: destructiveOps,
+			databaseName,
+			planHash: computePlanHash({
+				operations: planResult.value.plan.operations,
+				destination: planResult.value.destination
+			})
+		},
+		...ifDefined("warnings", planResult.value.warnings)
 	});
 }
 /**
@@ -219538,9 +220053,9 @@ const SPAN_IDS = {
 *    schema introspection.
 * 3. **Verify**: {@link verifyMigration} returns per-space `markerCheck` +
 *    per-space `schemaCheck` (each contract space verified against the full schema,
-*    then scoped to its own contract space). Marker mismatches map to
-*    `CliStructuredError` (code `5002`) so callers (CLI command) can render
-*    and exit. Verify results are returned to the caller verbatim.
+*    then scoped to its own contract space). Marker drift is returned as the
+*    success value's `markerDrift` envelope for callers to settle as a
+*    finding. Verify results are returned to the caller verbatim.
 */
 async function executeDbVerify(options) {
 	const { driver, familyInstance, onProgress, skipSchema, skipMarker } = options;
@@ -219661,17 +220176,14 @@ function finaliseVerifyResult(args) {
 			docsUrl: "https://pris.ly/contract-spaces"
 		}));
 	}
-	const markerError = skipMarker ? null : mapMarkerCheckFailures(aggregate.app.spaceId, verifyResult.value.markerCheck);
-	if (markerError !== null) {
-		emitVerifySpan(onProgress, "spanEndError");
-		return notOk(markerError);
-	}
-	emitVerifySpan(onProgress, "spanEndOk");
+	const markerDrift = skipMarker ? null : mapMarkerCheckFailures(aggregate.app.spaceId, verifyResult.value.markerCheck);
+	emitVerifySpan(onProgress, markerDrift === null ? "spanEndOk" : "spanEndError");
 	return ok$1({
 		schemaResults: verifyResult.value.schemaCheck.perSpace,
 		unclaimed: verifyResult.value.schemaCheck.unclaimed,
 		spaceOrder: [aggregate.app.spaceId, ...aggregate.extensions.map((e) => e.spaceId)],
-		appSpaceId: aggregate.app.spaceId
+		appSpaceId: aggregate.app.spaceId,
+		markerDrift
 	});
 }
 function buildSkippedSchemaResult(space) {
@@ -219704,7 +220216,7 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 			violations.push({
 				kind: "hashMismatch",
 				spaceId,
-				remediation: spaceId === appSpaceId ? "Run `prisma-next db update` to advance the marker, or roll the database back to the recorded hash." : `Apply on-disk migrations under \`migrations/${spaceId}/\` to advance the marker, or remove the conflicting marker row.`
+				remediation: spaceId === appSpaceId ? "Run `prisma-cli db update` to advance the marker, or roll the database back to the recorded hash." : `Apply on-disk migrations under \`migrations/${spaceId}/\` to advance the marker, or remove the conflicting marker row.`
 			});
 			continue;
 		}
@@ -219717,7 +220229,7 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 	for (const orphan of section.orphanMarkers) violations.push({
 		kind: "orphanMarker",
 		spaceId: orphan.spaceId,
-		remediation: `Add the corresponding extension to \`extensions\` in \`prisma-next.config.ts\`, or delete the orphan marker row for "${orphan.spaceId}".`
+		remediation: `Add the corresponding extension to \`extensions\` in \`prisma.config.ts\`, or delete the orphan marker row for "${orphan.spaceId}".`
 	});
 	if (violations.length === 0) return null;
 	const lines = violations.map((v) => `- [${v.kind}] ${v.spaceId}: ${v.remediation}`);
@@ -219849,7 +220361,8 @@ async function executeMigrate(options) {
 		code: "RUNNER_FAILED",
 		summary: applied.failure.summary,
 		why: applied.failure.why,
-		meta: applied.failure.meta
+		meta: applied.failure.meta,
+		...ifDefined("cause", applied.failure.cause)
 	});
 	const orderedAll = canonicalOrder.filter((spaceId) => perSpacePlans.has(spaceId) || atHeadResolutions.has(spaceId)).map((spaceId) => {
 		if (perSpacePlans.has(spaceId)) {
@@ -220374,6 +220887,7 @@ var ControlClientImpl = class {
 			targetId: this.options.target.targetId,
 			extensions: this.options.extensions ?? [],
 			...ifDefined("acceptDataLoss", options.acceptDataLoss),
+			...ifDefined("consent", options.consent),
 			...ifDefined("onProgress", onProgress)
 		});
 	}
@@ -220627,7 +221141,7 @@ function createPostgresControlClient(options = {}) {
 		...ifDefined("extensions", options.extensions)
 	});
 }
-var version = "0.9.0";
+var version = "0.10.0-dev.2";
 var migration_default = {
 	from: null,
 	to: "6bbd4dc1c19c8aa5e0d60c9755e0f8ea07ba1c01d20c48cf3aa7226e4ee7d33f",