@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/contract-prisma7__provider.mjs

@@ -0,0 +1,2011 @@
+import { r as lowerAuthoredIndex } from "./index-naming-BOcJT1B3-mG8Fd6KN.mjs";
+import { p as sqlDataTypeOfCodec, u as sqlCodecColumnLength } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { n as declaredBackingObjectName, r as declaredIndexesServeForeignKey } from "./foreign-key-materialization-BM59w_Xg.mjs";
+import { h as storedSqlText } from "./sql-expression-CKgKznXS.mjs";
+import { p as validateSqlStorageConsistency, u as validateModelStorageReferences } from "./validators-BwA7ttZM.mjs";
+import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-HVaxhALD.mjs";
+import { n as buildSqlContractFromDefinition, t as applySqlSpecifierControlPolicy } from "./derived-checks-D5HVRvqN-BJx1gwPA.mjs";
+import { c as instantiateFieldTypeConstructor, i as defaultFunctionCall, v as readDataTypeDefault } from "./psl-field-resolution-C5KQ7kzP-B0NwuRWV.mjs";
+import { a as normalizeReferentialAction, n as buildEntityTypesByDiscriminator, r as indexFkRelations, t as applyBackrelationCandidates } from "./interpreter-D5qk4B---CG0C7kdx.mjs";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { entryForTag, getAuthoringTypeConstructor, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructorFromValues } from "@prisma/orm-framework/components/authoring";
+import { clipToUtf8Bytes, utf8ByteLength } from "@prisma/orm-framework/utils/text";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { EMPTY_GENERATOR_FUNCTIONS } from "@prisma/orm-framework/components/components";
+import { validateContractDomain } from "@prisma/orm-framework/contract/validate-domain";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { ArrayLiteralAst, BooleanLiteralExprAst, FunctionCallAst, IdentifierAst, ModelAttributeAst, NumberLiteralExprAst, PathExprAst, StringLiteralExprAst, dottedPathsIn, 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 { assembleAuthoringContributions } from "@prisma/orm-framework/components/control";
+import { EMPTY_DATA_TYPES, buildSymbolTable, createBinder, createPslDiagnosticCollector, diagnosticSource, generatorFunctionCall, keywordPslSpan, mapPslDiagnostics, nodePslSpan, readResolvedAttribute } from "@prisma/orm-framework/psl-parser";
+import { fkRelationPairKey } from "@prisma/orm-framework/psl-parser/interpret";
+import { CUID_VERSION } from "@prisma/orm-framework/ids";
+//#region ../../../2-sql-family/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}"`));
+}
+const UNMAPPED_REASONS = ["ignored", "unsupported"];
+function unmappedClause(reason, one) {
+	if (reason === "ignored") return `${one ? "is" : "are"} marked @ignore`;
+	return `${one ? "has" : "have"} type Unsupported(...), so the Prisma 8 model has no field for ${one ? "it" : "them"}`;
+}
+/** A field with no Prisma 8 field in the model's primary key: without it the model has no field that identifies a row. */
+function unmappedFieldInPrimaryKey(input) {
+	const fields = fieldList(input.modelName, input.fieldNames);
+	const one = input.fieldNames.length === 1;
+	const modelIgnore = `@@ignore on model "${input.modelName}": Prisma 7 then requires @ignore on every relation field that points to the model, its next migration is empty, Prisma 8 keeps the model's table with its primary key, and the model disappears from both clients.`;
+	const edits = input.reason === "ignored" ? `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. Or replace ${one ? "it" : "them"} with ${modelIgnore}` : `Add ${modelIgnore}`;
+	return prisma7Diagnostic("PSL.PRISMA7_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${unmappedClause(input.reason, one)}, but ${input.usedBy} uses ${one ? "it" : "them"}, and without ${one ? "it" : "them"} model "${input.modelName}" has no field that identifies a row, so Prisma 8 could not update, delete or relate its rows. ${edits}`, input.sourceId, input.span);
+}
+/** A relation that is not `@ignore` joins on fields with no Prisma 8 field: Prisma 8 relations join on fields. */
+function unmappedFieldJoined(input) {
+	const fields = fieldList(input.modelName, input.fieldNames);
+	const one = input.fieldNames.length === 1;
+	const relation = `relation field "${input.relationField}"`;
+	const relationIgnore = `${relation} @ignore${input.reason === "ignored" ? " as well" : ""}: Prisma 7's next migration is then empty, the relation field disappears from the Prisma 7 client, and Prisma 8 keeps its foreign key while leaving the relation out of the contract's models.`;
+	const edits = input.reason === "ignored" ? `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. Or mark ${relationIgnore}` : `Mark ${relationIgnore}`;
+	return prisma7Diagnostic("PSL.PRISMA7_IGNORED_FIELD_REFERENCED", `${one ? "Field" : "Fields"} ${fields} ${unmappedClause(input.reason, one)}, but ${relation} joins on ${one ? "it" : "them"}, and Prisma 8 relations join on fields. ${edits}`, input.sourceId, input.span);
+}
+/** The diagnostics for the fields among `fieldNames` that have no Prisma 8 field, one per reason. */
+function unmappedFieldDiagnostics(fieldNames, unmapped, diagnostic) {
+	return UNMAPPED_REASONS.flatMap((reason) => {
+		const names = fieldNames.filter((name) => unmapped.get(name) === reason);
+		return names.length === 0 ? [] : [diagnostic(names, reason)];
+	});
+}
+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 path = PathExprAst.cast(element.syntax) ?? FunctionCallAst.cast(element.syntax)?.memberPath();
+					if (path !== void 0) return unsupported(`lists the dotted path "${path.path().join(".")}"; an index lists fields of its model by name, and Prisma 7 refuses the path as an unknown field.`, arg.span);
+					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
+	};
+}
+/**
+* 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) {
+	return `${clipToUtf8Bytes(base, maxBytes - utf8ByteLength(suffix))}${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
+	};
+}
+/** Prisma 7's primary key name: `map`, or `{table}_pkey` cut to `maxBytes`. */
+function prisma7PrimaryKeyName(tableName, map, maxBytes) {
+	return map ?? prisma7ConstraintName(tableName, "_pkey", maxBytes);
+}
+/** Prisma 7's foreign key name: `map`, or `{table}_{columns}_fkey` cut to `maxBytes`. */
+function prisma7ForeignKeyName(tableName, columns, map, maxBytes) {
+	return map ?? prisma7ConstraintName(`${tableName}_${columns.join("_")}`, "_fkey", maxBytes);
+}
+/** Prisma 7's primary key name for the junction table of an implicit many-to-many relation. */
+function prisma7JunctionPrimaryKeyName(relationName, maxBytes) {
+	return prisma7ConstraintName(`_${relationName}`, "_AB_pkey", maxBytes);
+}
+/** Prisma 7's name for the junction foreign key on column `A` or `B`. */
+function prisma7JunctionForeignKeyName(relationName, column, maxBytes) {
+	return prisma7ConstraintName(`_${relationName}`, `_${column}_fkey`, maxBytes);
+}
+/**
+* The name a contract states for a constraint Prisma 7 named `prisma7Name`: the name itself where the target would derive a different one, and `undefined` where the two agree, so the contract stays unnamed there and a table rename keeps deriving it.
+*/
+function statedConstraintName(prisma7Name, derivedName) {
+	return prisma7Name === derivedName ? void 0 : prisma7Name;
+}
+/**
+* Refuses a `map` on `@id`, `@@id`, `@unique`, `@@unique`, `@@index` or `@relation` longer than the database keeps, as Prisma 7 does. The database would store the name cut short, so a contract holding it whole would rename or drop a constraint the database does not have.
+*/
+function checkStatedConstraintNameLength(input) {
+	const { attribute, maxBytes } = input;
+	const mapArgument = attribute.args.find((arg) => arg.kind === "named" && arg.name === "map");
+	const expression = mapArgument?.expression;
+	const name = expression === void 0 ? void 0 : StringLiteralExprAst.cast(expression.syntax)?.value();
+	if (mapArgument === void 0 || name === void 0) return;
+	const bytes = utf8ByteLength(name);
+	if (bytes <= maxBytes) return;
+	const spelling = `${attribute.node instanceof ModelAttributeAst ? "@@" : "@"}${attribute.name}`;
+	input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_CONSTRAINT_NAME_TOO_LONG", `${input.owner}: the name "${name}" in the map argument of ${spelling} is ${bytes} bytes, longer than the ${maxBytes} bytes the database keeps. Shorten the map to ${maxBytes} bytes or fewer; Prisma 7 refuses this name too.`, input.sourceId, mapArgument.span));
+}
+/** The default functions of Prisma 7's schema language. */
+const PRISMA7_DEFAULT_FUNCTIONS = /* @__PURE__ */ new Set([
+	"autoincrement",
+	"now",
+	"uuid",
+	"cuid",
+	"nanoid",
+	"ulid"
+]);
+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 (input.onlyDbgenerated && call?.path().join(".") !== "dbgenerated") return unknown("on a field of type Unsupported(...) must be dbgenerated(\"...\"). Prisma 7 refuses this schema too: \"Only @default(dbgenerated(\"...\")) can be used for Unsupported types.\" Write the default as @default(dbgenerated(\"<sql expression>\")), or remove it.", attribute.span);
+	if (call !== void 0) return lowerFunction(call, expression, input, label, unknown);
+	const scalar = scalarValue$1(expression, input, unknown);
+	if (scalar === void 0) return void 0;
+	return {
+		storage: {
+			kind: "literal",
+			value: scalar,
+			inStoredForm: true
+		},
+		onCreate: void 0
+	};
+}
+/**
+* The stored value of a written default: an enum member resolves through the enum's members, and
+* every other value is read by the authoring entry for its syntax, cast into the column's data type
+* and validated by the column's codec — the same path the current schema language takes.
+*/
+function scalarValue$1(expression, input, unknown) {
+	const span = input.attribute.span;
+	const enumValue = enumMemberValue$1(expression, input);
+	if (enumValue !== void 0) return enumValue;
+	const array = ArrayLiteralAst.cast(expression.syntax);
+	const elements = array === void 0 ? void 0 : [...array.elements()];
+	if (elements?.some((element) => enumMemberValue$1(element, input) !== void 0) === true) {
+		const values = [];
+		for (const element of elements) {
+			const value = enumMemberValue$1(element, input);
+			if (value === void 0) return unknown("lists may only hold literals or enum members.", span);
+			values.push(value);
+		}
+		return values;
+	}
+	const finer = finerThanColumn(elements ?? [expression], elements !== void 0, input);
+	if (finer !== void 0) return unknown(finer, span);
+	const written = writtenLiteralFor(expression, elements, input);
+	if (written === void 0) return unreadableValue(expression, input, unknown);
+	const jsonNull = jsonNullDefault(written, expression, input);
+	if (jsonNull !== void 0) return jsonNull;
+	const read = readDataTypeDefault({
+		written,
+		isList: input.field.list,
+		column: {
+			codecId: input.codecId,
+			typeParams: input.typeParams
+		},
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes,
+		fieldPath: `${input.modelName}.${input.field.name}`
+	});
+	return read.ok ? read.value : unknown(refusalReason(read.refusal), span);
+}
+/**
+* Why a written date and time is refused when it has more fraction digits than the column holds:
+* Prisma 7 let the database round it, so the reason names the value the database stores.
+*/
+function finerThanColumn(values, isList, input) {
+	const form = input.literalForm;
+	if (form?.kind !== "tag" || form.finerThanColumn === void 0) return void 0;
+	for (const [index, value] of values.entries()) {
+		const text = StringLiteralExprAst.cast(value.syntax)?.value();
+		const finer = text === void 0 ? void 0 : form.finerThanColumn(text);
+		if (text === void 0 || finer === void 0) continue;
+		const at = isList ? ` at element ${index + 1}` : "";
+		const writtenDigits = /\.(\d+)/.exec(text)?.[1]?.length ?? 0;
+		const held = finer.heldDigits === 0 ? "none" : String(finer.heldDigits);
+		return `holds "${text}"${at}, with ${writtenDigits} ${writtenDigits === 1 ? "digit" : "digits"} after the decimal point, but the column holds ${held}. PostgreSQL stores it as "${finer.stored}"; write that instead.`;
+	}
+}
+/** The storage value of an enum member name, when the field is typed by a Prisma 7 enum. */
+function enumMemberValue$1(expression, input) {
+	const member = IdentifierAst.cast(expression.syntax)?.name();
+	return member === void 0 ? void 0 : input.enumMembers?.get(member);
+}
+function writtenLiteralFor(expression, elements, input) {
+	if (elements === void 0) return writtenLiteral(expression, input);
+	const written = [];
+	for (const element of elements) {
+		const elementLiteral = writtenLiteral(element, input);
+		if (elementLiteral === void 0) return void 0;
+		written.push(elementLiteral);
+	}
+	return {
+		kind: "list",
+		elements: written
+	};
+}
+/**
+* The JSON value null, which the contract cannot tell apart from SQL NULL, reported before the
+* column's codec sees the literal.
+*/
+function jsonNullDefault(written, expression, input) {
+	if (input.literalForm?.kind !== "json") return void 0;
+	const value = jsonDocumentOf(written, input);
+	if (value === void 0) return void 0;
+	if (!(Array.isArray(value) ? value.includes(null) : value === null)) return void 0;
+	input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_JSON_NULL_DEFAULT_UNSUPPORTED", `Field "${input.modelName}.${input.field.name}": @default(${printSyntax(expression.syntax).trim()}) ${written.kind === "list" ? "holds" : "is"} 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, input.attribute.span));
+}
+/** A `@default(...)` this contract source cannot read as a literal at all. */
+function unreadableValue(expression, input, unknown) {
+	const span = input.attribute.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);
+	if (ArrayLiteralAst.cast(expression.syntax) !== void 0) return unknown("lists may only hold literals or enum members.", span);
+	return unknown("holds a value this contract source does not read.", span);
+}
+/** The written literal a Prisma 7 expression is, or `undefined` when it is not a literal at all. */
+function writtenLiteral(expression, input) {
+	const text = StringLiteralExprAst.cast(expression.syntax)?.value();
+	if (text !== void 0) {
+		const form = input.literalForm;
+		if (form?.kind === "json") return {
+			kind: "tag",
+			tag: "json",
+			text
+		};
+		if (form?.kind === "tag") {
+			const body = form.body(text);
+			return body === void 0 ? void 0 : {
+				kind: "tag",
+				tag: form.tag,
+				text: body
+			};
+		}
+		return {
+			kind: "string",
+			text
+		};
+	}
+	const number = NumberLiteralExprAst.cast(expression.syntax)?.token()?.text;
+	if (number !== void 0) return {
+		kind: "number",
+		text: number
+	};
+	const boolean = BooleanLiteralExprAst.cast(expression.syntax)?.value();
+	return boolean === void 0 ? void 0 : {
+		kind: "boolean",
+		value: boolean
+	};
+}
+/**
+* The document a written JSON value holds, read through the same entry the interpreter uses, or
+* `undefined` when the body is not a document.
+*/
+function jsonDocumentOf(written, input) {
+	const entry = entryForTag(input.dataTypes, "json");
+	if (entry === void 0 || entry.entry.written.kind !== "tag") return void 0;
+	const bodies = written.kind === "list" ? written.elements.flatMap((element) => element.kind === "tag" ? [element.text] : []) : written.kind === "tag" ? [written.text] : [];
+	const parse = entry.entry.written.parse;
+	try {
+		const documents = bodies.map((body) => parse(body));
+		return written.kind === "list" ? documents : documents[0];
+	} catch {
+		return;
+	}
+}
+/** Why the column refused the value, as a phrase following `@default `. */
+function refusalReason(refusal) {
+	const at = refusal.elementIndex === void 0 ? "" : ` at element ${refusal.elementIndex + 1}`;
+	switch (refusal.kind) {
+		case "unreadable": return `holds text${at} that this contract source does not read: ${refusal.message}`;
+		case "unknown-tag": return `holds a ${refusal.tag} literal${at}, which this stack does not register.`;
+		case "unwritable": return `holds a ${refusal.syntax} value${at}, which this target has no data type for.`;
+		case "not-a-list": return "holds a single value on a list column, which takes a list literal.";
+		case "no-cast": return `holds a ${refusal.valueType} value${at}, which ${refusal.receivingType} has no cast from; ${describeCasts(refusal.casts)}.`;
+		case "no-list-cast": return `holds a list, which ${refusal.receivingType} has no cast from; ${describeCasts(refusal.casts)}.`;
+		case "no-element-cast": return `holds a ${refusal.valueType} value${at}, which the list cast of ${refusal.receivingType} does not take; it takes ${refusal.elementTypes.join(", ")}.`;
+		case "refused-by-column": return `holds a value${at} that ${refusal.codecId} does not read: ${refusal.message}`;
+	}
+}
+function describeCasts(casts) {
+	return casts.length === 0 ? "it casts from nothing" : `it casts from ${casts.join(", ")}`;
+}
+function lowerFunction(call, expression, input, label, unknown) {
+	const fn = call.path().join(".");
+	const span = input.attribute.span;
+	const callArgs = [...call.args()];
+	if (fn === "dbgenerated") return dbgeneratedDefault(callArgs, unknown, span);
+	const entry = input.controlMutationDefaults.defaultFunctionRegistry.get(fn);
+	const generator = entry === void 0 ? input.generatorFunctions.functionsFor(input.codecId).find(({ name }) => name === fn) : void 0;
+	if (!PRISMA7_DEFAULT_FUNCTIONS.has(fn) || entry === void 0 && !input.generatorFunctions.has(fn)) return unknown(`function "${fn}()" is not a Prisma 7 default function this target supports.`, span);
+	if (entry === void 0) {
+		if (generator === void 0) return unknown(`function "${fn}()" cannot fill a column of codec "${input.codecId}".`, span);
+		const args = fn === "cuid" && callArgs.length === 0 ? { version: CUID_VERSION } : boundArguments(generatorFunctionCall(fn, generator.signature, input.dataTypes), expression, input, label);
+		if (args === void 0) return void 0;
+		const resolution = input.generatorFunctions.resolve({
+			name: fn,
+			args
+		}, {
+			codecId: input.codecId,
+			typeParams: input.typeParams,
+			length: sqlCodecColumnLength(input.dataTypes, input.codecId, input.typeParams)
+		});
+		if (resolution.ok) return {
+			storage: void 0,
+			onCreate: resolution.generator
+		};
+		if (resolution.reason === "refused") {
+			const written = input.attribute.args.find((arg) => arg.kind === "positional")?.value.trim() ?? `${fn}()`;
+			input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_GENERATOR_REFUSED", `${label}: @default(${written}) cannot fill its column: ${resolution.message}`, input.sourceId, span));
+			return;
+		}
+		return unknown(`function "${fn}()" cannot fill a column of codec "${input.codecId}".`, span);
+	}
+	const args = boundArguments(defaultFunctionCall(fn, entry, input.dataTypes), expression, input, label);
+	if (args === void 0) return void 0;
+	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 {
+		storage: lowered.value.defaultValue,
+		onCreate: void 0
+	};
+}
+/**
+* The arguments of a call, bound and checked through its function's signature as Prisma 8 PSL binds them, or `undefined` after reporting each refusal at its argument.
+*/
+function boundArguments(arm, expression, input, label) {
+	const ctx = input.argumentContext();
+	const bound = arm.parse(expression, ctx);
+	if (bound.ok) return bound.value.args;
+	for (const diagnostic of mapPslDiagnostics(bound.failure, ctx.sources)) input.diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_DEFAULT", `${label}: ${diagnostic.message}`, input.sourceId, diagnostic.span));
+}
+/**
+* Prisma 7's `dbgenerated("<sql>")` is a raw SQL default, carried as written; the empty form
+* `dbgenerated()` means the column has no default. Prisma 7 refuses a blank string, so this
+* source does too.
+*/
+function dbgeneratedDefault(callArgs, unknown, span) {
+	if (callArgs.length === 0) return {
+		storage: void 0,
+		onCreate: void 0
+	};
+	const [argument] = callArgs;
+	const value = argument?.value();
+	const expression = callArgs.length === 1 && argument?.name() === void 0 && value !== void 0 ? StringLiteralExprAst.cast(value.syntax)?.value() : void 0;
+	if (expression === void 0 || expression.trim() === "") return unknown("function \"dbgenerated()\" has an argument this contract source does not read.", span);
+	return {
+		storage: {
+			kind: "function",
+			expression
+		},
+		onCreate: void 0
+	};
+}
+function prisma7ScalarMapping(typeMap, scalar) {
+	return Object.hasOwn(typeMap.scalars, scalar) ? typeMap.scalars[scalar] : void 0;
+}
+function prisma7NativeTypeMapping(typeMap, nativeType) {
+	return Object.hasOwn(typeMap.nativeTypes, nativeType) ? typeMap.nativeTypes[nativeType] : void 0;
+}
+/** 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 map;
+	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":
+				map = stringValue(arg.expression);
+				if (map === void 0) return invalid("map must be a string", arg.span);
+				break;
+			default: return invalid(`argument "${key ?? ""}" is not supported`, arg.span);
+		}
+	}
+	return {
+		name,
+		map,
+		fields,
+		references,
+		onDelete,
+		onUpdate,
+		span: attribute.span
+	};
+}
+function storageColumn(model, fieldName) {
+	return model.columns.get(fieldName) ?? model.unmappedColumns.get(fieldName);
+}
+/** A foreign key reaches a table with a model through the model, and an `@@ignore` model's table by its name. */
+function referenceTo(model, columns) {
+	const table = {
+		table: model.tableName,
+		columns,
+		namespaceId: model.namespaceId
+	};
+	return model.ignored ? table : {
+		model: model.modelName,
+		...table
+	};
+}
+function columnNames(model, fieldNames) {
+	const columns = [];
+	for (const fieldName of fieldNames) {
+		const column = storageColumn(model, 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 = storageColumn(model, 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 ignoredJunctions = /* @__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, ...model.ignoredRelationFields]) {
+		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 ignoredRelation = model.ignoredRelationFields.includes(relationField);
+			const joinedIgnored = ignoredRelation ? [] : [{
+				owner: model,
+				names: attribute.fields
+			}, {
+				owner: target,
+				names: attribute.references ?? []
+			}].flatMap(({ owner, names }) => unmappedFieldDiagnostics(names, owner.unmappedFields, (fieldNames, reason) => unmappedFieldJoined({
+				modelName: owner.modelName,
+				fieldNames,
+				reason,
+				relationField: `${model.modelName}.${field.name}`,
+				sourceId: model.sourceId,
+				span: attribute.span
+			})));
+			if (joinedIgnored.length > 0) {
+				rejectFkSide(model, relationField, ...joinedIgnored);
+				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.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) => storageColumn(model, 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;
+			}
+			const foreignKeyName = statedConstraintName(prisma7ForeignKeyName(model.tableName, localColumns, attribute.map, naming.identifierMaxBytes), naming.defaultConstraintNames.foreignKey(model.tableName, localColumns));
+			addForeignKey(model.modelName, {
+				...ifDefined("name", foreignKeyName),
+				columns: localColumns,
+				references: referenceTo(target, referencedColumns),
+				onDelete,
+				onUpdate,
+				index: false
+			});
+			if (ignoredRelation) continue;
+			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;
+		}
+		const ignoredPair = model.ignoredRelationFields.includes(relationField) || target.ignoredRelationFields.some((other) => other.targetModelName === model.modelName && sameName(other, relationField));
+		const targetRelationFields = [...target.relationFields, ...target.ignoredRelationFields];
+		if (targetRelationFields.filter((other) => other.targetModelName === model.modelName && isFkSide(other) && sameName(other, relationField)).length > 0 || !field.list) {
+			if (ignoredPair) continue;
+			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 = targetRelationFields.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,
+			ignored: ignoredPair
+		});
+	}
+	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, ignored } of requests) {
+			const junction = synthesizeJunction(requester, partner, naming, diagnostics);
+			if (junction === void 0) continue;
+			if (ignored) {
+				ignoredJunctions.set(junction.key, junction.table);
+				continue;
+			}
+			if (!junctions.has(junction.key)) {
+				junctions.set(junction.key, junctionModel(junction.name, junction.table));
+				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 candidatesBySourceId = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const model = models.get(candidate.modelName);
+		if (model === void 0) continue;
+		const group = candidatesBySourceId.get(model.sourceId) ?? {
+			sources: model.sources,
+			candidates: []
+		};
+		candidatesBySourceId.set(model.sourceId, group);
+		group.candidates.push(candidate);
+	}
+	for (const { sources, candidates: backrelationCandidates } of candidatesBySourceId.values()) {
+		const pairingDiagnostics = createPslDiagnosticCollector(sources);
+		applyBackrelationCandidates({
+			backrelationCandidates,
+			fkRelationsByPair,
+			invalidFkPairings,
+			fkRelationsByDeclaringModel,
+			modelIdColumns,
+			modelUniqueColumnSets,
+			modelRelations,
+			diagnostics: pairingDiagnostics,
+			sources
+		});
+		for (const diagnostic of pairingDiagnostics.toExternal()) 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,
+		ignoredJunctions,
+		foreignKeys,
+		relations
+	};
+}
+/** The junction model over a junction table: a field for each of its columns. */
+function junctionModel(name, table) {
+	const { columns, ...properties } = table;
+	return {
+		...properties,
+		modelName: name,
+		fields: columns.map((column) => ({
+			fieldName: column.columnName,
+			...column
+		}))
+	};
+}
+/**
+* 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.unmappedFields.has(name) || side.model.rejectedFields.has(name))) return;
+	const [idField, ...rest] = side.model.idFields;
+	const column = idField === void 0 ? void 0 : storageColumn(side.model, 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 foreignKeyName = (column) => statedConstraintName(prisma7JunctionForeignKeyName(name, column, naming.identifierMaxBytes), naming.defaultConstraintNames.foreignKey(tableName, [column]));
+	const primaryKeyName = statedConstraintName(prisma7JunctionPrimaryKeyName(name, naming.identifierMaxBytes), naming.defaultConstraintNames.primaryKey(tableName));
+	const foreignKey = (column, side, id) => ({
+		...ifDefined("name", foreignKeyName(column)),
+		columns: [column],
+		references: referenceTo(side.model, [id.columnName]),
+		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,
+		name,
+		table: {
+			tableName,
+			namespaceId,
+			columns: [{
+				columnName: "A",
+				descriptor: idA.descriptor,
+				nullable: false,
+				many: false
+			}, {
+				columnName: "B",
+				descriptor: idB.descriptor,
+				nullable: false,
+				many: false
+			}],
+			id: {
+				columns: ["A", "B"],
+				...ifDefined("name", primaryKeyName)
+			},
+			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`
+	};
+}
+/** The generator `now()` resolves to for a column, which `@updatedAt` writes on create and on update; `undefined` when no generator function binds `now` to its codec. */
+function nowGeneratorFor(generatorFunctions, dataTypes, column) {
+	const resolution = generatorFunctions.resolve({
+		name: "now",
+		args: {}
+	}, {
+		codecId: column.codecId,
+		typeParams: column.typeParams,
+		length: sqlCodecColumnLength(dataTypes, column.codecId, column.typeParams)
+	});
+	return resolution.ok ? resolution.generator : void 0;
+}
+const SUMMARY = "Prisma 7 schema interpretation failed";
+/**
+* The binder context of a Prisma 7 document's argument context. A default function's arguments are literals, so the binder needs no Prisma 8 attribute specs, functions or data types.
+*/
+const ARGUMENT_BINDER_CONTEXT = {
+	authoringContributions: assembleAuthoringContributions([]),
+	controlMutationDefaults: { defaultFunctionRegistry: /* @__PURE__ */ new Map() },
+	generatorFunctions: EMPTY_GENERATOR_FUNCTIONS,
+	dataTypes: EMPTY_DATA_TYPES
+};
+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 blockEntry(source, key) {
+	for (const entry of source.block.entries) if (entry.key()?.name() === key) return entry;
+}
+function scalarValue(source, key) {
+	const value = blockEntry(source, key)?.value();
+	if (value === void 0) return void 0;
+	return StringLiteralExprAst.cast(value.syntax)?.value();
+}
+function parameterSpan(source, key) {
+	const entry = blockEntry(source, key);
+	return entry === void 0 ? source.block.span : nodePslSpan(entry.syntax, source.sources);
+}
+/** Prisma 7 accepts no dotted path in a datasource or generator block, though the parser reads one as a value. */
+function reportDottedBlockValues(block, sourceId, sources, diagnostics) {
+	for (const entry of block.entries) {
+		const value = entry.value();
+		if (value === void 0) continue;
+		for (const path of dottedPathsIn(value)) diagnostics.push({
+			code: "PSL_INVALID_EXTENSION_BLOCK_MEMBER",
+			message: `${block.keyword} "${block.name}": the value of "${entry.key()?.name() ?? ""}" holds the dotted path ${path.path().join(".")}, which Prisma 7 does not accept in a ${block.keyword} block.`,
+			sourceId,
+			span: nodePslSpan(path.syntax, sources)
+		});
+	}
+}
+function reportDuplicateBlockEntries(source, diagnostics) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of source.block.entries) {
+		const key = entry.key()?.name();
+		if (key === void 0) continue;
+		if (seen.has(key)) {
+			diagnostics.push({
+				code: "PSL_EXTENSION_DUPLICATE_PARAMETER",
+				message: `Duplicate parameter "${key}" in "${source.block.keyword}" block "${source.block.name}"; first occurrence wins`,
+				sourceId: source.sourceId,
+				span: nodePslSpan(entry.syntax, source.sources)
+			});
+			continue;
+		}
+		seen.add(key);
+	}
+}
+function interpretPrisma7Documents(input) {
+	const { binding } = input;
+	const diagnostics = [...input.seedDiagnostics];
+	const { defaultNamespaceId } = input;
+	const datasources = [];
+	const enumBlocks = [];
+	const models = [];
+	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, sources, sourceFile, sourceId } of input.documents) {
+		const { symbolTable, diagnostics: tableDiagnostics } = buildSymbolTable({
+			documents: [document],
+			sources,
+			defaultNamespaceId
+		});
+		for (const diagnostic of tableDiagnostics) diagnostics.push({
+			code: diagnostic.code,
+			message: diagnostic.message,
+			sourceId,
+			span: sourceFile.rangeToPslSpan(diagnostic.range)
+		});
+		const unsupported = (keyword, span) => {
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_TOP_LEVEL_BLOCK",
+				message: `Unsupported top-level block "${keyword}"`,
+				sourceId,
+				span
+			});
+		};
+		const unsupportedInclusions = (code, holders) => {
+			for (const holder of Object.values(holders)) for (const inclusion of holder.node.inclusions()) diagnostics.push({
+				code,
+				message: `Unsupported mixin inclusion "${printSyntax(inclusion.syntax).trim()}"`,
+				sourceId,
+				span: nodePslSpan(inclusion.syntax, sources)
+			});
+		};
+		for (const block of Object.values(symbolTable.defaultNamespace.blocks)) switch (block.keyword) {
+			case "datasource":
+				datasources.push({
+					block,
+					sourceId,
+					sources,
+					sourceFile
+				});
+				reportDottedBlockValues(block, sourceId, sources, diagnostics);
+				break;
+			case "generator":
+				reportDottedBlockValues(block, sourceId, sources, diagnostics);
+				break;
+			case "enum":
+				if (claimName("enum", block.name, sourceId, block.span)) enumBlocks.push({
+					block,
+					sourceId,
+					sources,
+					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, sources)));
+				break;
+			default: unsupported(block.keyword, keywordPslSpan(block.node.syntax, block.keyword, sources));
+		}
+		for (const namespace of Object.values(symbolTable.namespaces)) for (const { span } of namespace.declarations) unsupported("namespace", span);
+		for (const compositeType of Object.values(symbolTable.defaultNamespace.compositeTypes)) unsupported("type", compositeType.span);
+		for (const namedType of Object.values(symbolTable.namedTypes)) unsupported("types", namedType.span);
+		for (const mixin of Object.values(symbolTable.defaultNamespace.mixins)) unsupported(`${mixin.keyword} mixin`, mixin.span);
+		unsupportedInclusions("PSL_INVALID_MODEL_MEMBER", symbolTable.defaultNamespace.models);
+		unsupportedInclusions("PSL_INVALID_EXTENSION_BLOCK_MEMBER", symbolTable.defaultNamespace.blocks);
+		let argumentContext;
+		const argumentContextOf = () => {
+			argumentContext ??= {
+				sources,
+				symbols: symbolTable,
+				binder: createBinder({
+					sources,
+					symbolTable,
+					context: ARGUMENT_BINDER_CONTEXT
+				}).binder
+			};
+			return argumentContext;
+		};
+		for (const symbol of Object.values(symbolTable.defaultNamespace.models)) {
+			if (!claimName("model", symbol.name, sourceId, symbol.span)) continue;
+			models.push(readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, binding, diagnostics, argumentContextOf));
+		}
+	}
+	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 = new Set(models.map((model) => model.symbol.name));
+	const ignoredModels = new Set(models.filter((model) => model.ignored).map((model) => model.symbol.name));
+	const composedExtensions = new Set(input.composedExtensions);
+	const builds = /* @__PURE__ */ new Map();
+	for (const declaration of models) {
+		const build = {
+			declaration,
+			columns: /* @__PURE__ */ new Map(),
+			unmappedColumns: /* @__PURE__ */ new Map(),
+			unmappedFields: /* @__PURE__ */ new Map(),
+			ignoredRelationFields: [],
+			rejectedFields: /* @__PURE__ */ new Set(),
+			idFields: declaration.id?.fields ?? [],
+			idMap: declaration.id?.map,
+			uniqueIndexes: [...declaration.uniqueIndexes],
+			relationFields: []
+		};
+		for (const field of Object.values(declaration.symbol.fields)) {
+			const reported = diagnostics.length;
+			readField({
+				field,
+				build,
+				modelNames,
+				ignoredModels,
+				enums,
+				namespaceEntities,
+				composedExtensions,
+				input,
+				diagnostics
+			});
+			if (diagnostics.length > reported && !build.columns.has(field.name) && !build.unmappedColumns.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,
+		ignored: build.declaration.ignored,
+		tableSpan: build.declaration.symbol.attributes.find((attribute) => attribute.name === "map")?.span ?? build.declaration.symbol.span,
+		namespaceId: build.declaration.namespaceId,
+		sourceId: build.declaration.sourceId,
+		sources: build.declaration.sources,
+		columns: build.columns,
+		unmappedColumns: build.unmappedColumns,
+		unmappedFields: build.unmappedFields,
+		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 = [];
+	const tables = [];
+	for (const [modelName, build] of builds) {
+		const model = relationModels.get(modelName);
+		if (model === void 0) continue;
+		const idAttribute = build.declaration.id;
+		if (idAttribute?.fields !== void 0) diagnostics.push(...unmappedFieldDiagnostics(idAttribute.fields, build.unmappedFields, (fieldNames, reason) => unmappedFieldInPrimaryKey({
+			modelName,
+			fieldNames,
+			reason,
+			usedBy: `@@id on model "${modelName}"`,
+			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 }) => {
+			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);
+		const primaryKeyName = statedConstraintName(prisma7PrimaryKeyName(model.tableName, build.idMap, binding.identifierMaxBytes), binding.defaultConstraintNames.primaryKey(model.tableName));
+		const tableProperties = stateServedBackingIndexes({
+			tableName: model.tableName,
+			...id !== void 0 && id.length > 0 ? { id: {
+				columns: id,
+				...ifDefined("name", primaryKeyName)
+			} } : {},
+			...indexes.length > 0 ? { indexes } : {},
+			...foreignKeys !== void 0 ? { foreignKeys } : {}
+		});
+		const unmappedColumns = [...build.unmappedColumns.values()];
+		if (model.ignored) {
+			tables.push({
+				...tableProperties,
+				namespaceId: model.namespaceId,
+				columns: unmappedColumns
+			});
+			continue;
+		}
+		modelNodes.push({
+			...tableProperties,
+			modelName,
+			namespaceId: model.namespaceId,
+			fields: [...build.columns.values()],
+			...relations !== void 0 ? { relations } : {}
+		});
+		if (unmappedColumns.length > 0) tables.push({
+			namespaceId: model.namespaceId,
+			tableName: model.tableName,
+			columns: unmappedColumns
+		});
+	}
+	tables.push(...[...lowered.ignoredJunctions.values()].map(stateServedBackingIndexes));
+	for (const [key, junction] of lowered.junctions) {
+		const relations = lowered.relations.get(key);
+		modelNodes.push(stateServedBackingIndexes(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,
+		...tables.length > 0 ? { tables } : {}
+	}, input.codecLookup, input.dataTypes.lookup));
+}
+/**
+* Prisma 7 never derives a backing index for a foreign key, so its relations say `index: false`. Where the model's own indexes or keys already serve a foreign key, the relation takes the default instead, so the build drops the derived index again, or names the named key or plain index whose first columns are the foreign key's. Either way the stored foreign key states what backs it, and no index is added.
+*/
+function stateServedBackingIndexes(node) {
+	if (node.foreignKeys === void 0) return node;
+	const table = {
+		indexes: (node.indexes ?? []).map((index) => lowerAuthoredIndex(node.tableName, blindCast(index), [])),
+		uniques: node.uniques ?? [],
+		primaryKey: node.id
+	};
+	return {
+		...node,
+		foreignKeys: node.foreignKeys.map((foreignKey) => {
+			if (foreignKey.index !== false) return foreignKey;
+			if (declaredIndexesServeForeignKey(foreignKey.columns, table)) return {
+				...foreignKey,
+				index: true
+			};
+			const name = declaredBackingObjectName(foreignKey.columns, table);
+			return name === void 0 ? foreignKey : {
+				...foreignKey,
+				index: name
+			};
+		})
+	};
+}
+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;
+	}
+	reportDuplicateBlockEntries(datasource, diagnostics);
+	const provider = scalarValue(datasource, "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(datasource, "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(datasource, 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(datasource, 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) ?? model.unmappedColumns.get(fieldName);
+		if (column === void 0) return void 0;
+		columns.push(column.columnName);
+	}
+	return columns;
+}
+function readModelDeclaration(symbol, sourceId, sources, defaultNamespaceId, binding, diagnostics, argumentContext) {
+	const { indexTypes } = binding;
+	let ignored = false;
+	let tableName = symbol.name;
+	let namespaceId = defaultNamespaceId;
+	let id;
+	const uniqueIndexes = [];
+	const indexes = [];
+	for (const attribute of symbol.attributes) {
+		if ([
+			"id",
+			"unique",
+			"index"
+		].includes(attribute.name)) checkStatedConstraintNameLength({
+			attribute,
+			owner: `Model "${symbol.name}"`,
+			maxBytes: binding.identifierMaxBytes,
+			sourceId,
+			diagnostics
+		});
+		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;
+			}
+			case "ignore":
+				ignored = true;
+				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,
+		sources,
+		namespaceId,
+		tableName,
+		ignored,
+		id,
+		uniqueIndexes,
+		indexes,
+		argumentContext
+	};
+}
+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, sources } = source;
+	let typeName = block.name;
+	let namespaceId = defaultNamespaceId;
+	for (const attribute of block.attributes) 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 = [];
+	const seenMemberNames = /* @__PURE__ */ new Set();
+	for (const entry of block.entries) {
+		const name = entry.key()?.name();
+		if (name === void 0) continue;
+		if (seenMemberNames.has(name)) {
+			diagnostics.push({
+				code: "PSL_EXTENSION_DUPLICATE_PARAMETER",
+				message: `Duplicate parameter "${name}" in "${block.keyword}" block "${block.name}"; first occurrence wins`,
+				sourceId,
+				span: nodePslSpan(entry.syntax, sources)
+			});
+			continue;
+		}
+		seenMemberNames.add(name);
+		let value = name;
+		const span = nodePslSpan(entry.syntax, sources);
+		for (const attributeNode of entry.attributes()) {
+			const attribute = readResolvedAttribute(attributeNode, sources);
+			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,
+			dataTypes: input.dataTypes,
+			sourceId: declaration.sourceId,
+			diagnostics: { push: (diagnostic) => {
+				diagnostics.push(blindCast(diagnostic));
+			} }
+		};
+		const values = Object.create(null);
+		const writtenValues = Object.create(null);
+		const parameterSpans = Object.create(null);
+		for (const member of declaration.members) {
+			values[member.name] = member.value;
+			writtenValues[member.name] = {
+				kind: "string",
+				text: member.value
+			};
+			parameterSpans[member.name] = member.span;
+		}
+		const entity = instantiateAuthoringEntityType(entityKind, descriptor, [{
+			kind: entityKind,
+			keyword: entityKind,
+			name: declaration.name,
+			values,
+			writtenValues,
+			parameterSpans,
+			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;
+}
+/** The SQL family's type constructor for a column of a type no data type claims (ADR 273). */
+const RAW_TYPE_CONSTRUCTOR = ["Raw"];
+/** Prisma 7's `Unsupported("...")`, which this source reads as ``Raw(sql`...`)``. */
+function isUnsupportedType(call) {
+	return call?.path.length === 1 && call.path[0] === "Unsupported";
+}
+/** The one double-quoted string `Unsupported(...)` takes, as written and with its escapes undone. */
+function unsupportedTypeArgument(call) {
+	const [written, ...rest] = call.args;
+	if (written === void 0 || rest.length > 0 || written.kind !== "positional") return void 0;
+	const literal = written.expression === void 0 ? void 0 : StringLiteralExprAst.cast(written.expression.syntax);
+	const text = literal?.quote() === "\"" ? literal.value() : void 0;
+	return text === void 0 ? void 0 : {
+		written,
+		text
+	};
+}
+function nativeTypeMessage(label, nativeType) {
+	return `${label}: native type "@db.${nativeType}" has no Prisma 8 codec yet, and Prisma 8 cannot read this schema until it supports the column type. @ignore on the field or @@ignore on the model does not help: Prisma 8 keeps the columns of ignored fields and models in the contract. Changing the field's type to one Prisma 8 supports changes the column type on Prisma 7's next migration.`;
+}
+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;
+	const fieldIgnored = field.attributes.some((attribute) => attribute.name === "ignore") || isRelationField && args.ignoredModels.has(field.typeName);
+	const unsupported = isUnsupportedType(field.typeConstructor);
+	const unmappedReason = unsupported && !model.ignored ? "unsupported" : fieldIgnored ? "ignored" : void 0;
+	if (unmappedReason !== void 0) build.unmappedFields.set(field.name, unmappedReason);
+	const ignored = fieldIgnored || model.ignored || unsupported;
+	let columnName = field.name;
+	let nativeType;
+	let relation;
+	let defaultAttribute;
+	let updatedAt;
+	for (const attribute of field.attributes) {
+		if (isRelationField ? attribute.name === "relation" : ["id", "unique"].includes(attribute.name)) checkStatedConstraintNameLength({
+			attribute,
+			owner: label,
+			maxBytes: binding.identifierMaxBytes,
+			sourceId,
+			diagnostics
+		});
+		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) {
+			const parsed = parseIndexAttribute(attribute, label, sourceId, binding.indexTypes, diagnostics);
+			if (parsed !== void 0) {
+				build.idFields = [field.name];
+				build.idMap = parsed.map;
+			}
+			if (unmappedReason !== void 0) diagnostics.push(unmappedFieldInPrimaryKey({
+				modelName: model.symbol.name,
+				fieldNames: [field.name],
+				reason: unmappedReason,
+				usedBy: "its @id",
+				sourceId,
+				span: attribute.span
+			}));
+		} 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 if (attribute.name === "ignore") {} 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 && !unsupported) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} has type "${field.typeConstructor.path.join(".")}(...)", which is not a Prisma 7 type. Prisma 7 refuses this schema too.`, sourceId, field.typeConstructor.span));
+		return;
+	}
+	if (unsupported && nativeType !== void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNKNOWN_ATTRIBUTE", `${label} has type Unsupported(...), which takes no native type, but has attribute "@db.${nativeType.name}". Prisma 7 refuses this schema too: "Attribute not known". Remove "@db.${nativeType.name}".`, sourceId, nativeType.attribute.span));
+		return;
+	}
+	const unsupportedArgument = field.typeConstructor === void 0 ? void 0 : unsupportedTypeArgument(field.typeConstructor);
+	if (field.typeConstructor !== void 0 && unsupportedArgument === void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label}: Unsupported(...) takes one string, the column's type as the database prints it, such as Unsupported("tsvector").`, sourceId, field.typeConstructor.span));
+		return;
+	}
+	if (isRelationField) {
+		const attribute = relation === void 0 ? void 0 : parseRelationAttribute(relation, label, sourceId, diagnostics);
+		if (relation !== void 0 && attribute === void 0) return;
+		(ignored ? build.ignoredRelationFields : build.relationFields).push({
+			field,
+			targetModelName: field.typeName,
+			attribute
+		});
+		return;
+	}
+	if (updatedAt !== void 0 && field.typeName !== "DateTime") {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_FIELD_INVALID", `${label} has type "${field.typeName}", but @updatedAt is only allowed on a DateTime field. Prisma 7 refuses this schema too: "Fields that are marked with @updatedAt must be of type DateTime." Remove @updatedAt, or change the field's type to DateTime.`, sourceId, updatedAt.span));
+		return;
+	}
+	if (updatedAt !== void 0 && field.list) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_FIELD_INVALID", `${label} is a list, but @updatedAt is not allowed on a list field. Prisma 7 refuses this schema too: "Fields that are marked with @updatedAt cannot be lists." Remove @updatedAt, or make the field a single DateTime.`, sourceId, updatedAt.span));
+		return;
+	}
+	const enumDeclaration = unsupported ? void 0 : args.enums.get(field.typeName);
+	let fieldType;
+	if (unsupportedArgument !== void 0) {
+		const sqlText = storedSqlText(unsupportedArgument.text);
+		if (sqlText === void 0) {
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label}: Unsupported(${unsupportedArgument.written.value}) is not one type name: a sql literal cannot hold it, because it has a NUL character or is too large.`, sourceId, unsupportedArgument.written.span));
+			return;
+		}
+		fieldType = {
+			kind: "values",
+			path: RAW_TYPE_CONSTRUCTOR,
+			values: [sqlText]
+		};
+	} else 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;
+		}
+		fieldType = {
+			kind: "written",
+			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;
+		}
+		const native = nativeType === void 0 ? void 0 : prisma7NativeTypeMapping(binding.typeMap, nativeType.name);
+		if (nativeType !== void 0 && native === void 0) {
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_NATIVE_TYPE_UNSUPPORTED", nativeTypeMessage(label, nativeType.name), sourceId, nativeType.attribute.span));
+			return;
+		}
+		const mapping = native ?? scalar;
+		fieldType = nativeType === void 0 || nativeType.attribute.args.length === 0 ? {
+			kind: "values",
+			path: [mapping.constructorName],
+			values: mapping.args
+		} : {
+			kind: "written",
+			call: {
+				path: [mapping.constructorName],
+				args: nativeType.attribute.args,
+				span: nativeType.attribute.span
+			}
+		};
+	}
+	const constructorPath = fieldType.kind === "written" ? fieldType.call.path : fieldType.path;
+	const typeConstructor = getAuthoringTypeConstructor(input.authoringContributions, constructorPath);
+	if (typeConstructor === void 0) {
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label} type "${field.typeName}" could not be resolved against target "${binding.target.targetId}".`, sourceId, field.span));
+		return;
+	}
+	let resolved;
+	if (fieldType.kind === "written") {
+		const typeDiagnostics = createPslDiagnosticCollector(model.sources);
+		resolved = instantiateFieldTypeConstructor({
+			call: fieldType.call,
+			descriptor: typeConstructor,
+			diagnostics: typeDiagnostics,
+			source: diagnosticSource(model.sources, field.node.syntax),
+			entityLabel: label,
+			namespaceId: model.namespaceId,
+			namespaceExtensionEntities: args.namespaceEntities,
+			codecLookup: input.codecLookup,
+			dataTypes: input.dataTypes
+		});
+		diagnostics.push(...typeDiagnostics.toExternal());
+	} else {
+		const instantiated = instantiateAuthoringTypeConstructorFromValues(typeConstructor, fieldType.values, input.codecLookup.descriptorFor(typeConstructor.output.codecId)?.paramsSchema);
+		if (!instantiated.ok && unsupportedArgument !== void 0) {
+			diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UNSUPPORTED_TYPE", `${label}: Unsupported(${unsupportedArgument.written.value}) is not one type name: ${instantiated.failure.message}`, sourceId, unsupportedArgument.written.span));
+			return;
+		}
+		if (!instantiated.ok) throw new InternalError(`The Prisma 7 target binding maps ${label} to constructor "${fieldType.path.join(".")}" with arguments its codec refuses: ${instantiated.failure.message}`);
+		resolved = {
+			ok: true,
+			descriptor: instantiated.value
+		};
+	}
+	if (!resolved.ok) return;
+	const typeLookups = {
+		codecLookup: input.codecLookup,
+		dataTypeLookup: input.dataTypes.lookup
+	};
+	const updatedAtGenerator = updatedAt === void 0 || ignored ? void 0 : nowGeneratorFor(input.generatorFunctions, input.dataTypes, resolved.descriptor);
+	if (updatedAt !== void 0 && !ignored && updatedAtGenerator === void 0) {
+		if (nativeType === void 0) throw new InternalError(`The Prisma 7 target binding has no "now" generator for codec "${resolved.descriptor.codecId}", which the DateTime scalar maps to.`);
+		diagnostics.push(prisma7Diagnostic("PSL.PRISMA7_UPDATED_AT_FIELD_INVALID", `${label} has @updatedAt, but "@db.${nativeType.name}" makes it a column that is not a date or time, so @updatedAt cannot set it. Prisma 7 refuses this schema too: "Native type ${nativeType.name} is not compatible with declared field type DateTime". Remove @updatedAt, or use a date or time native type such as @db.Timestamp.`, sourceId, nativeType.attribute.span));
+		return;
+	}
+	const lowered = defaultAttribute === void 0 ? void 0 : lowerPrisma7Default({
+		attribute: defaultAttribute,
+		field,
+		modelName: model.symbol.name,
+		onlyDbgenerated: unsupported,
+		codecId: resolved.descriptor.codecId,
+		typeParams: resolved.descriptor.typeParams,
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes,
+		literalForm: binding.literalDefaultForm({
+			codecId: resolved.descriptor.codecId,
+			dataType: sqlDataTypeOfCodec(resolved.descriptor.codecId, typeLookups).id,
+			typeParams: resolved.descriptor.typeParams
+		}),
+		enumMembers: enumDeclaration === void 0 ? void 0 : new Map(enumDeclaration.members.map((member) => [member.name, member.value])),
+		controlMutationDefaults: input.controlMutationDefaults,
+		argumentContext: model.argumentContext,
+		generatorFunctions: input.generatorFunctions,
+		sourceId,
+		diagnostics
+	});
+	if (defaultAttribute !== void 0 && lowered === void 0) return;
+	const column = {
+		columnName,
+		descriptor: resolved.descriptor,
+		nullable: field.optional || field.list,
+		many: field.list,
+		...field.list ? { elementNullable: true } : {},
+		...ifDefined("default", lowered?.storage)
+	};
+	if (ignored) {
+		build.unmappedColumns.set(field.name, column);
+		return;
+	}
+	const executionDefaults = updatedAtGenerator !== void 0 ? {
+		onCreate: updatedAtGenerator,
+		onUpdate: updatedAtGenerator
+	} : lowered?.onCreate !== void 0 ? { onCreate: lowered.onCreate } : void 0;
+	build.columns.set(field.name, {
+		fieldName: field.name,
+		...column,
+		...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: sourceFile.rangeToPslSpan(diagnostic.range)
+	}));
+}
+/**
+* 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 isMissingPath(error) {
+	return error instanceof Error && Reflect.get(error, "code") === "ENOENT";
+}
+function prisma7Contract(schemaPath, options) {
+	const parserOptions = { grammar: "prisma-7" };
+	return {
+		source: {
+			format: "psl",
+			inputs: [schemaPath],
+			parserOptions,
+			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 from source.inputs.");
+				let files;
+				try {
+					files = await listSchemaFiles(absolutePath, schemaPath);
+				} catch (error) {
+					const cause = String(error);
+					const message = isMissingPath(error) ? `There is no file or directory at "${schemaPath}". Fix the path passed to prisma7Schema() in prisma.config.ts.` : cause;
+					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
+						}
+					});
+				}
+				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, sources, diagnostics } = parse(schema, file.sourceId, parserOptions);
+					const sourceFile = sources.sourceFileFor(document.syntax);
+					seedDiagnostics.push(...mapParseDiagnostics(diagnostics, sourceFile, file.sourceId));
+					documents.push({
+						document,
+						sources,
+						sourceFile,
+						sourceId: file.sourceId
+					});
+				}
+				let contract;
+				try {
+					const interpreted = interpretPrisma7Documents({
+						documents,
+						seedDiagnostics,
+						binding: options.binding,
+						controlMutationDefaults: context.controlMutationDefaults,
+						generatorFunctions: context.generatorFunctions,
+						authoringContributions: context.authoringContributions,
+						codecLookup: context.codecLookup,
+						dataTypes: context.dataTypes,
+						composedExtensions: context.composedExtensions,
+						defaultNamespaceId: context.defaultNamespaceId
+					});
+					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