@prisma/orm-family-sql 8.0.0-rc.11-dev.16 → 8.0.0-rc.11-dev.18

package/dist/contract-prisma7__provider.mjs

@@ -0,0 +1,1648 @@
+import { l as validateSqlStorageConsistency, s as validateModelStorageReferences } from "./validators-DD98VrpC.mjs";
+import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
+import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-DGjY5t7S-CzJmkeZR.mjs";
+import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, o as numberLiteralDefault, r as indexFkRelations, s as resolveFieldTypeDescriptor, t as applyBackrelationCandidates } from "./interpreter-QDw8KJeP-Bc93B8xi.mjs";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { collectScalarTypeConstructors, instantiateAuthoringEntityType } from "@prisma/orm-framework/components/authoring";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { validateContractDomain } from "@prisma/orm-framework/contract/validate-domain";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { buildSymbolTable, keywordPslSpan, nodePslSpan, rangeToPslSpan, readResolvedAttribute, readResolvedAttributes } from "@prisma/orm-framework/psl-parser";
+import { ArrayLiteralAst, BooleanLiteralExprAst, FunctionCallAst, IdentifierAst, NumberLiteralExprAst, StringLiteralExprAst, parse, printSyntax } from "@prisma/orm-framework/psl-parser/syntax";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { basename, dirname, extname, join, normalize } from "pathe";
+import { fkRelationPairKey } from "@prisma/orm-framework/psl-parser/interpret";
+//#region ../../../2-sql/2-authoring/contract-prisma7/dist/provider.mjs
+function prisma7Diagnostic(code, message, sourceId, span) {
+	return {
+		code,
+		message,
+		sourceId,
+		...span !== void 0 ? { span } : {}
+	};
+}
+function andList(items) {
+	const leading = items.slice(0, -1);
+	const last = items[items.length - 1] ?? "";
+	return leading.length === 0 ? last : `${leading.join(", ")} and ${last}`;
+}
+function fieldList(modelName, fieldNames) {
+	return andList(fieldNames.map((name) => `"${modelName}.${name}"`));
+}
+function ignoredFieldReferenced(input) {
+	const fields = fieldList(input.modelName, input.fieldNames);
+	const one = input.fieldNames.length === 1;
+	return prisma7Diagnostic("PSL.PRISMA7_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${one ? "is" : "are"} marked @ignore, but ${input.usedBy} uses ${one ? "it" : "them"}, and Prisma 7 still creates the ${input.constraint} that includes ${one ? "its column" : "their columns"}. Remove @ignore from ${fields}; Prisma 7's next migration is then empty, and ${one ? "the field appears" : "the fields appear"} in the Prisma 7 client again.`, input.sourceId, input.span);
+}
+const CLIENT_SIDE_GENERATORS = /* @__PURE__ */ new Set([
+	"uuid",
+	"cuid",
+	"ulid",
+	"nanoid"
+]);
+function givesColumnDefault(attribute) {
+	const expression = attribute?.args.find((arg) => arg.kind === "positional")?.expression;
+	if (expression === void 0) return false;
+	const call = FunctionCallAst.cast(expression.syntax);
+	if (call === void 0) return true;
+	const fn = call.path().join(".");
+	if (CLIENT_SIDE_GENERATORS.has(fn)) return false;
+	return fn !== "dbgenerated" || [...call.args()].length > 0;
+}
+/** Positional argument keys per Prisma 7 default function, matching the target registry's signatures. */
+const FUNCTION_ARGUMENT_KEYS = {
+	uuid: ["version"],
+	cuid: ["version"],
+	nanoid: ["size"],
+	dbgenerated: ["expression"],
+	now: [],
+	autoincrement: [],
+	ulid: []
+};
+function literalArgument(expression) {
+	const text = StringLiteralExprAst.cast(expression.syntax)?.value();
+	if (text !== void 0) return text;
+	const number = NumberLiteralExprAst.cast(expression.syntax)?.value();
+	if (number !== void 0) return number;
+	return BooleanLiteralExprAst.cast(expression.syntax)?.value();
+}
+function lowerPrisma7Default(input) {
+	const { attribute, field, sourceId, diagnostics } = input;
+	const label = `Field "${input.modelName}.${field.name}"`;
+	const unknown = (reason, span) => {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_DEFAULT", `${label}: @default ${reason}`, sourceId, span));
+	};
+	const argument = attribute.args.find((arg) => arg.kind === "positional");
+	const expression = argument?.expression;
+	if (argument === void 0 || expression === void 0) return unknown("needs one value.", attribute.span);
+	const call = FunctionCallAst.cast(expression.syntax);
+	if (call !== void 0) return lowerFunction(call, input, label, unknown);
+	const rawLiteral = input.literalForm?.kind === "sqlExpression" ? sqlExpressionDefault(expression, input.literalForm, input.field.list) : void 0;
+	if (rawLiteral === "unreadable") return unknown("holds a value this contract source does not read.", attribute.span);
+	if (rawLiteral !== void 0) return {
+		storage: {
+			kind: "function",
+			expression: rawLiteral.expression
+		},
+		onCreate: void 0
+	};
+	const scalar = scalarValue$1(expression, input, unknown);
+	if (scalar === void 0) return void 0;
+	return {
+		storage: {
+			kind: "literal",
+			value: scalar
+		},
+		onCreate: void 0
+	};
+}
+function scalarValue$1(expression, input, unknown) {
+	const span = input.attribute.span;
+	const isJson = input.literalForm?.kind === "json";
+	const jsonNull = (holds) => {
+		input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_JSON_NULL_DEFAULT_UNSUPPORTED", `Field "${input.modelName}.${input.field.name}": @default(${printSyntax(expression.syntax).trim()}) ${holds} the JSON value null, which the contract cannot tell apart from SQL NULL. Remove the @default or give it another JSON value; either changes the column default on Prisma 7's next migration.`, input.sourceId, span));
+	};
+	const array = ArrayLiteralAst.cast(expression.syntax);
+	if (array !== void 0) {
+		const values = [];
+		for (const element of array.elements()) {
+			const value = elementValue(element, input);
+			if (value === void 0) return unknown(rejectedNumberReason(element, input) ?? "lists may only hold literals or enum members.", span);
+			values.push(value);
+		}
+		if (isJson && values.includes(null)) return jsonNull("holds");
+		return values;
+	}
+	const value = elementValue(expression, input);
+	if (isJson && value === null) return jsonNull("is");
+	if (value !== void 0) return value;
+	const numberReason = rejectedNumberReason(expression, input);
+	if (numberReason !== void 0) return unknown(numberReason, span);
+	const identifier = IdentifierAst.cast(expression.syntax)?.name();
+	if (identifier !== void 0) return unknown(input.enumMembers === void 0 ? `refers to "${identifier}", but the field is not an enum.` : `refers to "${identifier}", which is not a member of the field's enum.`, span);
+	return unknown("holds a value this contract source does not read.", span);
+}
+function sqlExpressionDefault(expression, form, isList) {
+	const array = isList ? ArrayLiteralAst.cast(expression.syntax) : void 0;
+	if (array === void 0) {
+		const text = StringLiteralExprAst.cast(expression.syntax)?.value();
+		if (text === void 0) return void 0;
+		const literal = form.literal(text);
+		return literal === void 0 ? "unreadable" : { expression: literal };
+	}
+	const literals = [];
+	for (const element of array.elements()) {
+		const text = StringLiteralExprAst.cast(element.syntax)?.value();
+		const literal = text === void 0 ? void 0 : form.literal(text);
+		if (literal === void 0) return "unreadable";
+		literals.push(literal);
+	}
+	return { expression: form.list(literals) };
+}
+/** The Prisma 7 scalars whose number defaults must be whole numbers, as each is named in a message. */
+const WHOLE_NUMBER_SCALARS = {
+	Int: "an Int",
+	BigInt: "a BigInt"
+};
+const WHOLE_NUMBER_TEXT = /^-?\d+$/;
+/** The number literal the column codec reads neither as a number nor as text, such as `1.5` for a `BigInt`, which Prisma 7 rejects too. */
+function rejectedNumberReason(expression, input) {
+	const text = NumberLiteralExprAst.cast(expression.syntax)?.token()?.text;
+	if (text === void 0 || numberValue(text, input) !== void 0) return void 0;
+	const { typeName } = input.field;
+	const wholeNumberScalar = Object.hasOwn(WHOLE_NUMBER_SCALARS, typeName) ? WHOLE_NUMBER_SCALARS[typeName] : void 0;
+	return wholeNumberScalar === void 0 ? `holds ${text}, which is not a valid ${typeName} value.` : `holds ${text}, which is not an integer; ${wholeNumberScalar} default must be a whole number.`;
+}
+/** A number default for the field: Prisma 7 accepts only whole numbers for `Int` and `BigInt`. */
+function numberValue(text, input) {
+	if (Object.hasOwn(WHOLE_NUMBER_SCALARS, input.field.typeName) && !WHOLE_NUMBER_TEXT.test(text)) return;
+	return numberLiteralDefault(text, input.codecId, input.codecLookup);
+}
+function elementValue(expression, input) {
+	const member = IdentifierAst.cast(expression.syntax)?.name();
+	if (member !== void 0) return input.enumMembers?.get(member);
+	const number = NumberLiteralExprAst.cast(expression.syntax)?.token()?.text;
+	if (number !== void 0) return numberValue(number, input);
+	const text = StringLiteralExprAst.cast(expression.syntax)?.value();
+	if (text !== void 0) {
+		if (input.literalForm?.kind === "json") try {
+			return blindCast(JSON.parse(text));
+		} catch {
+			return;
+		}
+		return text;
+	}
+	return BooleanLiteralExprAst.cast(expression.syntax)?.value();
+}
+function lowerFunction(call, input, label, unknown) {
+	const fn = call.path().join(".");
+	const span = input.attribute.span;
+	const callArgs = [...call.args()];
+	if (fn === "dbgenerated" && callArgs.length === 0) {
+		if (input.field.optional || input.field.list) return {
+			storage: void 0,
+			onCreate: void 0
+		};
+		input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_DEFAULT", `${label}: @default(dbgenerated()) with no expression is not supported yet on a required field, because without a column default Prisma 8 requires the value on create. Either remove the @default, which makes Prisma 7's next migration drop the column default (ALTER COLUMN ... DROP DEFAULT) and both clients require the value on create, or write the column's database default as @default(dbgenerated("<expression>")), which Prisma 7's next migration sets on the column.`, input.sourceId, span));
+		return;
+	}
+	const keys = FUNCTION_ARGUMENT_KEYS[fn];
+	const entry = input.controlMutationDefaults.defaultFunctionRegistry.get(fn);
+	if (keys === void 0 || entry === void 0) return unknown(`function "${fn}()" is not a Prisma 7 default function this target supports.`, span);
+	const args = {};
+	let index = 0;
+	for (const arg of callArgs) {
+		const key = arg.name()?.name() ?? keys[index];
+		const value = arg.value();
+		const literal = value === void 0 ? void 0 : literalArgument(value);
+		if (key === void 0 || literal === void 0) return unknown(`function "${fn}()" has an argument this contract source does not read.`, span);
+		args[key] = literal;
+		index += 1;
+	}
+	if (fn === "cuid") args["version"] = 2;
+	const lowered = entry.lower({
+		call: {
+			fn,
+			span,
+			args
+		},
+		context: {
+			sourceId: input.sourceId,
+			modelName: input.modelName,
+			fieldName: input.field.name,
+			columnCodecId: input.codecId
+		}
+	});
+	if (!lowered.ok) {
+		input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_DEFAULT", `${label}: ${lowered.diagnostic.message}`, input.sourceId, span));
+		return;
+	}
+	return lowered.value.kind === "storage" ? {
+		storage: lowered.value.defaultValue,
+		onCreate: void 0
+	} : {
+		storage: void 0,
+		onCreate: lowered.value.generated
+	};
+}
+function parseIndexAttribute(attribute, owner, sourceId, indexTypes, diagnostics) {
+	const unsupported = (what, span) => {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_INDEX_ARGUMENT_UNSUPPORTED", `"${owner}": @${attribute.name} ${what}`, sourceId, span));
+	};
+	let fields;
+	let map;
+	let type;
+	for (const arg of attribute.args) {
+		const key = arg.kind === "positional" ? "fields" : arg.name;
+		const expression = arg.expression;
+		switch (key) {
+			case "fields": {
+				const array = expression === void 0 ? void 0 : ArrayLiteralAst.cast(expression.syntax);
+				if (array === void 0) return unsupported("expects a list of field names.", arg.span);
+				const names = [];
+				for (const element of array.elements()) {
+					const name = IdentifierAst.cast(element.syntax)?.name();
+					if (name === void 0) return unsupported("field arguments such as sort or length are not supported; Prisma 8 indexes carry none.", arg.span);
+					names.push(name);
+				}
+				fields = names;
+				break;
+			}
+			case "map":
+				map = expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+				if (map === void 0) return unsupported("map must be a string.", arg.span);
+				break;
+			case "name": break;
+			case "type": {
+				const token = expression === void 0 ? void 0 : IdentifierAst.cast(expression.syntax)?.name();
+				type = token !== void 0 && Object.hasOwn(indexTypes, token) ? indexTypes[token] : void 0;
+				if (type === void 0) return unsupported(`type "${token ?? ""}" is not an index type Prisma 8 supports.`, arg.span);
+				break;
+			}
+			default: return unsupported(`argument "${key ?? ""}" is not supported.`, arg.span);
+		}
+	}
+	return {
+		fields,
+		map,
+		type,
+		span: attribute.span
+	};
+}
+const utf8 = new TextEncoder();
+/**
+* A generated constraint name as Prisma 7 spells it: `base` cut so that
+* `base + suffix` is at most `maxBytes` bytes, cut on a character boundary,
+* with the suffix kept whole. Prisma 7.10.0 emits `..._aVeryLongCo_idx` for a
+* long `@@index`, `..._AB_pkey` and `..._B_index` for a long implicit junction,
+* and cuts a multi-byte name before the character that would cross the budget.
+*/
+function prisma7ConstraintName(base, suffix, maxBytes) {
+	const budget = maxBytes - utf8.encode(suffix).length;
+	let bytes = 0;
+	let kept = "";
+	for (const character of base) {
+		bytes += utf8.encode(character).length;
+		if (bytes > budget) break;
+		kept += character;
+	}
+	return `${kept}${suffix}`;
+}
+/** Prisma 7's default index name: `{table}_{columns}_idx`, or `_key` for a unique index, cut to `maxBytes`. */
+function defaultIndexName(tableName, columns, unique, maxBytes) {
+	return prisma7ConstraintName(`${tableName}_${columns.join("_")}`, unique ? "_key" : "_idx", maxBytes);
+}
+function indexNode(tableName, columns, attribute, unique, maxBytes) {
+	return {
+		columns,
+		...attribute.type === void 0 ? {
+			type: void 0,
+			options: void 0
+		} : {
+			type: attribute.type,
+			options: {}
+		},
+		where: void 0,
+		unique: unique ? true : void 0,
+		map: attribute.map ?? defaultIndexName(tableName, columns, unique, maxBytes),
+		name: void 0
+	};
+}
+function prisma7ScalarMapping(typeMap, scalar) {
+	return Object.hasOwn(typeMap.scalars, scalar) ? typeMap.scalars[scalar] : void 0;
+}
+function prisma7NativeTypeMapping(typeMap, nativeType, args) {
+	const mapping = Object.hasOwn(typeMap.nativeTypes, nativeType) ? typeMap.nativeTypes[nativeType] : void 0;
+	if (mapping === void 0) return void 0;
+	return args.length === 0 ? mapping : {
+		constructorName: mapping.constructorName,
+		args
+	};
+}
+/** The codes `applyBackrelationCandidates` reports, each shown as `PSL.PRISMA7_RELATION_UNRESOLVED`. */
+const RELATION_PAIRING_CODES = /* @__PURE__ */ new Set([
+	"PSL_ORPHANED_BACKRELATION",
+	"PSL_AMBIGUOUS_BACKRELATION",
+	"PSL_NON_UNIQUE_BACKRELATION",
+	"PSL_REQUIRED_ONE_TO_ONE_BACKRELATION",
+	"PSL_JUNCTION_ID_NOT_FK_COVERING",
+	"PSL_JUNCTION_TARGET_FK_NOT_ID"
+]);
+function identifierNames(expression) {
+	if (expression === void 0) return void 0;
+	const array = ArrayLiteralAst.cast(expression.syntax);
+	if (array === void 0) return void 0;
+	const names = [];
+	for (const element of array.elements()) {
+		const name = IdentifierAst.cast(element.syntax)?.name();
+		if (name === void 0) return void 0;
+		names.push(name);
+	}
+	return names;
+}
+function stringValue(expression) {
+	return expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+}
+const PRISMA7_REFERENTIAL_ACTIONS = /* @__PURE__ */ new Set([
+	"Cascade",
+	"Restrict",
+	"NoAction",
+	"SetNull",
+	"SetDefault"
+]);
+function actionValue(expression) {
+	const token = expression === void 0 ? void 0 : IdentifierAst.cast(expression.syntax)?.name();
+	return token !== void 0 && PRISMA7_REFERENTIAL_ACTIONS.has(token) ? normalizeReferentialAction(token) : void 0;
+}
+function parseRelationAttribute(attribute, label, sourceId, diagnostics) {
+	let name;
+	let fields;
+	let references;
+	let onDelete;
+	let onUpdate;
+	const invalid = (what, span) => {
+		diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${label}: @relation ${what}.`,
+			sourceId,
+			span
+		});
+	};
+	for (const arg of attribute.args) {
+		const key = arg.kind === "positional" ? "name" : arg.name;
+		switch (key) {
+			case "name":
+				name = stringValue(arg.expression);
+				if (name === void 0) return invalid("name must be a string", arg.span);
+				break;
+			case "fields":
+				fields = identifierNames(arg.expression);
+				if (fields === void 0) return invalid("fields must be a list of field names", arg.span);
+				break;
+			case "references":
+				references = identifierNames(arg.expression);
+				if (references === void 0) return invalid("references must be a list of field names", arg.span);
+				break;
+			case "onDelete":
+				onDelete = actionValue(arg.expression);
+				if (onDelete === void 0) return invalid("onDelete must be a referential action", arg.span);
+				break;
+			case "onUpdate":
+				onUpdate = actionValue(arg.expression);
+				if (onUpdate === void 0) return invalid("onUpdate must be a referential action", arg.span);
+				break;
+			case "map": break;
+			default: return invalid(`argument "${key ?? ""}" is not supported`, arg.span);
+		}
+	}
+	return {
+		name,
+		fields,
+		references,
+		onDelete,
+		onUpdate,
+		span: attribute.span
+	};
+}
+function columnNames(model, fieldNames) {
+	const columns = [];
+	for (const fieldName of fieldNames) {
+		const column = model.columns.get(fieldName);
+		if (column === void 0) return void 0;
+		columns.push(column.columnName);
+	}
+	return columns;
+}
+function unresolved(label, reason, sourceId, span) {
+	return prisma7Diagnostic("PSL.PRISMA7_RELATION_UNRESOLVED", `${label} ${reason}`, sourceId, span);
+}
+function groupBy(items, keyOf) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const group = groups.get(keyOf(item)) ?? [];
+		groups.set(keyOf(item), group);
+		group.push(item);
+	}
+	return groups;
+}
+function orderJunctionSides(requester, partner) {
+	return (requester.model === partner.model ? requester.field.field.name < partner.field.field.name : requester.model.modelName < partner.model.modelName) ? [requester, partner] : [partner, requester];
+}
+function junctionKey(namespaceId, name) {
+	return JSON.stringify([namespaceId, name]);
+}
+/**
+* Prisma 7's default relation name: the two model names in alphabetical
+* order joined by `To`. Giving every unnamed relation that name lets the
+* shared pairing helper match Prisma 7's rule that an unnamed side pairs only
+* with the unnamed side of the same model pair.
+*/
+function effectiveRelationName(attribute, modelName, targetModelName) {
+	if (attribute?.name !== void 0) return attribute.name;
+	const [first, second] = modelName < targetModelName ? [modelName, targetModelName] : [targetModelName, modelName];
+	return `${first}To${second}`;
+}
+/**
+* Prisma 7 accepts `SetNull` over a required field and `SetDefault` over a
+* required field with no default, and writes them into the foreign key; the
+* contract rejects both, because the action would fail the first time it runs.
+*/
+function referentialActionRejections(input) {
+	const { model, relationField, label, fieldNames, span } = input;
+	const anotherAction = "choose another action, which replaces the foreign key on Prisma 7's next migration and leaves the Prisma 7 client unchanged.";
+	const fieldsWhere = (predicate) => fieldNames.filter((name) => {
+		const column = model.columns.get(name);
+		return column !== void 0 && predicate(column);
+	});
+	const rejections = [];
+	for (const [key, action] of Object.entries(input.actions)) {
+		if (action === "setNull") {
+			const required = fieldsWhere((column) => !column.nullable);
+			if (required.length === 0) continue;
+			const fields = fieldList(model.modelName, required);
+			rejections.push(prisma7Diagnostic("PSL.PRISMA7_REFERENTIAL_ACTION_UNSUPPORTED", `${label}: ${key}: SetNull sets the foreign key fields to null, but ${fields} ${required.length === 1 ? "is" : "are"} required, so Prisma 8 cannot describe this foreign key. Make ${fields}${relationField.optional ? "" : ` and "${model.modelName}.${relationField.name}"`} optional, which drops NOT NULL on Prisma 7's next migration and makes ${required.length === 1 && relationField.optional ? "it" : "them"} nullable in the Prisma 7 client, or ${anotherAction}`, model.sourceId, span));
+		}
+		if (action === "setDefault") {
+			const withoutDefault = fieldsWhere((column) => !column.nullable && column.default === void 0);
+			if (withoutDefault.length === 0) continue;
+			const fields = fieldList(model.modelName, withoutDefault);
+			const one = withoutDefault.length === 1;
+			const generated = withoutDefault.filter((name) => model.columns.get(name)?.executionDefaults?.onCreate !== void 0);
+			const plain = withoutDefault.filter((name) => !generated.includes(name));
+			const generatorNote = generated.length > 0 ? " (a client-side generator such as uuid() does not give the column one)" : "";
+			const example = "a column default, such as a literal or @default(dbgenerated(\"<expression>\"))";
+			const plainFields = fieldList(model.modelName, plain);
+			const generatedFields = fieldList(model.modelName, generated);
+			const edit = generated.length === 0 ? `Give ${plainFields} ${example}` : plain.length === 0 ? `Replace the @default on ${generatedFields} with ${example}, because a field takes only one @default` : `Give ${plainFields} ${example}, and replace the @default on ${generatedFields} with one, because a field takes only one @default`;
+			const effects = [
+				`Prisma 7's next migration sets ${one ? "it" : "them"}`,
+				...plain.length > 0 ? [`${plainFields} ${plain.length === 1 ? "becomes" : "become"} optional when creating records with the Prisma 7 client`] : [],
+				...generated.length > 0 ? [`the Prisma 7 client stops generating ${generated.length === 1 ? "a value" : "values"} for ${generatedFields}`] : []
+			];
+			rejections.push(prisma7Diagnostic("PSL.PRISMA7_REFERENTIAL_ACTION_UNSUPPORTED", `${label}: ${key}: SetDefault sets the foreign key fields to their column defaults, but ${fields} ${one ? "is" : "are"} required and ${one ? "has" : "have"} no column default${generatorNote}, so Prisma 8 cannot describe this foreign key. ${edit}: ${andList(effects)}. Or ${anotherAction}`, model.sourceId, span));
+		}
+	}
+	return rejections;
+}
+function lowerRelations(models, naming, diagnostics) {
+	const fkRelationMetadata = [];
+	const candidates = [];
+	const invalidFkPairings = [];
+	const foreignKeys = /* @__PURE__ */ new Map();
+	const junctions = /* @__PURE__ */ new Map();
+	const reportedJunctionNames = /* @__PURE__ */ new Set();
+	const junctionRequests = [];
+	const addForeignKey = (modelName, node) => {
+		const existing = foreignKeys.get(modelName) ?? [];
+		foreignKeys.set(modelName, existing);
+		existing.push(node);
+	};
+	const isFkSide = (relationField) => relationField.attribute?.fields !== void 0;
+	const sameName = (left, right) => left.attribute?.name === right.attribute?.name;
+	const rejectFkSide = (model, relationField, ...rejections) => {
+		diagnostics.push(...rejections);
+		invalidFkPairings.push({
+			pairKey: fkRelationPairKey(model.modelName, relationField.targetModelName),
+			relationName: effectiveRelationName(relationField.attribute, model.modelName, relationField.targetModelName)
+		});
+	};
+	for (const model of models.values()) for (const relationField of model.relationFields) {
+		const { field, targetModelName } = relationField;
+		const label = `Relation field "${model.modelName}.${field.name}"`;
+		const target = models.get(targetModelName);
+		if (target === void 0) continue;
+		if (isFkSide(relationField)) {
+			const attribute = relationField.attribute;
+			if (attribute === void 0 || attribute.fields === void 0) continue;
+			const ignoredScalars = attribute.fields.filter((name) => model.ignoredFields.has(name));
+			if (ignoredScalars.length > 0) {
+				rejectFkSide(model, relationField, ignoredFieldReferenced({
+					modelName: model.modelName,
+					fieldNames: ignoredScalars,
+					usedBy: `relation field "${model.modelName}.${field.name}"`,
+					constraint: "foreign key",
+					sourceId: model.sourceId,
+					span: attribute.span
+				}));
+				continue;
+			}
+			if (attribute.references === void 0) {
+				rejectFkSide(model, relationField, unresolved(label, "declares fields without references.", model.sourceId, attribute.span));
+				continue;
+			}
+			if (attribute.fields.some((name) => model.rejectedFields.has(name)) || attribute.references.some((name) => target.ignoredFields.has(name) || target.rejectedFields.has(name))) {
+				rejectFkSide(model, relationField);
+				continue;
+			}
+			const localColumns = columnNames(model, attribute.fields);
+			const referencedColumns = columnNames(target, attribute.references);
+			if (localColumns === void 0 || referencedColumns === void 0) {
+				rejectFkSide(model, relationField, unresolved(label, "names a field that is not a scalar column of the model or its target.", model.sourceId, attribute.span));
+				continue;
+			}
+			if (localColumns.length !== referencedColumns.length) {
+				rejectFkSide(model, relationField, unresolved(label, "must list as many fields as references.", model.sourceId, attribute.span));
+				continue;
+			}
+			const nullability = attribute.fields.map((name) => model.columns.get(name)?.nullable === true);
+			const anyNullable = nullability.includes(true);
+			if (anyNullable && !field.optional) {
+				rejectFkSide(model, relationField, unresolved(label, "must be optional because one of its fields is optional.", model.sourceId, field.span));
+				continue;
+			}
+			const onDelete = attribute.onDelete ?? (nullability.includes(false) ? "restrict" : "setNull");
+			const onUpdate = attribute.onUpdate ?? "cascade";
+			const actionRejections = referentialActionRejections({
+				model,
+				relationField: field,
+				label,
+				fieldNames: attribute.fields,
+				actions: {
+					onDelete,
+					onUpdate
+				},
+				span: attribute.span
+			});
+			if (actionRejections.length > 0) {
+				rejectFkSide(model, relationField, ...actionRejections);
+				continue;
+			}
+			addForeignKey(model.modelName, {
+				columns: localColumns,
+				references: {
+					model: target.modelName,
+					table: target.tableName,
+					columns: referencedColumns,
+					namespaceId: target.namespaceId
+				},
+				onDelete,
+				onUpdate,
+				index: false
+			});
+			fkRelationMetadata.push({
+				declaringModelName: model.modelName,
+				declaringFieldName: field.name,
+				declaringTableName: model.tableName,
+				declaringNamespaceId: model.namespaceId,
+				targetModelName: target.modelName,
+				targetTableName: target.tableName,
+				targetNamespaceId: target.namespaceId,
+				relationName: effectiveRelationName(attribute, model.modelName, target.modelName),
+				nullable: anyNullable,
+				localColumns,
+				referencedColumns
+			});
+			continue;
+		}
+		if (target.ignoredRelationFields.some((other) => other.targetModelName === model.modelName && sameName(other, relationField))) continue;
+		if (target.relationFields.filter((other) => other.targetModelName === model.modelName && isFkSide(other) && sameName(other, relationField)).length > 0 || !field.list) {
+			candidates.push({
+				modelName: model.modelName,
+				tableName: model.tableName,
+				field,
+				targetModelName: target.modelName,
+				isList: field.list,
+				relationName: effectiveRelationName(relationField.attribute, model.modelName, target.modelName)
+			});
+			continue;
+		}
+		const partners = target.relationFields.filter((other) => other !== relationField && other.targetModelName === model.modelName && other.field.list && !isFkSide(other) && sameName(other, relationField));
+		const [partner] = partners;
+		if (partner === void 0) {
+			diagnostics.push(unresolved(label, `has no matching relation field on "${target.modelName}".`, model.sourceId, field.span));
+			continue;
+		}
+		if (partners.length > 1 || target === model && relationField.attribute?.name === void 0) {
+			diagnostics.push(unresolved(label, `is ambiguous: more than one list field on "${target.modelName}" could pair with it. Name both sides with @relation("name").`, model.sourceId, field.span));
+			continue;
+		}
+		const junctionName = effectiveRelationName(relationField.attribute, model.modelName, target.modelName);
+		const requester = {
+			model,
+			field: relationField
+		};
+		const partnerSide = {
+			model: target,
+			field: partner
+		};
+		const junctionNamespaceId = orderJunctionSides(requester, partnerSide)[0].model.namespaceId;
+		const namesake = models.get(junctionName);
+		if (namesake !== void 0 && namesake.namespaceId === junctionNamespaceId) {
+			const reportedKey = junctionKey(junctionNamespaceId, junctionName);
+			if (!reportedJunctionNames.has(reportedKey)) {
+				reportedJunctionNames.add(reportedKey);
+				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_JUNCTION_NAME_COLLISION", `${label} is an implicit many-to-many relation whose junction model would be named "${junctionName}", but model "${junctionName}" already has that name. Rename model "${junctionName}" and keep its table with @@map("${namesake.tableName}"); Prisma 7's next migration is then empty.`, model.sourceId, field.span));
+			}
+			continue;
+		}
+		junctionRequests.push({
+			requester,
+			partner: partnerSide,
+			name: junctionName
+		});
+	}
+	const requestsByJunction = groupBy(junctionRequests, (request) => junctionKey(orderJunctionSides(request.requester, request.partner)[0].model.namespaceId, request.name));
+	for (const requests of requestsByJunction.values()) {
+		const [first] = requests;
+		if (first === void 0) continue;
+		const name = first.name;
+		const [sideA] = orderJunctionSides(first.requester, first.partner);
+		const tableName = prisma7ConstraintName(`_${name}`, "", naming.identifierMaxBytes);
+		const sideLabel = (side) => `${side.model.modelName}.${side.field.field.name}`;
+		const pairs = /* @__PURE__ */ new Map();
+		for (const request of requests) {
+			const key = [sideLabel(request.requester), sideLabel(request.partner)].sort().join("|");
+			if (!pairs.has(key)) pairs.set(key, request);
+		}
+		if (pairs.size > 1) {
+			const pairRequests = [...pairs.values()];
+			for (const request of pairRequests) {
+				const others = pairRequests.filter((other) => other !== request).map((other) => `"${sideLabel(other.requester)}"`);
+				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_RELATION_NAME_SHARED", `Relation field "${sideLabel(request.requester)}" is an implicit many-to-many relation named "${name}", and so ${others.length === 1 ? "is relation field" : "are relation fields"} ${andList(others)}; Prisma 7 creates one table "${tableName}" for them, wired to only one of the relations (its foreign keys show which). Give each relation its own name with @relation("<name>") on both fields: renaming a relation that "${tableName}" does not reference makes Prisma 7's next migration create its own table, while renaming the one it references moves "${tableName}"'s foreign keys to another relation, which fails on rows whose ids that relation's models lack and attaches the rest to the wrong records.`, request.requester.model.sourceId, request.requester.field.field.span));
+			}
+			continue;
+		}
+		const tableOwner = [...models.values()].find((other) => other.tableName === tableName && other.namespaceId === sideA.model.namespaceId);
+		if (tableOwner !== void 0) {
+			const relationField = `${first.requester.model.modelName}.${first.requester.field.field.name}`;
+			const message = `Model "${tableOwner.modelName}" and the implicit many-to-many relation "${relationField}" both use table "${tableOwner.namespaceId}"."${tableName}"; Prisma 7 creates the relation's table there and never creates the model's. Rename the model's table with @@map, which makes Prisma 7's next migration create it, or give the relation its own name with @relation("<name>") on both fields, which makes Prisma 7's next migration rebuild "${tableName}" as the model's table and create an empty table for the relation, losing the relation's rows.`;
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_TABLE_COLLISION", message, tableOwner.sourceId, tableOwner.tableSpan), prisma7Diagnostic("PSL.PRISMA7_TABLE_COLLISION", message, first.requester.model.sourceId, first.requester.field.field.span));
+			continue;
+		}
+		for (const { requester, partner } of requests) {
+			const junction = synthesizeJunction(requester, partner, naming, diagnostics);
+			if (junction === void 0) continue;
+			if (!junctions.has(junction.key)) {
+				junctions.set(junction.key, junction.node);
+				fkRelationMetadata.push(...junction.foreignKeys);
+			}
+			candidates.push({
+				modelName: requester.model.modelName,
+				tableName: requester.model.tableName,
+				field: requester.field.field,
+				targetModelName: partner.model.modelName,
+				isList: true,
+				relationName: junction.candidateRelationName
+			});
+		}
+	}
+	const { modelRelations, fkRelationsByPair, fkRelationsByDeclaringModel } = indexFkRelations({ fkRelationMetadata });
+	const modelIdColumns = /* @__PURE__ */ new Map();
+	const modelUniqueColumnSets = /* @__PURE__ */ new Map();
+	for (const model of models.values()) {
+		const id = columnNames(model, model.idFields);
+		if (id !== void 0 && id.length > 0) modelIdColumns.set(model.modelName, id);
+		const sets = [];
+		if (id !== void 0 && id.length > 0) sets.push(id);
+		for (const unique of model.uniqueFieldSets) {
+			const columns = columnNames(model, unique);
+			if (columns !== void 0) sets.push(columns);
+		}
+		modelUniqueColumnSets.set(model.modelName, sets);
+	}
+	for (const key of junctions.keys()) {
+		modelIdColumns.set(key, ["A", "B"]);
+		modelUniqueColumnSets.set(key, [["A", "B"]]);
+	}
+	const pairingDiagnostics = [];
+	const candidatesBySourceId = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const sourceId = models.get(candidate.modelName)?.sourceId ?? "schema.prisma";
+		const group = candidatesBySourceId.get(sourceId) ?? [];
+		candidatesBySourceId.set(sourceId, group);
+		group.push(candidate);
+	}
+	for (const [sourceId, backrelationCandidates] of candidatesBySourceId) applyBackrelationCandidates({
+		backrelationCandidates,
+		fkRelationsByPair,
+		invalidFkPairings,
+		fkRelationsByDeclaringModel,
+		modelIdColumns,
+		modelUniqueColumnSets,
+		modelRelations,
+		diagnostics: pairingDiagnostics,
+		sourceId
+	});
+	for (const diagnostic of pairingDiagnostics) diagnostics.push(RELATION_PAIRING_CODES.has(diagnostic.code) ? {
+		...diagnostic,
+		code: "PSL.PRISMA7_RELATION_UNRESOLVED"
+	} : diagnostic);
+	const relations = /* @__PURE__ */ new Map();
+	for (const [modelName, nodes] of modelRelations) relations.set(modelName, [...nodes].sort((left, right) => left.fieldName.localeCompare(right.fieldName)));
+	return {
+		junctions,
+		foreignKeys,
+		relations
+	};
+}
+/**
+* The id column a junction side contributes. The diagnostic names the
+* requesting relation field, so it is located at that field, whichever side's
+* id is at fault.
+*/
+function singleIdColumn(side, requester, diagnostics) {
+	if (side.model.idFields.some((name) => side.model.ignoredFields.has(name) || side.model.rejectedFields.has(name))) return;
+	const [idField, ...rest] = side.model.idFields;
+	const column = idField === void 0 ? void 0 : side.model.columns.get(idField);
+	if (column === void 0 || rest.length > 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_JUNCTION_ID_UNSUPPORTED", `Relation field "${requester.model.modelName}.${requester.field.field.name}" is an implicit many-to-many relation, but "${side.model.modelName}" ${column === void 0 ? "has no single-field @id" : "has a composite id"}; Prisma 7 requires a single-field @id on both models of an implicit many-to-many relation.`, requester.model.sourceId, requester.field.field.span));
+		return;
+	}
+	return column;
+}
+/**
+* Prisma 7's implicit junction: table `_AToB` (or `_Name`), columns `A` and `B`
+* typed like the two ids, primary key `(A, B)`, index `_AToB_B_index`, and two
+* cascading foreign keys, with relation fields named as `contract infer` names
+* them. `A` is the model whose name is smaller in plain
+* string order; for a self-relation, the field whose name is smaller. This is
+* prisma-engines' rule (`psl/parser-database/src/relations.rs`,
+* `ingest_relation`: the side with the greater model name, or field name for a
+* self relation, is skipped so the smaller one owns `field_a`).
+*/
+function synthesizeJunction(requester, partner, naming, diagnostics) {
+	const [sideA, sideB] = orderJunctionSides(requester, partner);
+	const requesterFirst = sideA === requester;
+	const name = requester.field.attribute?.name ?? `${sideA.model.modelName}To${sideB.model.modelName}`;
+	const idA = singleIdColumn(sideA, requester, diagnostics);
+	const idB = singleIdColumn(sideB, requester, diagnostics);
+	if (idA === void 0 || idB === void 0) return void 0;
+	const tableName = prisma7ConstraintName(`_${name}`, "", naming.identifierMaxBytes);
+	const namespaceId = sideA.model.namespaceId;
+	const key = junctionKey(namespaceId, name);
+	const [relationFieldA, relationFieldB] = naming.junctionRelationFieldNames(sideA.model.tableName, sideB.model.tableName);
+	const foreignKey = (column, side, id) => ({
+		columns: [column],
+		references: {
+			model: side.model.modelName,
+			table: side.model.tableName,
+			columns: [id.columnName],
+			namespaceId: side.model.namespaceId
+		},
+		onDelete: "cascade",
+		onUpdate: "cascade",
+		index: false
+	});
+	const metadata = (column, side, id) => ({
+		declaringModelName: key,
+		declaringFieldName: column === "A" ? relationFieldA : relationFieldB,
+		declaringTableName: tableName,
+		declaringNamespaceId: namespaceId,
+		targetModelName: side.model.modelName,
+		targetTableName: side.model.tableName,
+		targetNamespaceId: side.model.namespaceId,
+		relationName: `${name}:${column}`,
+		nullable: false,
+		localColumns: [column],
+		referencedColumns: [id.columnName]
+	});
+	const index = {
+		columns: ["B"],
+		type: void 0,
+		options: void 0,
+		where: void 0,
+		unique: void 0,
+		map: prisma7ConstraintName(`_${name}`, "_B_index", naming.identifierMaxBytes),
+		name: void 0
+	};
+	return {
+		key,
+		node: {
+			modelName: name,
+			tableName,
+			namespaceId,
+			fields: [{
+				fieldName: "A",
+				columnName: "A",
+				descriptor: idA.descriptor,
+				nullable: false
+			}, {
+				fieldName: "B",
+				columnName: "B",
+				descriptor: idB.descriptor,
+				nullable: false
+			}],
+			id: { columns: ["A", "B"] },
+			indexes: [index],
+			foreignKeys: [foreignKey("A", sideA, idA), foreignKey("B", sideB, idB)]
+		},
+		foreignKeys: [metadata("A", sideA, idA), metadata("B", sideB, idB)],
+		candidateRelationName: requesterFirst ? `${name}:A` : `${name}:B`
+	};
+}
+const SUMMARY = "Prisma 7 schema interpretation failed";
+const EMPTY_DESCRIPTORS = /* @__PURE__ */ new Map();
+function attributeText(attribute) {
+	const args = attribute.args.map((arg) => arg.kind === "named" ? `${arg.name}: ${arg.value}` : arg.value);
+	return args.length === 0 ? `@${attribute.name}` : `@${attribute.name}(${args.join(", ")})`;
+}
+function stringArgument(attribute) {
+	const expression = (attribute.args.find((arg) => arg.kind === "positional") ?? attribute.args.find((arg) => arg.name === "name"))?.expression;
+	if (expression === void 0) return void 0;
+	return StringLiteralExprAst.cast(expression.syntax)?.value();
+}
+function scalarValue(block, key) {
+	const parameter = block.parameters[key];
+	if (parameter?.kind !== "value") return void 0;
+	try {
+		const parsed = JSON.parse(parameter.raw);
+		return typeof parsed === "string" ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function parameterSpan(block, key) {
+	const parameter = block.parameters[key];
+	return parameter === void 0 ? block.span : parameter.span;
+}
+function interpretPrisma7Documents(input) {
+	const { binding } = input;
+	const diagnostics = [...input.seedDiagnostics];
+	const defaultNamespaceId = binding.target.defaultNamespaceId;
+	const datasources = [];
+	const enumBlocks = [];
+	const models = [];
+	const ignoredModels = /* @__PURE__ */ new Set();
+	const declaredNames = /* @__PURE__ */ new Map();
+	const claimName = (kind, name, sourceId, span) => {
+		const previous = declaredNames.get(name);
+		if (previous === void 0) {
+			declaredNames.set(name, sourceId);
+			return true;
+		}
+		diagnostics.push({
+			code: "PSL_DUPLICATE_DECLARATION",
+			message: `Duplicate declaration of ${kind} "${name}"; first declared in ${basename(previous)}.`,
+			sourceId,
+			span
+		});
+		return false;
+	};
+	for (const { document, sourceFile, sourceId } of input.documents) {
+		const { table, diagnostics: tableDiagnostics } = buildSymbolTable({
+			document,
+			sourceFile,
+			pslBlockDescriptors: {}
+		});
+		for (const diagnostic of tableDiagnostics) diagnostics.push({
+			code: diagnostic.code,
+			message: diagnostic.message,
+			sourceId,
+			span: rangeToPslSpan(diagnostic.range, sourceFile)
+		});
+		const unsupported = (keyword, span) => {
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_TOP_LEVEL_BLOCK",
+				message: `Unsupported top-level block "${keyword}"`,
+				sourceId,
+				span
+			});
+		};
+		for (const block of Object.values(table.topLevel.blocks)) switch (block.keyword) {
+			case "datasource":
+				datasources.push({
+					block,
+					sourceId,
+					sourceFile
+				});
+				break;
+			case "generator": break;
+			case "enum":
+				if (claimName("enum", block.name, sourceId, block.span)) enumBlocks.push({
+					block,
+					sourceId,
+					sourceFile
+				});
+				break;
+			case "view":
+				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_VIEW_UNSUPPORTED", `View "${block.name}" is not supported; Prisma 8 has no views. Remove the view or replace it with a model over the underlying table.`, sourceId, keywordPslSpan(block.node.syntax, block.keyword, sourceFile)));
+				break;
+			default: unsupported(block.keyword, keywordPslSpan(block.node.syntax, block.keyword, sourceFile));
+		}
+		for (const namespace of Object.values(table.topLevel.namespaces)) unsupported("namespace", namespace.span);
+		for (const compositeType of Object.values(table.topLevel.compositeTypes)) unsupported("type", compositeType.span);
+		for (const namedType of Object.values(table.topLevel.namedTypes)) unsupported("types", namedType.span);
+		for (const symbol of Object.values(table.topLevel.models)) {
+			if (!claimName("model", symbol.name, sourceId, symbol.span)) continue;
+			const declaration = readModelDeclaration(symbol, sourceId, defaultNamespaceId, binding.indexTypes, diagnostics);
+			if (declaration === void 0) ignoredModels.add(symbol.name);
+			else models.push(declaration);
+		}
+	}
+	checkDatasource(datasources, input.documents[0]?.sourceId ?? "schema.prisma", binding, diagnostics);
+	reportTableCollisions(models, diagnostics);
+	const enums = /* @__PURE__ */ new Map();
+	for (const source of enumBlocks) {
+		const declaration = readEnumDeclaration(source, defaultNamespaceId, diagnostics);
+		if (declaration !== void 0) enums.set(declaration.name, declaration);
+	}
+	const namespaceEntities = lowerNativeEnums(enums, input, diagnostics);
+	const modelNames = /* @__PURE__ */ new Set([...models.map((model) => model.symbol.name), ...ignoredModels]);
+	const scalarColumnDescriptors = collectScalarTypeConstructors(input.authoringContributions.type);
+	const composedExtensions = new Set(input.composedExtensions);
+	const builds = /* @__PURE__ */ new Map();
+	for (const declaration of models) {
+		const build = {
+			declaration,
+			columns: /* @__PURE__ */ new Map(),
+			ignoredFields: /* @__PURE__ */ new Set(),
+			ignoredRelationFields: [],
+			rejectedFields: /* @__PURE__ */ new Set(),
+			idFields: declaration.id?.fields ?? [],
+			uniqueIndexes: [...declaration.uniqueIndexes],
+			relationFields: []
+		};
+		for (const field of Object.values(declaration.symbol.fields)) {
+			const reported = diagnostics.length;
+			readField({
+				field,
+				build,
+				modelNames,
+				ignoredModels,
+				enums,
+				namespaceEntities,
+				scalarColumnDescriptors,
+				composedExtensions,
+				input,
+				diagnostics
+			});
+			if (diagnostics.length > reported && !build.columns.has(field.name) && !build.ignoredFields.has(field.name)) build.rejectedFields.add(field.name);
+		}
+		builds.set(declaration.symbol.name, build);
+	}
+	const relationModels = /* @__PURE__ */ new Map();
+	for (const [modelName, build] of builds) relationModels.set(modelName, {
+		modelName,
+		tableName: build.declaration.tableName,
+		tableSpan: build.declaration.symbol.attributes.find((attribute) => attribute.name === "map")?.span ?? build.declaration.symbol.span,
+		namespaceId: build.declaration.namespaceId,
+		sourceId: build.declaration.sourceId,
+		columns: build.columns,
+		ignoredFields: build.ignoredFields,
+		ignoredRelationFields: build.ignoredRelationFields,
+		rejectedFields: build.rejectedFields,
+		idFields: build.idFields,
+		uniqueFieldSets: build.uniqueIndexes.flatMap((index) => index.fields === void 0 ? [] : [index.fields]),
+		relationFields: build.relationFields
+	});
+	const lowered = lowerRelations(relationModels, binding, diagnostics);
+	const modelNodes = [];
+	for (const [modelName, build] of builds) {
+		const model = relationModels.get(modelName);
+		if (model === void 0) continue;
+		const ignoredAmong = (fieldNames) => fieldNames?.filter((name) => build.ignoredFields.has(name)) ?? [];
+		const idAttribute = build.declaration.id;
+		const ignoredIdFields = ignoredAmong(idAttribute?.fields);
+		if (idAttribute !== void 0 && ignoredIdFields.length > 0) diagnostics.push(ignoredFieldReferenced({
+			modelName,
+			fieldNames: ignoredIdFields,
+			usedBy: `@@id on model "${modelName}"`,
+			constraint: "primary key",
+			sourceId: model.sourceId,
+			span: idAttribute.span
+		}));
+		const id = keyColumns(model, model.idFields);
+		const indexes = [...build.uniqueIndexes.map((attribute) => ({
+			attribute,
+			unique: true
+		})), ...build.declaration.indexes.map((attribute) => ({
+			attribute,
+			unique: false
+		}))].flatMap(({ attribute, unique }) => {
+			const ignoredIndexFields = ignoredAmong(attribute.fields);
+			if (ignoredIndexFields.length > 0) {
+				diagnostics.push(ignoredFieldReferenced({
+					modelName,
+					fieldNames: ignoredIndexFields,
+					usedBy: `${unique ? "@@unique" : "@@index"} on model "${modelName}"`,
+					constraint: unique ? "unique index" : "index",
+					sourceId: model.sourceId,
+					span: attribute.span
+				}));
+				return [];
+			}
+			if (attribute.fields?.some((name) => build.rejectedFields.has(name))) return [];
+			const columns = attribute.fields === void 0 ? void 0 : keyColumns(model, attribute.fields);
+			if (columns === void 0) {
+				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_INDEX_ARGUMENT_UNSUPPORTED", `Model "${modelName}": an index names a field that is not a scalar column of the model.`, model.sourceId, attribute.span));
+				return [];
+			}
+			return [indexNode(model.tableName, columns, attribute, unique, binding.identifierMaxBytes)];
+		});
+		const foreignKeys = lowered.foreignKeys.get(modelName);
+		const relations = lowered.relations.get(modelName);
+		modelNodes.push({
+			modelName,
+			tableName: model.tableName,
+			namespaceId: model.namespaceId,
+			fields: [...build.columns.values()],
+			...id !== void 0 && id.length > 0 ? { id: { columns: id } } : {},
+			...indexes.length > 0 ? { indexes } : {},
+			...foreignKeys !== void 0 ? { foreignKeys } : {},
+			...relations !== void 0 ? { relations } : {}
+		});
+	}
+	for (const [key, junction] of lowered.junctions) {
+		const relations = lowered.relations.get(key);
+		modelNodes.push(relations === void 0 ? junction : {
+			...junction,
+			relations
+		});
+	}
+	if (diagnostics.length > 0) return notOk({
+		summary: SUMMARY,
+		diagnostics
+	});
+	const createNamespace = (namespace) => {
+		const entities = namespaceEntities.get(namespace.id);
+		if (entities === void 0) return binding.createNamespace(namespace);
+		const valueSet = {
+			...namespace.entries["valueSet"],
+			...entities["valueSet"]
+		};
+		return binding.createNamespace({
+			...namespace,
+			entries: {
+				...namespace.entries,
+				...entities,
+				...Object.keys(valueSet).length > 0 ? { valueSet } : {}
+			}
+		});
+	};
+	return ok(buildSqlContractFromDefinition({
+		target: binding.target,
+		warnings: void 0,
+		createNamespace,
+		...namespaceEntities.size > 0 ? { namespaces: [...namespaceEntities.keys()] } : {},
+		models: modelNodes
+	}, input.codecLookup));
+}
+function checkDatasource(datasources, fallbackSourceId, binding, diagnostics) {
+	const [datasource] = datasources;
+	const [namedProvider] = binding.providers;
+	if (datasource === void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_PROVIDER_MISMATCH", `No datasource block found; add \`datasource db { provider = "${namedProvider}" }\`.`, fallbackSourceId, void 0));
+		return;
+	}
+	const block = datasource.block.block;
+	const provider = scalarValue(block, "provider");
+	if (provider === void 0 || !binding.providers.includes(provider)) diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_PROVIDER_MISMATCH", provider === void 0 ? `The datasource block declares no string \`provider\`; this contract source reads Prisma 7 schemas for provider "${namedProvider}".` : `The datasource provider is "${provider}"; this contract source reads Prisma 7 schemas for provider "${namedProvider}".`, datasource.sourceId, parameterSpan(block, "provider")));
+	for (const [property, edit] of Object.entries({
+		relationMode: "Removing relationMode, or setting it to \"foreignKeys\"",
+		referentialIntegrity: "Removing referentialIntegrity, or replacing it with relationMode = \"foreignKeys\""
+	})) {
+		if (scalarValue(block, property) !== "prisma") continue;
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_RELATION_MODE_UNSUPPORTED", `${property} = "prisma" is not supported: the contract declares the foreign keys its relations need, and in this mode Prisma 7 creates none. ${edit}, makes Prisma 7's next migration add those foreign keys, and that migration fails if any existing row breaks one.`, datasource.sourceId, parameterSpan(block, property)));
+	}
+}
+function reportTableCollisions(models, diagnostics) {
+	const byTable = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const key = `${model.namespaceId}.${model.tableName}`;
+		const group = byTable.get(key) ?? [];
+		byTable.set(key, group);
+		group.push(model);
+	}
+	for (const group of byTable.values()) {
+		if (group.length < 2) continue;
+		const names = group.map((model) => `"${model.symbol.name}"`).join(", ");
+		for (const model of group) {
+			const mapAttribute = model.symbol.attributes.find((attribute) => attribute.name === "map");
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_TABLE_COLLISION", `Models ${names} all map to table "${model.namespaceId}"."${model.tableName}"; each model needs its own table.`, model.sourceId, mapAttribute?.span ?? model.symbol.span));
+		}
+	}
+}
+function keyColumns(model, fieldNames) {
+	const columns = [];
+	for (const fieldName of fieldNames) {
+		const column = model.columns.get(fieldName);
+		if (column === void 0) return void 0;
+		columns.push(column.columnName);
+	}
+	return columns;
+}
+function readModelDeclaration(symbol, sourceId, defaultNamespaceId, indexTypes, diagnostics) {
+	if (symbol.attributes.some((attribute) => attribute.name === "ignore")) return void 0;
+	let tableName = symbol.name;
+	let namespaceId = defaultNamespaceId;
+	let id;
+	const uniqueIndexes = [];
+	const indexes = [];
+	for (const attribute of symbol.attributes) switch (attribute.name) {
+		case "map":
+			tableName = requireStringArgument(attribute, symbol.name, sourceId, diagnostics) ?? tableName;
+			break;
+		case "schema":
+			namespaceId = requireStringArgument(attribute, symbol.name, sourceId, diagnostics) ?? namespaceId;
+			break;
+		case "id": {
+			const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
+			if (parsed?.fields !== void 0) id = parsed;
+			break;
+		}
+		case "unique": {
+			const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
+			if (parsed?.fields !== void 0) uniqueIndexes.push(parsed);
+			break;
+		}
+		case "index": {
+			const parsed = parseIndexAttribute(attribute, symbol.name, sourceId, indexTypes, diagnostics);
+			if (parsed?.fields !== void 0) indexes.push(parsed);
+			break;
+		}
+		default: diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `Model "${symbol.name}": attribute "@@${attribute.name}" is not supported yet by the Prisma 7 contract source.`, sourceId, attribute.span));
+	}
+	return {
+		symbol,
+		sourceId,
+		namespaceId,
+		tableName,
+		id,
+		uniqueIndexes,
+		indexes
+	};
+}
+function requireStringArgument(attribute, owner, sourceId, diagnostics) {
+	const value = stringArgument(attribute);
+	if (value === void 0) diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `"${owner}": attribute "${attribute.name}" expects one string argument.`,
+		sourceId,
+		span: attribute.span
+	});
+	return value;
+}
+function readEnumDeclaration(source, defaultNamespaceId, diagnostics) {
+	const { block, sourceId, sourceFile } = source;
+	let typeName = block.name;
+	let namespaceId = defaultNamespaceId;
+	for (const attribute of readResolvedAttributes(block.node.attributes(), sourceFile)) switch (attribute.name) {
+		case "map":
+			typeName = requireStringArgument(attribute, block.name, sourceId, diagnostics) ?? typeName;
+			break;
+		case "schema":
+			namespaceId = requireStringArgument(attribute, block.name, sourceId, diagnostics) ?? namespaceId;
+			break;
+		default: diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `Enum "${block.name}": attribute "@@${attribute.name}" is not supported by the Prisma 7 contract source.`, sourceId, attribute.span));
+	}
+	const members = [];
+	for (const entry of block.node.entries()) {
+		const name = entry.key()?.name();
+		if (name === void 0) continue;
+		let value = name;
+		const span = nodePslSpan(entry.syntax, sourceFile);
+		for (const attributeNode of entry.attributes()) {
+			const attribute = readResolvedAttribute(attributeNode, sourceFile);
+			if (attribute.name === "map") value = requireStringArgument(attribute, `${block.name}.${name}`, sourceId, diagnostics) ?? value;
+			else diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `Enum member "${block.name}.${name}": attribute "@${attribute.name}" is not supported by the Prisma 7 contract source.`, sourceId, attribute.span));
+		}
+		members.push({
+			name,
+			value,
+			span
+		});
+	}
+	return {
+		name: block.name,
+		typeName,
+		namespaceId,
+		members,
+		span: block.span,
+		sourceId
+	};
+}
+function lowerNativeEnums(enums, input, diagnostics) {
+	const result = /* @__PURE__ */ new Map();
+	if (enums.size === 0) return result;
+	const { entityKind } = input.binding.nativeEnum;
+	const descriptor = buildEntityTypesByDiscriminator(input.authoringContributions).get(entityKind);
+	for (const declaration of enums.values()) {
+		if (descriptor === void 0) {
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `Enum "${declaration.name}" cannot be lowered: target "${input.binding.target.targetId}" registers no "${entityKind}" entity kind.`, declaration.sourceId, declaration.span));
+			continue;
+		}
+		const context = {
+			family: input.binding.target.familyId,
+			target: input.binding.target.targetId,
+			codecLookup: input.codecLookup,
+			sourceId: declaration.sourceId,
+			diagnostics: { push: (diagnostic) => {
+				diagnostics.push(blindCast(diagnostic));
+			} }
+		};
+		const entity = instantiateAuthoringEntityType(entityKind, descriptor, [{
+			kind: entityKind,
+			keyword: entityKind,
+			name: declaration.name,
+			parameters: Object.fromEntries(declaration.members.map((member) => [member.name, {
+				kind: "value",
+				raw: JSON.stringify(member.value),
+				span: member.span
+			}])),
+			blockAttributes: [],
+			attributes: { map: {
+				args: { name: declaration.typeName },
+				span: declaration.span
+			} },
+			span: declaration.span,
+			namespaceId: declaration.namespaceId
+		}], context);
+		if (entity === void 0) continue;
+		const entities = result.get(declaration.namespaceId) ?? {};
+		result.set(declaration.namespaceId, entities);
+		entities[entityKind] = {
+			...entities[entityKind],
+			[declaration.name]: entity
+		};
+		const valueSet = deriveValueSetFromEntity(descriptor.output, entity);
+		if (valueSet !== void 0) entities["valueSet"] = {
+			...entities["valueSet"],
+			[declaration.name]: valueSet
+		};
+	}
+	return result;
+}
+function keysUsingField(field, model) {
+	const modelName = model.symbol.name;
+	const uses = [];
+	for (const attribute of field.attributes) {
+		if (attribute.name === "id") uses.push({
+			usedBy: "its @id",
+			constraint: "primary key"
+		});
+		if (attribute.name === "unique") uses.push({
+			usedBy: "its @unique",
+			constraint: "unique index"
+		});
+	}
+	if (model.id?.fields?.includes(field.name)) uses.push({
+		usedBy: `@@id on model "${modelName}"`,
+		constraint: "primary key"
+	});
+	for (const unique of model.uniqueIndexes) if (unique.fields?.includes(field.name)) uses.push({
+		usedBy: `@@unique on model "${modelName}"`,
+		constraint: "unique index"
+	});
+	for (const index of model.indexes) if (index.fields?.includes(field.name)) uses.push({
+		usedBy: `@@index on model "${modelName}"`,
+		constraint: "index"
+	});
+	for (const other of Object.values(model.symbol.fields)) {
+		if (other.attributes.some((attribute) => attribute.name === "ignore")) continue;
+		const relation = other.attributes.find((attribute) => attribute.name === "relation");
+		if ((relation === void 0 ? void 0 : parseRelationAttribute(relation, other.name, model.sourceId, []))?.fields?.includes(field.name)) uses.push({
+			usedBy: `relation field "${modelName}.${other.name}"`,
+			constraint: "foreign key"
+		});
+	}
+	return uses;
+}
+function nativeTypeMessage(input) {
+	const { label, nativeType, field, model } = input;
+	const uses = keysUsingField(field, model);
+	if (uses.length > 0) {
+		const constraints = [...new Set(uses.map((use) => `the ${use.constraint}`))];
+		return `${label}: native type "@db.${nativeType}" has no Prisma 8 codec, and ${andList(uses.map((use) => use.usedBy))} ${uses.length === 1 ? "uses" : "use"} the field, so @ignore on the field does not help: Prisma 7 still creates ${andList(constraints)} over the column. Add @@ignore to model "${model.symbol.name}" to keep the model out of the contract: Prisma 7's next migration is empty, but the model disappears from the Prisma 7 client too, and every relation field in another model that points to it needs @ignore, which removes that field from the Prisma 7 client as well. Changing the field's type instead changes the column type on Prisma 7's next migration.`;
+	}
+	return `${label}: native type "@db.${nativeType}" has no Prisma 8 codec. Add @ignore to the field to keep its column out of the contract: Prisma 7's next migration is empty, and the field disappears from the Prisma 7 client too${!field.optional && !field.list && !givesColumnDefault(input.defaultAttribute) ? "; because the field is required and its column has no default, neither client can then insert rows" : ""}. Changing the field's type instead changes the column type on Prisma 7's next migration.`;
+}
+function readIgnoredField(field, isRelationField, args) {
+	const { build, diagnostics } = args;
+	const model = build.declaration;
+	if (isRelationField) {
+		if (args.ignoredModels.has(field.typeName)) return;
+		const relation = field.attributes.find((attribute) => attribute.name === "relation");
+		build.ignoredRelationFields.push({
+			field,
+			targetModelName: field.typeName,
+			attribute: relation === void 0 ? void 0 : parseRelationAttribute(relation, field.name, model.sourceId, [])
+		});
+		return;
+	}
+	for (const attribute of field.attributes) {
+		if (attribute.name !== "id" && attribute.name !== "unique") continue;
+		if (attribute.name === "id") build.idFields = [field.name];
+		diagnostics.push(ignoredFieldReferenced({
+			modelName: model.symbol.name,
+			fieldNames: [field.name],
+			usedBy: `its @${attribute.name}`,
+			constraint: attribute.name === "id" ? "primary key" : "unique index",
+			sourceId: model.sourceId,
+			span: attribute.span
+		}));
+	}
+}
+function readField(args) {
+	const { field, build, diagnostics, input } = args;
+	const { binding } = input;
+	const model = build.declaration;
+	const sourceId = model.sourceId;
+	const label = `Field "${model.symbol.name}.${field.name}"`;
+	const isRelationField = args.modelNames.has(field.typeName) && field.typeConstructor === void 0;
+	if (field.attributes.some((attribute) => attribute.name === "ignore")) {
+		build.ignoredFields.add(field.name);
+		readIgnoredField(field, isRelationField, args);
+		return;
+	}
+	let columnName = field.name;
+	let nativeType;
+	let relation;
+	let defaultAttribute;
+	let updatedAt;
+	for (const attribute of field.attributes) if (attribute.name === "map" && !isRelationField) columnName = requireStringArgument(attribute, label, sourceId, diagnostics) ?? columnName;
+	else if (attribute.name.startsWith("db.") && !isRelationField) nativeType = {
+		name: attribute.name.slice(3),
+		attribute
+	};
+	else if (attribute.name === "id" && !isRelationField) {
+		if (parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics) !== void 0) build.idFields = [field.name];
+	} else if (attribute.name === "unique" && !isRelationField) {
+		const parsed = parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics);
+		if (parsed !== void 0) build.uniqueIndexes.push({
+			...parsed,
+			fields: [field.name]
+		});
+	} else if (attribute.name === "default" && !isRelationField) defaultAttribute = attribute;
+	else if (attribute.name === "updatedAt" && !isRelationField) updatedAt = attribute;
+	else if (attribute.name === "relation" && isRelationField) relation = attribute;
+	else diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `${label}: attribute "@${attribute.name}" is not supported yet by the Prisma 7 contract source.`, sourceId, attribute.span));
+	if (field.malformedType) return;
+	if (field.typeConstructor !== void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} has type "${field.typeConstructor.path.join(".")}(...)", which has no Prisma 8 codec, so model "${model.symbol.name}" cannot use this contract source while it has the field. Prisma 7 rejects @ignore on an Unsupported field, and removing the field drops its column on Prisma 7's next migration. Adding @@ignore to model "${model.symbol.name}" keeps the model out of the contract: Prisma 7's next migration is empty, but the model disappears from the Prisma 7 client too, and every relation field in another model that points to it needs @ignore, which removes that field from the Prisma 7 client as well.`, sourceId, field.typeConstructor.span));
+		return;
+	}
+	if (args.ignoredModels.has(field.typeName)) return;
+	if (isRelationField) {
+		const attribute = relation === void 0 ? void 0 : parseRelationAttribute(relation, label, sourceId, diagnostics);
+		if (relation !== void 0 && attribute === void 0) return;
+		build.relationFields.push({
+			field,
+			targetModelName: field.typeName,
+			attribute
+		});
+		return;
+	}
+	const enumDeclaration = args.enums.get(field.typeName);
+	let call;
+	if (enumDeclaration !== void 0) {
+		if (enumDeclaration.namespaceId !== model.namespaceId) {
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_ENUM_NAMESPACE_MISMATCH", `${label} uses enum "${enumDeclaration.name}" from schema "${enumDeclaration.namespaceId}", but the model is in schema "${model.namespaceId}". Prisma 8 columns reference the enum type of their own schema; declare the enum in "${model.namespaceId}" or move the model.`, sourceId, field.span));
+			return;
+		}
+		call = {
+			path: binding.nativeEnum.typeConstructor,
+			args: [{
+				kind: "positional",
+				value: enumDeclaration.name,
+				span: field.span
+			}],
+			span: field.span
+		};
+	} else {
+		const scalar = prisma7ScalarMapping(binding.typeMap, field.typeName);
+		if (scalar === void 0) {
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} has unknown type "${field.typeName}".`, sourceId, field.span));
+			return;
+		}
+		let mapping = scalar;
+		let span = field.span;
+		if (nativeType !== void 0) {
+			const native = prisma7NativeTypeMapping(binding.typeMap, nativeType.name, nativeType.attribute.args.map((arg) => arg.value));
+			if (native === void 0) {
+				diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_NATIVE_TYPE_UNSUPPORTED", nativeTypeMessage({
+					label,
+					nativeType: nativeType.name,
+					field,
+					model,
+					defaultAttribute
+				}), sourceId, nativeType.attribute.span));
+				return;
+			}
+			mapping = native;
+			span = nativeType.attribute.span;
+		}
+		call = {
+			path: [mapping.constructorName],
+			args: mapping.args.map((value) => ({
+				kind: "positional",
+				value,
+				span
+			})),
+			span
+		};
+	}
+	const namespaceExtensionEntities = args.namespaceEntities.get(model.namespaceId);
+	const resolved = resolveFieldTypeDescriptor({
+		field: {
+			...field,
+			typeConstructor: call
+		},
+		enumTypeDescriptors: EMPTY_DESCRIPTORS,
+		namedTypeDescriptors: EMPTY_DESCRIPTORS,
+		scalarColumnDescriptors: args.scalarColumnDescriptors,
+		authoringContributions: input.authoringContributions,
+		composedExtensions: args.composedExtensions,
+		familyId: binding.target.familyId,
+		targetId: binding.target.targetId,
+		diagnostics,
+		sourceId,
+		entityLabel: label,
+		namespaceId: model.namespaceId,
+		...ifDefined("namespaceExtensionEntities", namespaceExtensionEntities),
+		codecLookup: input.codecLookup
+	});
+	if (!resolved.ok) {
+		if (!resolved.alreadyReported) diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} type "${field.typeName}" could not be resolved against target "${binding.target.targetId}".`, sourceId, field.span));
+		return;
+	}
+	const updatedAtGeneratorId = updatedAt === void 0 ? void 0 : binding.updatedAtGeneratorId(resolved.descriptor.codecId);
+	if (updatedAt !== void 0 && updatedAtGeneratorId === void 0) {
+		const withoutUpdatedAt = defaultAttribute !== void 0 && givesColumnDefault(defaultAttribute) ? `. Its ${attributeText(defaultAttribute)} still sets the value on create, and neither client changes it on update.` : field.optional ? ", but neither client then fills the value, so it stays empty unless a client writes it, and updates leave it unchanged." : ", but neither client then fills the value, so both require it on create and leave it unchanged on update.";
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_TYPE_UNSUPPORTED", `${label}: @updatedAt is not supported on this column, because Prisma 8 has no generator for column type "${resolved.descriptor.nativeType}" yet. Remove @updatedAt: Prisma 7's next migration is empty${withoutUpdatedAt}`, sourceId, updatedAt.span));
+		return;
+	}
+	if (updatedAt !== void 0 && defaultAttribute !== void 0) {
+		const written = attributeText(defaultAttribute);
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_WITH_DEFAULT_UNSUPPORTED", `${label} combines @updatedAt with ${written}, which Prisma 8 cannot express yet. Remove ${written}: @updatedAt still sets the value on create and on update, and Prisma 7's next migration removes the column default.`, sourceId, defaultAttribute.span));
+		return;
+	}
+	const lowered = defaultAttribute === void 0 ? void 0 : lowerPrisma7Default({
+		attribute: defaultAttribute,
+		field,
+		modelName: model.symbol.name,
+		codecId: resolved.descriptor.codecId,
+		codecLookup: input.codecLookup,
+		literalForm: binding.literalDefaultForm(resolved.descriptor),
+		enumMembers: enumDeclaration === void 0 ? void 0 : new Map(enumDeclaration.members.map((member) => [member.name, member.value])),
+		controlMutationDefaults: input.controlMutationDefaults,
+		sourceId,
+		diagnostics
+	});
+	if (defaultAttribute !== void 0 && lowered === void 0) return;
+	const updatedAtGenerator = updatedAtGeneratorId === void 0 ? void 0 : {
+		kind: "generator",
+		id: updatedAtGeneratorId
+	};
+	const generator = updatedAtGenerator ?? lowered?.onCreate;
+	const generatingAttribute = updatedAt ?? defaultAttribute;
+	if (generator !== void 0 && generatingAttribute !== void 0 && field.optional) {
+		const written = attributeText(generatingAttribute);
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_OPTIONAL_GENERATED_FIELD_UNSUPPORTED", `${label} is optional and its value comes from ${written}, which Prisma 8 cannot express on an optional field yet. Remove ${written} and keep the "?": the database does not change, and both clients then stop filling the value.`, sourceId, generatingAttribute.span));
+		return;
+	}
+	const executionDefaults = updatedAtGenerator !== void 0 ? {
+		onCreate: updatedAtGenerator,
+		onUpdate: updatedAtGenerator
+	} : generator !== void 0 ? { onCreate: generator } : void 0;
+	build.columns.set(field.name, {
+		fieldName: field.name,
+		columnName,
+		descriptor: resolved.descriptor,
+		nullable: field.optional || field.list,
+		...field.list ? {
+			many: true,
+			noCheck: ["elementNotNull"]
+		} : {},
+		...ifDefined("default", lowered?.storage),
+		...ifDefined("executionDefaults", executionDefaults)
+	});
+}
+function defaultOutputFromSchemaPath(schemaPath) {
+	return join(dirname(schemaPath), "contract.json");
+}
+function mapParseDiagnostics(diagnostics, sourceFile, sourceId) {
+	return diagnostics.map((diagnostic) => ({
+		code: diagnostic.code,
+		message: diagnostic.message,
+		sourceId,
+		span: rangeToPslSpan(diagnostic.range, sourceFile)
+	}));
+}
+/**
+* The files a Prisma 7 schema input names: the file itself, or every regular
+* `.prisma` file under the directory, nested directories and symbolic links
+* included, as Prisma 7 reads a schema directory. Sorted by path so duplicate
+* detection blames the later file deterministically.
+*/
+async function listSchemaFiles(absolutePath, displayPath) {
+	if (!(await stat(absolutePath)).isDirectory()) return [{
+		sourceId: displayPath,
+		absolutePath
+	}];
+	const entries = await readdir(absolutePath, { recursive: true });
+	const files = [];
+	for (const entry of entries.filter((name) => extname(name) === ".prisma").map((name) => normalize(name)).sort()) {
+		const entryPath = join(absolutePath, entry);
+		if ((await stat(entryPath)).isFile()) files.push({
+			sourceId: join(displayPath, entry),
+			absolutePath: entryPath
+		});
+	}
+	return files;
+}
+/**
+* The checks `contract emit` runs on the contract after `load` that the
+* contract builder does not: domain roots and relations, column defaults
+* against nullability, and model storage references. The structural check also
+* needs the target's entity kinds, which `load` does not receive.
+*/
+function validateInterpretedContract(contract) {
+	validateContractDomain(contract);
+	const sqlContract = blindCast(contract);
+	validateSqlStorageConsistency(sqlContract);
+	validateModelStorageReferences(sqlContract);
+}
+function prisma7Contract(schemaPath, options) {
+	return {
+		source: {
+			format: "prisma7",
+			inputs: [schemaPath],
+			async load(context) {
+				const [absolutePath] = context.resolvedInputs;
+				if (absolutePath === void 0) throw new InternalError("prisma7Contract: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.");
+				let files;
+				try {
+					files = await listSchemaFiles(absolutePath, schemaPath);
+				} catch (error) {
+					const message = String(error);
+					return notOk({
+						summary: `Failed to read Prisma 7 schema at "${schemaPath}"`,
+						diagnostics: [prisma7Diagnostic("PSL.PRISMA7_SCHEMA_READ_FAILED", message, schemaPath, void 0)],
+						meta: {
+							schemaPath,
+							absolutePath,
+							cause: message
+						}
+					});
+				}
+				if (files.length === 0) return notOk({
+					summary: `Failed to read Prisma 7 schema at "${schemaPath}"`,
+					diagnostics: [prisma7Diagnostic("PSL.PRISMA7_SCHEMA_READ_FAILED", `The schema directory "${schemaPath}" contains no .prisma file.`, schemaPath, void 0)],
+					meta: {
+						schemaPath,
+						absolutePath
+					}
+				});
+				const documents = [];
+				const seedDiagnostics = [];
+				for (const file of files) {
+					let schema;
+					try {
+						schema = await readFile(file.absolutePath, "utf-8");
+					} catch (error) {
+						const message = String(error);
+						return notOk({
+							summary: `Failed to read Prisma 7 schema at "${file.sourceId}"`,
+							diagnostics: [prisma7Diagnostic("PSL.PRISMA7_SCHEMA_READ_FAILED", message, file.sourceId, void 0)],
+							meta: {
+								schemaPath: file.sourceId,
+								absoluteSchemaPath: file.absolutePath,
+								cause: message
+							}
+						});
+					}
+					const { document, sourceFile, diagnostics } = parse(schema, { grammar: "prisma7" });
+					seedDiagnostics.push(...mapParseDiagnostics(diagnostics, sourceFile, file.sourceId));
+					documents.push({
+						document,
+						sourceFile,
+						sourceId: file.sourceId
+					});
+				}
+				let contract;
+				try {
+					const interpreted = interpretPrisma7Documents({
+						documents,
+						seedDiagnostics,
+						binding: options.binding,
+						controlMutationDefaults: context.controlMutationDefaults,
+						authoringContributions: context.authoringContributions,
+						codecLookup: context.codecLookup,
+						composedExtensions: context.composedExtensions
+					});
+					if (!interpreted.ok) return interpreted;
+					contract = applySqlSpecifierControlPolicy(interpreted.value, options.defaultControlPolicy, options.binding.createNamespace);
+					validateInterpretedContract(contract);
+				} catch (error) {
+					if (!isStructuredError(error)) throw error;
+					return notOk({
+						summary: "Prisma 7 schema interpretation failed",
+						diagnostics: [prisma7Diagnostic("PSL.PRISMA7_CONTRACT_INVALID", `This schema gives a contract that Prisma 8 rejects, and the Prisma 7 contract source has no specific diagnostic for the cause: ${error.message.replace(/\.$/, "")}. This is a bug in Prisma ORM; please report it with this schema.`, schemaPath, void 0)],
+						meta: {
+							schemaPath,
+							code: error.code
+						}
+					});
+				}
+				return ok(contract);
+			}
+		},
+		output: options.output ?? defaultOutputFromSchemaPath(schemaPath)
+	};
+}
+//#endregion
+export { prisma7Contract };
+
+//# sourceMappingURL=contract-prisma7__provider.mjs.map