@prisma-next/family-sql 0.14.0-dev.9 → 0.14.0-dev.90

package/dist/control.mjs

@@ -1,17 +1,20 @@
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CjFfO6LM.mjs";
-import { t as SqlContractSerializer } from "./sql-contract-serializer-BR2vC7Z-.mjs";
-import { a as contractToSchemaIR, c as extractCodecControlHooks, o as detectDestructiveChanges, s as resolveValueSetValues, t as verifySqlSchema } from "./verify-sql-schema-xT4udQLQ.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CXd-8ydc.mjs";
+import { n as classifyDiffSubjectGranularity, o as verifySqlSchemaByDiff, s as extractCodecControlHooks, t as classifyDiffEntityKind } from "./schema-verify-W3r631Jh.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-C75cfMSS.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-C-G0obRm.mjs";
+import { t as backingIndexColumnKeys } from "./foreign-key-index-backing-BP71iI-Q.mjs";
 import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-CloimujU.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
+import { blindCast } from "@prisma-next/utils/casts";
 import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
+import { isPlainRecord } from "@prisma-next/framework-components/ir";
 import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
 import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { StorageTable } from "@prisma-next/sql-contract/types";
-import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma-next/framework-components/psl-ast";
 import { effectiveControlPolicy } from "@prisma-next/contract/types";
+import { StorageTable, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { SqlSchemaIR, SqlTableIR } from "@prisma-next/sql-schema-ir/types";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -46,921 +49,6 @@ function sqlOperationsToPreview(operations) {
 	})) };
 }
 //#endregion
-//#region src/core/psl-contract-infer/default-mapping.ts
-const DEFAULT_FUNCTION_ATTRIBUTES = {
-	"autoincrement()": "@default(autoincrement())",
-	"now()": "@default(now())"
-};
-function mapDefault(columnDefault, options) {
-	switch (columnDefault.kind) {
-		case "literal": return { attribute: `@default(${formatLiteralValue(columnDefault.value)})` };
-		case "function": {
-			const attribute = options?.functionAttributes?.[columnDefault.expression] ?? DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ?? options?.fallbackFunctionAttribute?.(columnDefault.expression);
-			return attribute ? { attribute } : { comment: `// Raw default: ${columnDefault.expression.replace(/[\r\n]+/g, " ")}` };
-		}
-	}
-}
-function formatLiteralValue(value) {
-	if (value === null) return "null";
-	switch (typeof value) {
-		case "boolean":
-		case "number": return String(value);
-		case "string": return quoteString(value);
-		default: return quoteString(JSON.stringify(value));
-	}
-}
-function quoteString(str) {
-	return `"${escapeString(str)}"`;
-}
-function escapeString(str) {
-	return JSON.stringify(str).slice(1, -1);
-}
-//#endregion
-//#region src/core/psl-contract-infer/name-transforms.ts
-const PSL_RESERVED_WORDS = new Set([
-	"model",
-	"enum",
-	"types",
-	"type",
-	"generator",
-	"datasource"
-]);
-const IDENTIFIER_PART_PATTERN = /[A-Za-z0-9]+/g;
-function hasSeparators(input) {
-	return /[^A-Za-z0-9]/.test(input);
-}
-function extractIdentifierParts(input) {
-	return input.match(IDENTIFIER_PART_PATTERN) ?? [];
-}
-function createSyntheticIdentifier(input) {
-	let hash = 2166136261;
-	for (const char of input) {
-		hash ^= char.codePointAt(0) ?? 0;
-		hash = Math.imul(hash, 16777619);
-	}
-	return `x${(hash >>> 0).toString(16)}`;
-}
-function sanitizeIdentifierCharacters(input) {
-	const sanitized = input.replace(/[^\w]/g, "");
-	return sanitized.length > 0 ? sanitized : createSyntheticIdentifier(input);
-}
-function capitalize(word) {
-	return word.charAt(0).toUpperCase() + word.slice(1);
-}
-function snakeToPascalCase(input) {
-	const parts = extractIdentifierParts(input);
-	if (parts.length === 0) return capitalize(sanitizeIdentifierCharacters(input));
-	return parts.map(capitalize).join("");
-}
-function snakeToCamelCase(input) {
-	const parts = extractIdentifierParts(input);
-	if (parts.length === 0) return sanitizeIdentifierCharacters(input);
-	const [firstPart = input, ...rest] = parts;
-	return firstPart.charAt(0).toLowerCase() + firstPart.slice(1) + rest.map(capitalize).join("");
-}
-function needsEscaping(name) {
-	return PSL_RESERVED_WORDS.has(name.toLowerCase()) || /^\d/.test(name);
-}
-function escapeName(name) {
-	return `_${name}`;
-}
-function escapeIfNeeded(name) {
-	return needsEscaping(name) ? escapeName(name) : name;
-}
-function toModelName(tableName) {
-	let name;
-	if (hasSeparators(tableName)) name = snakeToPascalCase(tableName);
-	else name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
-	if (needsEscaping(name)) return {
-		name: escapeName(name),
-		map: tableName
-	};
-	if (name !== tableName) return {
-		name,
-		map: tableName
-	};
-	return { name };
-}
-function toFieldName(columnName) {
-	let name;
-	if (hasSeparators(columnName)) name = snakeToCamelCase(columnName);
-	else name = columnName.charAt(0).toLowerCase() + columnName.slice(1);
-	if (needsEscaping(name)) return {
-		name: escapeName(name),
-		map: columnName
-	};
-	if (name !== columnName) return {
-		name,
-		map: columnName
-	};
-	return { name };
-}
-function pluralize(word) {
-	if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) return `${word}es`;
-	if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) return `${word.slice(0, -1)}ies`;
-	return `${word}s`;
-}
-function deriveRelationFieldName(fkColumns, referencedTableName) {
-	if (fkColumns.length === 1) {
-		const [col = referencedTableName] = fkColumns;
-		const stripped = col.replace(/_id$/i, "").replace(/Id$/, "");
-		if (stripped.length > 0 && stripped !== col) return escapeIfNeeded(snakeToCamelCase(stripped));
-		return escapeIfNeeded(snakeToCamelCase(referencedTableName));
-	}
-	return escapeIfNeeded(snakeToCamelCase(referencedTableName));
-}
-function deriveBackRelationFieldName(childModelName, isOneToOne) {
-	const base = childModelName.charAt(0).toLowerCase() + childModelName.slice(1);
-	return isOneToOne ? base : pluralize(base);
-}
-function toNamedTypeName(columnName) {
-	let name;
-	if (hasSeparators(columnName)) name = snakeToPascalCase(columnName);
-	else name = columnName.charAt(0).toUpperCase() + columnName.slice(1);
-	return escapeIfNeeded(name);
-}
-//#endregion
-//#region src/core/psl-contract-infer/postgres-default-mapping.ts
-const POSTGRES_FUNCTION_ATTRIBUTES = { "gen_random_uuid()": "@default(dbgenerated(\"gen_random_uuid()\"))" };
-function formatDbGeneratedAttribute(expression) {
-	return `@default(dbgenerated(${JSON.stringify(expression)}))`;
-}
-function createPostgresDefaultMapping() {
-	return {
-		functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,
-		fallbackFunctionAttribute: formatDbGeneratedAttribute
-	};
-}
-//#endregion
-//#region src/core/psl-contract-infer/postgres-type-map.ts
-const POSTGRES_TO_PSL = {
-	text: "String",
-	bool: "Boolean",
-	boolean: "Boolean",
-	int4: "Int",
-	integer: "Int",
-	int8: "BigInt",
-	bigint: "BigInt",
-	float8: "Float",
-	"double precision": "Float",
-	numeric: "Decimal",
-	decimal: "Decimal",
-	timestamptz: "DateTime",
-	"timestamp with time zone": "DateTime",
-	jsonb: "Json",
-	bytea: "Bytes"
-};
-const PRESERVED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	uuid: {
-		pslType: "String",
-		attributeName: "db.Uuid"
-	},
-	int2: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	smallint: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	float4: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	real: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	"timestamp without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	date: {
-		pslType: "DateTime",
-		attributeName: "db.Date"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	"time without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	"time with time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	json: {
-		pslType: "Json",
-		attributeName: "db.Json"
-	}
-};
-const PARAMETERIZED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	numeric: {
-		pslType: "Decimal",
-		attributeName: "db.Numeric"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	timestamptz: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamptz"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	}
-};
-const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
-function getOwnMappingValue(map, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function getOwnRecordValue(map, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function createNativeTypeAttribute(name, args) {
-	return args && args.length > 0 ? {
-		name,
-		args
-	} : { name };
-}
-function splitTypeParameterList(params) {
-	return params.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
-}
-function createPostgresTypeMap(enumTypeNames) {
-	return { resolve(nativeType) {
-		if (enumTypeNames?.has(nativeType)) return {
-			pslType: nativeType,
-			nativeType
-		};
-		const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
-		if (paramMatch) {
-			const [, baseType = nativeType, params = ""] = paramMatch;
-			const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
-			if (template) return {
-				pslType: template.pslType,
-				nativeType,
-				typeParams: {
-					baseType,
-					params
-				},
-				nativeTypeAttribute: createNativeTypeAttribute(template.attributeName, splitTypeParameterList(params))
-			};
-		}
-		const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
-		if (preservedType) return {
-			pslType: preservedType.pslType,
-			nativeType,
-			nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName)
-		};
-		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
-		if (pslType) return {
-			pslType,
-			nativeType
-		};
-		return {
-			unsupported: true,
-			nativeType
-		};
-	} };
-}
-function extractEnumInfo(annotations) {
-	const nativeEnumTypeNames = (annotations?.["pg"])?.["nativeEnumTypeNames"];
-	const typeNames = /* @__PURE__ */ new Set();
-	const definitions = /* @__PURE__ */ new Map();
-	if (Array.isArray(nativeEnumTypeNames)) {
-		for (const name of nativeEnumTypeNames) if (typeof name === "string") typeNames.add(name);
-	}
-	return {
-		typeNames,
-		definitions
-	};
-}
-//#endregion
-//#region src/core/psl-contract-infer/raw-default-parser.ts
-const NEXTVAL_PATTERN = /^nextval\s*\(/i;
-const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const JSON_CAST_SUFFIX = /::jsonb?$/i;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-function canonicalizeTimestampDefault(expr) {
-	if (NOW_FUNCTION_PATTERN.test(expr)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return "clock_timestamp()";
-	if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return void 0;
-	let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, "").trim();
-	if (inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1).trim();
-	if (NOW_FUNCTION_PATTERN.test(inner)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return "clock_timestamp()";
-	inner = inner.replace(TEXT_CAST_SUFFIX, "").trim();
-	if (NOW_LITERAL_PATTERN.test(inner)) return "now()";
-}
-function parseRawDefault(rawDefault, nativeType) {
-	const trimmed = rawDefault.trim();
-	const normalizedType = nativeType?.toLowerCase();
-	if (NEXTVAL_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "autoincrement()"
-	};
-	const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-	if (canonicalTimestamp) return {
-		kind: "function",
-		expression: canonicalTimestamp
-	};
-	if (UUID_PATTERN.test(trimmed) || UUID_OSSP_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "gen_random_uuid()"
-	};
-	if (NULL_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: null
-	};
-	if (TRUE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: true
-	};
-	if (FALSE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: false
-	};
-	if (NUMERIC_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: Number(trimmed)
-	};
-	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-	if (stringMatch?.[1] !== void 0) {
-		const unescaped = stringMatch[1].replace(/''/g, "'");
-		if (normalizedType === "json" || normalizedType === "jsonb") {
-			if (JSON_CAST_SUFFIX.test(trimmed)) return {
-				kind: "function",
-				expression: trimmed
-			};
-			try {
-				return {
-					kind: "literal",
-					value: JSON.parse(unescaped)
-				};
-			} catch {}
-		}
-		return {
-			kind: "literal",
-			value: unescaped
-		};
-	}
-	return {
-		kind: "function",
-		expression: trimmed
-	};
-}
-//#endregion
-//#region src/core/psl-contract-infer/relation-inference.ts
-const DEFAULT_ON_DELETE = "noAction";
-const DEFAULT_ON_UPDATE = "noAction";
-const REFERENTIAL_ACTION_PSL = {
-	noAction: "NoAction",
-	restrict: "Restrict",
-	cascade: "Cascade",
-	setNull: "SetNull",
-	setDefault: "SetDefault"
-};
-function inferRelations(tables, modelNameMap) {
-	const relationsByTable = /* @__PURE__ */ new Map();
-	const fkCountByPair = /* @__PURE__ */ new Map();
-	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
-		const pairKey = `${table.name}→${fk.referencedTable}`;
-		fkCountByPair.set(pairKey, (fkCountByPair.get(pairKey) ?? 0) + 1);
-	}
-	const usedFieldNames = /* @__PURE__ */ new Map();
-	for (const table of Object.values(tables)) {
-		const names = /* @__PURE__ */ new Set();
-		for (const col of Object.values(table.columns)) names.add(col.name);
-		usedFieldNames.set(table.name, names);
-	}
-	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
-		const childTableName = table.name;
-		const parentTableName = fk.referencedTable;
-		const childUsed = usedFieldNames.get(childTableName);
-		const childModelName = modelNameMap.get(childTableName) ?? childTableName;
-		const parentModelName = modelNameMap.get(parentTableName) ?? parentTableName;
-		const pairKey = `${childTableName}→${parentTableName}`;
-		const isSelfRelation = childTableName === parentTableName;
-		const needsRelationName = fkCountByPair.get(pairKey) > 1 || isSelfRelation;
-		const isOneToOne = detectOneToOne(fk, table);
-		const childRelFieldName = resolveUniqueFieldName(deriveRelationFieldName(fk.columns, parentTableName), childUsed, parentModelName);
-		const relationName = needsRelationName ? deriveRelationName(fk, childRelFieldName, parentModelName, isSelfRelation) : void 0;
-		addRelationField(relationsByTable, childTableName, buildChildRelationField(childRelFieldName, parentModelName, fk, fk.columns.some((columnName) => table.columns[columnName]?.nullable ?? false), relationName));
-		childUsed.add(childRelFieldName);
-		const parentUsed = usedFieldNames.get(parentTableName) ?? /* @__PURE__ */ new Set();
-		usedFieldNames.set(parentTableName, parentUsed);
-		const backRelFieldName = resolveUniqueFieldName(deriveBackRelationFieldName(childModelName, isOneToOne), parentUsed, childModelName);
-		addRelationField(relationsByTable, parentTableName, {
-			fieldName: backRelFieldName,
-			typeName: childModelName,
-			optional: isOneToOne,
-			list: !isOneToOne,
-			relationName
-		});
-		parentUsed.add(backRelFieldName);
-	}
-	return { relationsByTable };
-}
-function detectOneToOne(fk, table) {
-	const fkCols = [...fk.columns].sort();
-	if (table.primaryKey) {
-		const pkCols = [...table.primaryKey.columns].sort();
-		if (pkCols.length === fkCols.length && pkCols.every((c, i) => c === fkCols[i])) return true;
-	}
-	for (const unique of table.uniques) {
-		const uniqueCols = [...unique.columns].sort();
-		if (uniqueCols.length === fkCols.length && uniqueCols.every((c, i) => c === fkCols[i])) return true;
-	}
-	return false;
-}
-function deriveRelationName(fk, childRelationFieldName, parentModelName, isSelfRelation) {
-	if (fk.name) return fk.name;
-	if (isSelfRelation) return `${childRelationFieldName.charAt(0).toUpperCase() + childRelationFieldName.slice(1)}${pluralize(parentModelName)}`;
-	return fk.columns.join("_");
-}
-function buildChildRelationField(fieldName, parentModelName, fk, optional, relationName) {
-	const onDelete = fk.onDelete && fk.onDelete !== DEFAULT_ON_DELETE ? fk.onDelete : void 0;
-	const onUpdate = fk.onUpdate && fk.onUpdate !== DEFAULT_ON_UPDATE ? fk.onUpdate : void 0;
-	return {
-		fieldName,
-		typeName: parentModelName,
-		referencedTableName: fk.referencedTable,
-		optional,
-		list: false,
-		relationName,
-		fkName: fk.name,
-		fields: fk.columns,
-		references: fk.referencedColumns,
-		onDelete: onDelete ? REFERENTIAL_ACTION_PSL[onDelete] : void 0,
-		onUpdate: onUpdate ? REFERENTIAL_ACTION_PSL[onUpdate] : void 0
-	};
-}
-function resolveUniqueFieldName(desired, usedNames, fallbackSuffix) {
-	if (!usedNames.has(desired)) return desired;
-	const withSuffix = `${desired}${fallbackSuffix}`;
-	if (!usedNames.has(withSuffix)) return withSuffix;
-	let counter = 2;
-	while (usedNames.has(`${desired}${counter}`)) counter++;
-	return `${desired}${counter}`;
-}
-function addRelationField(map, tableName, field) {
-	const existing = map.get(tableName);
-	if (existing) existing.push(field);
-	else map.set(tableName, [field]);
-}
-//#endregion
-//#region src/core/psl-contract-infer/sql-schema-ir-to-psl-ast.ts
-const SYNTHETIC_SPAN = {
-	start: {
-		offset: 0,
-		line: 1,
-		column: 1
-	},
-	end: {
-		offset: 0,
-		line: 1,
-		column: 1
-	}
-};
-const PSL_SCALAR_TYPE_NAMES = new Set([
-	"String",
-	"Boolean",
-	"Int",
-	"BigInt",
-	"Float",
-	"Decimal",
-	"DateTime",
-	"Json",
-	"Bytes"
-]);
-/**
-* Converts a SQL schema IR into a PSL AST suitable for `printPsl`.
-*
-* This function owns all SQL-specific concerns: native type mapping (Postgres),
-* relation inference from foreign keys, enum extraction, and raw default parsing.
-* The output is a fully-formed `PslDocumentAst` with synthetic spans.
-*/
-function sqlSchemaIrToPslAst(schemaIR) {
-	const enumInfo = extractEnumInfo(schemaIR.annotations);
-	if (enumInfo.typeNames.size > 0) {
-		const names = [...enumInfo.typeNames].join(", ");
-		throw new Error(`contract infer: the database contains native Postgres enum type(s): ${names}. Native Postgres enums (CREATE TYPE … AS ENUM) are not adoptable by contract infer. Drop the native type and replace each column with a text column carrying a CHECK constraint, then re-run contract infer. The domain enum (enum Name { @@type("pg/text@1") … }) authoring surface generates the required check automatically.`);
-	}
-	return buildPslDocumentAst(schemaIR, {
-		typeMap: createPostgresTypeMap(/* @__PURE__ */ new Set()),
-		defaultMapping: createPostgresDefaultMapping(),
-		parseRawDefault
-	});
-}
-function buildPslDocumentAst(schemaIR, options) {
-	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
-	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
-	const modelNameMap = new Map([...modelNames].map(([tableName, result]) => [tableName, result.name]));
-	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
-	const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
-	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, /* @__PURE__ */ new Map(), reservedNamedTypeNames);
-	const models = [];
-	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, /* @__PURE__ */ new Map(), fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationsByTable.get(table.name) ?? []));
-	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
-	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
-	const types = namedTypeEntries.length > 0 ? {
-		kind: "types",
-		declarations: namedTypeEntries.map(buildNamedTypeDeclaration),
-		span: SYNTHETIC_SPAN
-	} : void 0;
-	return {
-		kind: "document",
-		sourceId: "<sql-schema-ir>",
-		namespaces: [makePslNamespace({
-			kind: "namespace",
-			name: UNSPECIFIED_PSL_NAMESPACE_ID,
-			entries: makePslNamespaceEntries(sortedModels, [], []),
-			span: SYNTHETIC_SPAN
-		})],
-		...types ? { types } : {},
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields) {
-	const { name: modelName, map: mapName } = toModelName(table.name);
-	const fieldNameMap = fieldNamesByTable.get(table.name);
-	const pkColumns = new Set(table.primaryKey?.columns ?? []);
-	const isSinglePk = pkColumns.size === 1;
-	const singlePkConstraintName = isSinglePk ? table.primaryKey?.name : void 0;
-	const uniqueColumns = /* @__PURE__ */ new Map();
-	for (const unique of table.uniques) if (unique.columns.length === 1) {
-		const [columnName = ""] = unique.columns;
-		const existingConstraintName = uniqueColumns.get(columnName);
-		if (!uniqueColumns.has(columnName) || existingConstraintName === void 0 && unique.name) uniqueColumns.set(columnName, unique.name);
-	}
-	const fields = [];
-	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
-	const usedFieldNames = new Set(fields.map((field) => field.name));
-	for (const rel of relationFields) fields.push(buildRelationField(rel, table.name, fieldNamesByTable, usedFieldNames));
-	const modelAttributes = [];
-	if (table.primaryKey && table.primaryKey.columns.length > 1) {
-		const pkFieldNames = table.primaryKey.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
-		modelAttributes.push(buildModelConstraintAttribute("id", pkFieldNames, table.primaryKey.name));
-	}
-	for (const unique of table.uniques) if (unique.columns.length > 1) {
-		const uniqueFieldNames = unique.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
-		modelAttributes.push(buildModelConstraintAttribute("unique", uniqueFieldNames, unique.name));
-	}
-	for (const index of table.indexes) if (!index.unique) {
-		const indexFieldNames = index.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
-		modelAttributes.push(buildModelConstraintAttribute("index", indexFieldNames, index.name));
-	}
-	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
-	const comment = table.primaryKey ? void 0 : "// WARNING: This table has no primary key in the database";
-	return {
-		kind: "model",
-		name: modelName,
-		fields,
-		attributes: modelAttributes,
-		span: SYNTHETIC_SPAN,
-		...comment !== void 0 ? { comment } : {}
-	};
-}
-function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
-	const resolvedField = fieldNameMap?.get(column.name);
-	const fieldName = resolvedField?.fieldName ?? toFieldName(column.name).name;
-	const fieldMap = resolvedField?.fieldMap;
-	const resolution = typeMap.resolve(column.nativeType, table.annotations);
-	if ("unsupported" in resolution) {
-		const attrs = [];
-		if (fieldMap !== void 0) attrs.push(buildMapAttribute("field", fieldMap));
-		return {
-			kind: "field",
-			name: fieldName,
-			typeName: `Unsupported("${escapePslString(resolution.nativeType)}")`,
-			optional: column.nullable,
-			list: false,
-			attributes: attrs,
-			span: SYNTHETIC_SPAN
-		};
-	}
-	let typeName = resolution.pslType;
-	const enumPslName = enumNameMap.get(column.nativeType);
-	if (enumPslName) typeName = enumPslName;
-	if (resolution.nativeTypeAttribute && !enumPslName) typeName = resolveNamedTypeName(namedTypes, resolution);
-	const attributes = [];
-	const isId = isSinglePk && pkColumns.has(column.name);
-	if (isId) attributes.push(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
-	if (column.default !== void 0) {
-		const parsed = parseColumnDefault(column.default, column.nativeType, rawDefaultParser);
-		if (parsed) {
-			const result = mapDefault(parsed, defaultMapping);
-			if ("attribute" in result) attributes.push(parseDefaultAttributeString(result.attribute));
-		}
-	}
-	if (uniqueColumns.has(column.name) && !isId) {
-		const uniqueConstraintName = uniqueColumns.get(column.name);
-		attributes.push(buildSimpleConstraintFieldAttribute("unique", uniqueConstraintName));
-	}
-	if (fieldMap !== void 0) attributes.push(buildMapAttribute("field", fieldMap));
-	return {
-		kind: "field",
-		name: fieldName,
-		typeName,
-		optional: column.nullable,
-		list: false,
-		attributes,
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildRelationField(rel, hostTableName, fieldNamesByTable, usedFieldNames) {
-	const fieldName = createUniqueFieldName(rel.fieldName, usedFieldNames);
-	usedFieldNames.add(fieldName);
-	const args = [];
-	if (rel.fields && rel.references) {
-		if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
-		args.push(namedArg("fields", `[${rel.fields.map((columnName) => resolveColumnFieldName(fieldNamesByTable, hostTableName, columnName)).join(", ")}]`));
-		args.push(namedArg("references", `[${rel.references.map((columnName) => resolveColumnFieldName(fieldNamesByTable, rel.referencedTableName ?? "", columnName)).join(", ")}]`));
-		if (rel.onDelete) args.push(namedArg("onDelete", rel.onDelete));
-		if (rel.onUpdate) args.push(namedArg("onUpdate", rel.onUpdate));
-		if (rel.fkName) args.push(namedArg("map", `"${escapePslString(rel.fkName)}"`));
-	} else if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
-	const attrs = args.length > 0 ? [buildAttribute("field", "relation", args)] : [];
-	return {
-		kind: "field",
-		name: fieldName,
-		typeName: rel.typeName,
-		optional: rel.optional,
-		list: rel.list,
-		attributes: attrs,
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildModelConstraintAttribute(name, fields, constraintName) {
-	const args = [positionalArg(`[${fields.join(", ")}]`)];
-	if (constraintName !== void 0) args.push(namedArg("map", `"${escapePslString(constraintName)}"`));
-	return buildAttribute("model", name, args);
-}
-function buildSimpleConstraintFieldAttribute(name, constraintName) {
-	if (constraintName === void 0) return buildAttribute("field", name, []);
-	return buildAttribute("field", name, [namedArg("map", `"${escapePslString(constraintName)}"`)]);
-}
-function parseDefaultAttributeString(attributeText) {
-	return buildAttribute("field", "default", [positionalArg(attributeText.replace(/^@default\(/, "").replace(/\)$/, ""))]);
-}
-function buildMapAttribute(target, mapName) {
-	return buildAttribute(target, "map", [positionalArg(`"${escapePslString(mapName)}"`)]);
-}
-function buildAttribute(target, name, args) {
-	return {
-		kind: "attribute",
-		target,
-		name,
-		args,
-		span: SYNTHETIC_SPAN
-	};
-}
-function positionalArg(value) {
-	return {
-		kind: "positional",
-		value,
-		span: SYNTHETIC_SPAN
-	};
-}
-function namedArg(name, value) {
-	return {
-		kind: "named",
-		name,
-		value,
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildNamedTypeDeclaration(entry) {
-	const attribute = buildAttribute("namedType", entry.nativeTypeAttribute.name, (entry.nativeTypeAttribute.args ?? []).map(positionalArg));
-	return {
-		kind: "namedType",
-		name: entry.name,
-		baseType: entry.baseType,
-		attributes: [attribute],
-		span: SYNTHETIC_SPAN
-	};
-}
-function escapePslString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-}
-/**
-* Resolves a `SqlColumnIR.default` value into a normalized {@link ColumnDefault}.
-*
-* `SqlSchemaIR` types the column default as `string` (a raw database default
-* expression). Some legacy fixtures and tests still pass already-normalized
-* `ColumnDefault` objects in the same slot, so we accept either shape
-* defensively at runtime.
-*/
-function parseColumnDefault(value, nativeType, rawDefaultParser) {
-	if (typeof value === "string") return rawDefaultParser ? rawDefaultParser(value, nativeType) : void 0;
-	if (value !== null && typeof value === "object" && "kind" in value) return value;
-}
-function buildFieldNamesByTable(tables) {
-	const fieldNamesByTable = /* @__PURE__ */ new Map();
-	for (const table of Object.values(tables)) {
-		const assignmentOrder = [...Object.values(table.columns).map((column, index) => {
-			const { name, map } = toFieldName(column.name);
-			return {
-				columnName: column.name,
-				desiredFieldName: name,
-				fieldMap: map,
-				index
-			};
-		})].sort((left, right) => {
-			const mapComparison = Number(left.fieldMap !== void 0) - Number(right.fieldMap !== void 0);
-			if (mapComparison !== 0) return mapComparison;
-			return left.index - right.index;
-		});
-		const usedFieldNames = /* @__PURE__ */ new Set();
-		const tableFieldNames = /* @__PURE__ */ new Map();
-		for (const column of assignmentOrder) {
-			const fieldName = createUniqueFieldName(column.desiredFieldName, usedFieldNames);
-			usedFieldNames.add(fieldName);
-			tableFieldNames.set(column.columnName, {
-				fieldName,
-				fieldMap: column.fieldMap
-			});
-		}
-		fieldNamesByTable.set(table.name, tableFieldNames);
-	}
-	return fieldNamesByTable;
-}
-function resolveColumnFieldName(fieldNamesByTable, tableName, columnName) {
-	return fieldNamesByTable.get(tableName)?.get(columnName)?.fieldName ?? toFieldName(columnName).name;
-}
-function createUniqueFieldName(desiredName, usedFieldNames) {
-	if (!usedFieldNames.has(desiredName)) return desiredName;
-	let counter = 2;
-	while (usedFieldNames.has(`${desiredName}${counter}`)) counter++;
-	return `${desiredName}${counter}`;
-}
-function buildTopLevelNameMap(sources, normalize, kind, sourceKind) {
-	const results = /* @__PURE__ */ new Map();
-	const normalizedToSources = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		const normalized = normalize(source);
-		results.set(source, normalized);
-		normalizedToSources.set(normalized.name, [...normalizedToSources.get(normalized.name) ?? [], source]);
-	}
-	const duplicates = [...normalizedToSources.entries()].filter(([, conflictingSources]) => conflictingSources.length > 1);
-	if (duplicates.length > 0) {
-		const details = duplicates.map(([normalizedName, conflictingSources]) => `- ${kind} "${normalizedName}" from ${sourceKind}s ${conflictingSources.map((source) => `"${source}"`).join(", ")}`);
-		throw new Error(`PSL ${kind} name collisions detected:\n${details.join("\n")}`);
-	}
-	return results;
-}
-function createReservedNamedTypeNames(modelNames) {
-	const reservedNames = new Set(PSL_SCALAR_TYPE_NAMES);
-	for (const result of modelNames.values()) reservedNames.add(result.name);
-	return reservedNames;
-}
-function seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNames) {
-	const seeds = /* @__PURE__ */ new Map();
-	for (const tableName of Object.keys(schemaIR.tables).sort()) {
-		const table = schemaIR.tables[tableName];
-		if (!table) continue;
-		for (const columnName of Object.keys(table.columns).sort()) {
-			const column = table.columns[columnName];
-			if (!column) continue;
-			const resolution = typeMap.resolve(column.nativeType, table.annotations);
-			if ("unsupported" in resolution || enumNameMap.has(column.nativeType) || !resolution.nativeTypeAttribute) continue;
-			const signatureKey = createNamedTypeSignatureKey(resolution);
-			if (!seeds.has(signatureKey)) seeds.set(signatureKey, {
-				baseType: resolution.pslType,
-				desiredName: toNamedTypeName(column.name),
-				nativeTypeAttribute: resolution.nativeTypeAttribute
-			});
-		}
-	}
-	const registry = {
-		entriesByKey: /* @__PURE__ */ new Map(),
-		usedNames: new Set(reservedNames)
-	};
-	const sortedSeeds = [...seeds.entries()].sort((left, right) => {
-		const desiredNameComparison = left[1].desiredName.localeCompare(right[1].desiredName);
-		if (desiredNameComparison !== 0) return desiredNameComparison;
-		return left[0].localeCompare(right[0]);
-	});
-	for (const [signatureKey, seed] of sortedSeeds) {
-		const name = createUniqueFieldName(seed.desiredName, registry.usedNames);
-		registry.entriesByKey.set(signatureKey, {
-			name,
-			baseType: seed.baseType,
-			nativeTypeAttribute: seed.nativeTypeAttribute
-		});
-		registry.usedNames.add(name);
-	}
-	return registry;
-}
-function resolveNamedTypeName(registry, resolution) {
-	const key = createNamedTypeSignatureKey(resolution);
-	const existing = registry.entriesByKey.get(key);
-	if (existing) return existing.name;
-	throw new Error(`Named type registry was not seeded for native type "${resolution.nativeType}"`);
-}
-function createNamedTypeSignatureKey(resolution) {
-	return JSON.stringify({
-		baseType: resolution.pslType,
-		nativeTypeAttribute: resolution.nativeTypeAttribute ? {
-			name: resolution.nativeTypeAttribute.name,
-			args: resolution.nativeTypeAttribute.args ?? null
-		} : null
-	});
-}
-function topologicalSort(models, tables, modelNameMap) {
-	const modelByName = /* @__PURE__ */ new Map();
-	for (const model of models) modelByName.set(model.name, model);
-	const deps = /* @__PURE__ */ new Map();
-	const tableToModel = /* @__PURE__ */ new Map();
-	for (const tableName of Object.keys(tables)) {
-		const modelName = modelNameMap.get(tableName);
-		tableToModel.set(tableName, modelName);
-		deps.set(modelName, /* @__PURE__ */ new Set());
-	}
-	for (const [tableName, table] of Object.entries(tables)) {
-		const modelName = tableToModel.get(tableName);
-		for (const fk of table.foreignKeys) {
-			const refModelName = tableToModel.get(fk.referencedTable);
-			if (refModelName && refModelName !== modelName) deps.get(modelName).add(refModelName);
-		}
-	}
-	const result = [];
-	const visited = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	const sortedNames = [...deps.keys()].sort();
-	function visit(name) {
-		if (visited.has(name)) return;
-		if (visiting.has(name)) return;
-		visiting.add(name);
-		const sortedDeps = [...deps.get(name)].sort();
-		for (const dep of sortedDeps) visit(dep);
-		visiting.delete(name);
-		visited.add(name);
-		result.push(modelByName.get(name));
-	}
-	for (const name of sortedNames) visit(name);
-	return result;
-}
-//#endregion
 //#region src/core/control-instance.ts
 function extractCodecTypeIdsFromContract(contract) {
 	const typeIds = /* @__PURE__ */ new Set();
@@ -1050,7 +138,7 @@ function buildTransitiveDependsOnMap(extensions) {
 		}
 		return set;
 	};
-	for (const ext of extensions) resolve(ext.id, new Set([ext.id]));
+	for (const ext of extensions) resolve(ext.id, /* @__PURE__ */ new Set([ext.id]));
 	return result;
 }
 /**
@@ -1123,8 +211,18 @@ function createSqlFamilyInstance(stack) {
 	let controlAdapter;
 	const getControlAdapter = () => controlAdapter ??= adapter.create(stack);
 	const targetSerializer = target.contractSerializer;
-	const deserializeWithTargetSerializer = (contractJson) => {
-		return (targetSerializer ?? new SqlContractSerializer()).deserializeContract(contractJson);
+	const targetInferPslContract = blindCast(target).inferPslContract;
+	const diffSchema = blindCast(target).diffSchema;
+	const targetGranularityOf = blindCast(target).classifySubjectGranularity;
+	const targetEntityKindOf = blindCast(target).classifyEntityKind;
+	const describedContracts = extensions.flatMap((extension) => extension.contractSpace ? [{
+		spaceId: extension.id,
+		contract: extension.contractSpace.contractJson
+	}] : []);
+	const deserializeWithTargetSerializer = (contractOrJson) => {
+		const serializer = targetSerializer ?? new SqlContractSerializer();
+		const json = targetSerializer !== void 0 && !isPlainRecord(contractOrJson) ? targetSerializer.serializeContract(blindCast(contractOrJson)) : contractOrJson;
+		return serializer.deserializeContract(json);
 	};
 	return {
 		familyId: "sql",
@@ -1227,17 +325,41 @@ function createSqlFamilyInstance(stack) {
 		},
 		verifySchema(options) {
 			const contract = deserializeWithTargetSerializer(options.contract);
-			const controlAdapter = getControlAdapter();
-			return verifySqlSchema({
+			if (!diffSchema) throw new Error(`SQL target "${target.targetId}" is missing the required diffSchema descriptor operation`);
+			if (!targetGranularityOf) throw new Error(`SQL target "${target.targetId}" is missing the required classifySubjectGranularity descriptor operation`);
+			return verifySqlSchemaByDiff({
 				contract,
 				schema: options.schema,
 				strict: options.strict,
-				typeMetadataRegistry,
 				frameworkComponents: options.frameworkComponents,
-				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
-				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType)
+				diffSchema,
+				granularityOf: targetGranularityOf
 			});
 		},
+		/**
+		* Classifies a diff issue's subject granularity on demand, by resolving
+		* its node's `nodeKind` through the target's classifier — the
+		* {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability. Framework consumers spanning contract spaces (the
+		* migration aggregate's unclaimed-elements sweep) detect and call this
+		* instead of reaching into the concrete schema-IR node, which they
+		* cannot read; nothing is stamped on the issue or the node.
+		*/
+		classifySubjectGranularity(issue) {
+			if (!targetGranularityOf) throw new Error(`SQL target "${target.targetId}" is missing the required classifySubjectGranularity descriptor operation`);
+			return classifyDiffSubjectGranularity(issue, targetGranularityOf);
+		},
+		/**
+		* Classifies a diff issue's subject storage `entityKind` on demand, by
+		* resolving its node's `nodeKind` through the target's classifier —
+		* the sibling of `classifySubjectGranularity` above, and part of the
+		* same {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability.
+		*/
+		classifyEntityKind(issue) {
+			if (!targetEntityKindOf) throw new Error(`SQL target "${target.targetId}" is missing the required classifyEntityKind descriptor operation`);
+			return classifyDiffEntityKind(issue, targetEntityKindOf);
+		},
 		async sign(options) {
 			const { driver, contract: contractInput, contractPath, configPath } = options;
 			const startTime = Date.now();
@@ -1326,7 +448,8 @@ function createSqlFamilyInstance(stack) {
 			return getControlAdapter().introspect(options.driver, options.contract);
 		},
 		inferPslContract(schemaIR) {
-			return sqlSchemaIrToPslAst(schemaIR);
+			if (!targetInferPslContract) throw new Error(`Target "${target.targetId}" does not support contract infer (no inferPslContract on its descriptor).`);
+			return targetInferPslContract(schemaIR, describedContracts);
 		},
 		lowerAst(ast, context) {
 			return getControlAdapter().lowerToExecuteRequest(ast, context);
@@ -1334,21 +457,25 @@ function createSqlFamilyInstance(stack) {
 		bootstrapControlTableQueries() {
 			return getControlAdapter().bootstrapControlTableQueries();
 		},
-		bootstrapSignMarkerQueries() {
-			return getControlAdapter().bootstrapSignMarkerQueries();
-		},
 		toOperationPreview(operations) {
 			return sqlOperationsToPreview(operations);
 		},
 		toSchemaView(schema) {
-			const tableNodes = Object.entries(schema.tables).map(([tableName, table]) => {
+			const root = blindCast(schema);
+			const namespaceEntries = root.namespaces !== void 0 ? Object.entries(root.namespaces).map(([namespaceKey, namespace]) => [namespaceKey, namespace.tables]) : [[void 0, root.tables ?? {}]];
+			const qualify = namespaceEntries.length > 1;
+			const tableNodes = namespaceEntries.flatMap(([namespaceKey, tables]) => Object.entries(tables).map(([tableName, table]) => [
+				qualify && namespaceKey !== void 0 ? `${namespaceKey}.${tableName}` : tableName,
+				tableName,
+				table
+			])).map(([displayName, tableName, table]) => {
 				const children = [];
 				const columnNodes = [];
 				for (const [columnName, column] of Object.entries(table.columns)) {
 					const label = `${columnName}: ${column.nativeType} (${column.nullable ? "nullable" : "not nullable"})`;
 					columnNodes.push(new SchemaTreeNode({
 						kind: "field",
-						id: `column-${tableName}-${columnName}`,
+						id: `column-${displayName}-${columnName}`,
 						label,
 						meta: {
 							nativeType: column.nativeType,
@@ -1359,7 +486,7 @@ function createSqlFamilyInstance(stack) {
 				}
 				if (columnNodes.length > 0) children.push(new SchemaTreeNode({
 					kind: "collection",
-					id: `columns-${tableName}`,
+					id: `columns-${displayName}`,
 					label: "columns",
 					children: columnNodes
 				}));
@@ -1367,7 +494,7 @@ function createSqlFamilyInstance(stack) {
 					const pkColumns = table.primaryKey.columns.join(", ");
 					children.push(new SchemaTreeNode({
 						kind: "index",
-						id: `primary-key-${tableName}`,
+						id: `primary-key-${displayName}`,
 						label: `primary key: ${pkColumns}`,
 						meta: {
 							columns: table.primaryKey.columns,
@@ -1380,7 +507,7 @@ function createSqlFamilyInstance(stack) {
 					const label = `unique ${name}`;
 					children.push(new SchemaTreeNode({
 						kind: "index",
-						id: `unique-${tableName}-${name}`,
+						id: `unique-${displayName}-${name}`,
 						label,
 						meta: {
 							columns: unique.columns,
@@ -1393,7 +520,7 @@ function createSqlFamilyInstance(stack) {
 					const label = index.unique ? `unique index ${name}` : `index ${name}`;
 					children.push(new SchemaTreeNode({
 						kind: "index",
-						id: `index-${tableName}-${name}`,
+						id: `index-${displayName}-${name}`,
 						label,
 						meta: {
 							columns: index.columns,
@@ -1414,8 +541,8 @@ function createSqlFamilyInstance(stack) {
 				}));
 				return new SchemaTreeNode({
 					kind: "entity",
-					id: `table-${tableName}`,
-					label: `table ${tableName}`,
+					id: `table-${displayName}`,
+					label: `table ${displayName}`,
 					...Object.keys(tableMeta).length > 0 ? { meta: tableMeta } : {},
 					...children.length > 0 ? { children } : {}
 				});
@@ -1448,6 +575,264 @@ var SqlFamilyDescriptor = class {
 	}
 };
 //#endregion
+//#region src/core/migrations/contract-to-schema-ir.ts
+function convertColumn(name, column, storageTypes, expandNativeType, renderDefault) {
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	const baseNativeType = expandNativeType ? expandNativeType({
+		nativeType: resolved.nativeType,
+		codecId: resolved.codecId,
+		...ifDefined("typeParams", resolved.typeParams)
+	}) : resolved.nativeType;
+	const nativeType = baseNativeType;
+	const resolvedNativeType = column.many ? `${baseNativeType}[]` : baseNativeType;
+	return {
+		name,
+		nativeType,
+		nullable: column.nullable,
+		...ifDefined("many", column.many),
+		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0),
+		resolvedNativeType,
+		...ifDefined("resolvedDefault", column.default ?? void 0),
+		codecRef: buildColumnCodecRef(resolved, column.many),
+		codecBaseNativeType: resolved.nativeType,
+		...column.typeRef !== void 0 ? { codecNamedType: true } : {}
+	};
+}
+/**
+* Builds the column's `CodecRef` from its resolved (post-`typeRef`) codec
+* identity — the same construction the query AST and the migration DDL
+* renderer already use (TML-2456, TML-2918).
+*/
+function buildColumnCodecRef(resolved, many) {
+	return {
+		codecId: resolved.codecId,
+		...ifDefined("typeParams", resolved.typeParams !== void 0 ? blindCast(resolved.typeParams) : void 0),
+		...ifDefined("many", many)
+	};
+}
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referenced = storageTypes[column.typeRef];
+	if (!referenced) throw new Error(`Column references storage type "${column.typeRef}" but it is not defined in storage.types.`);
+	if (isStorageTypeInstance(referenced)) return {
+		codecId: referenced.codecId,
+		nativeType: referenced.nativeType,
+		typeParams: referenced.typeParams
+	};
+	throw new Error(`Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`);
+}
+/**
+* Resolves a `ValueSetRef` to its permitted values from the contract storage.
+*
+* Throws when the referenced namespace or value-set is absent — this indicates
+* the contract was built incorrectly (the check and the value-set must be
+* co-emitted by the lowering step). Used by `convertCheck` (schema-IR
+* projection), `verifyCheckConstraints` (verification), and
+* `checkConstraintPlanCallStrategy` (migration planning) so all three agree on
+* the resolved values and the error behavior on a missing reference.
+*/
+function allStrings(values) {
+	return values.every((value) => typeof value === "string");
+}
+function resolveValueSetValues(ref, storage, contextLabel) {
+	const ns = storage.namespaces[ref.namespaceId];
+	if (!ns) throw new Error(`resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`);
+	const valueSet = ns.entries.valueSet?.[ref.entityName];
+	if (!valueSet) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`);
+	const values = valueSet.values;
+	if (!allStrings(values)) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`);
+	return values;
+}
+/**
+* Projects a `CheckConstraint` IR into an `SqlCheckConstraintIRInput` by
+* resolving the permitted values from the storage value-set it references.
+*
+* The `CheckConstraint.valueSet` ref points to
+* `storage.namespaces[namespaceId].entries.valueSet[name]`. The resolved
+* values are lifted directly from `StorageValueSet.values` so verification
+* compares value sets, not SQL predicate strings.
+*
+* Throws if the referenced namespace or value-set is absent — this
+* indicates the contract was built incorrectly (the check and the
+* value-set must be co-emitted by the lowering step).
+*/
+function convertCheck(check, storage) {
+	const permittedValues = resolveValueSetValues(check.valueSet, storage, `check "${check.name}"`);
+	return {
+		name: check.name,
+		column: check.column,
+		permittedValues
+	};
+}
+function convertUnique(unique) {
+	return {
+		columns: unique.columns,
+		...ifDefined("name", unique.name)
+	};
+}
+function convertIndex(index) {
+	return {
+		columns: index.columns,
+		unique: false,
+		...ifDefined("name", index.name),
+		...ifDefined("type", index.type),
+		...ifDefined("options", index.options)
+	};
+}
+/**
+* The FK's referenced-namespace identity comes from the target's namespace
+* node, not the raw namespace-id string. An unbound target namespace stamps
+* no `referencedSchema` at all — the FK node's id renders the absence as the
+* empty segment, which is what flat (single-schema) introspection produces,
+* so both diff sides' FK ids meet by construction. A bound namespace (or a
+* cross-space target whose namespace lives in another contract's storage)
+* stamps its coordinate verbatim; namespaced targets (Postgres) resolve the
+* real DDL schema downstream.
+*/
+function convertForeignKey(fk, storage) {
+	const targetIsUnbound = storage.namespaces[fk.target.namespaceId]?.isUnbound === true;
+	return {
+		columns: fk.source.columns,
+		referencedTable: fk.target.tableName,
+		...targetIsUnbound ? {} : { referencedSchema: fk.target.namespaceId },
+		referencedColumns: fk.target.columns,
+		...ifDefined("name", fk.name),
+		...ifDefined("onDelete", fk.onDelete),
+		...ifDefined("onUpdate", fk.onUpdate)
+	};
+}
+function convertTable(name, table, storageTypes, expandNativeType, renderDefault, storage) {
+	const columns = {};
+	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault);
+	const satisfiedIndexColumns = new Set(backingIndexColumnKeys(table));
+	const fkBackingIndexes = [];
+	for (const fk of table.foreignKeys) {
+		if (fk.index === false) continue;
+		const key = fk.source.columns.join(",");
+		if (satisfiedIndexColumns.has(key)) continue;
+		fkBackingIndexes.push({
+			columns: fk.source.columns,
+			unique: false,
+			name: defaultIndexName(name, fk.source.columns)
+		});
+		satisfiedIndexColumns.add(key);
+	}
+	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, storage)) : void 0;
+	return new SqlTableIR({
+		name,
+		columns,
+		...ifDefined("primaryKey", table.primaryKey),
+		foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map((fk) => convertForeignKey(fk, storage)),
+		uniques: table.uniques.map(convertUnique),
+		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
+		...ifDefined("checks", checks)
+	});
+}
+/**
+* Detects destructive changes between two contract storages.
+*
+* The additive-only planner silently ignores removals (tables, columns).
+* This function detects those removals so callers can report them as conflicts
+* rather than silently producing an empty plan.
+*
+* Returns an empty array if no destructive changes are found.
+*/
+function detectDestructiveChanges(from, to) {
+	if (!from) return [];
+	const hasOwn = (value, key) => Object.hasOwn(value, key);
+	const conflicts = [];
+	const namespaceIds = [.../* @__PURE__ */ new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)])].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	for (const namespaceId of namespaceIds) {
+		const fromNs = from.namespaces[namespaceId];
+		const toNs = to.namespaces[namespaceId];
+		const fromTables = fromNs?.entries.table;
+		if (!fromTables) continue;
+		for (const tableName of Object.keys(fromTables)) {
+			const toTableRaw = toNs?.entries.table?.[tableName];
+			if (!StorageTable.is(toTableRaw)) {
+				conflicts.push({
+					kind: "tableRemoved",
+					summary: `Table "${tableName}" was removed`
+				});
+				continue;
+			}
+			const toTable = toTableRaw;
+			const fromTableRaw = fromTables[tableName];
+			if (!StorageTable.is(fromTableRaw)) continue;
+			const fromTable = fromTableRaw;
+			for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
+				kind: "columnRemoved",
+				summary: `Column "${tableName}"."${columnName}" was removed`
+			});
+		}
+	}
+	return conflicts;
+}
+/**
+* Converts a `Contract` to `SqlSchemaIR`.
+*
+* Reads `contract.storage` for tables and `contract.storage.types` for type
+* annotations. Storage-type annotations are written under
+* `options.annotationNamespace`.
+*
+* Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
+* structural information. When `expandNativeType` is provided, parameterized types
+* are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
+* resulting IR compares correctly against the "to" contract during planning.
+*
+* Returns an empty schema IR when `contract` is `null` (new project).
+*/
+/**
+* Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
+* table name within that namespace. Unlike {@link contractToSchemaIR}, which
+* flattens every namespace's tables into one bare-keyed record (and throws on a
+* cross-namespace name collision), this scopes the table iteration to one
+* namespace so the same table name can exist in two schemas.
+*
+* The full `storage` is still passed to `convertTable`, so value-set / enum /
+* type resolution that legitimately spans namespaces is unaffected. Foreign
+* keys are built purely from the FK descriptor (`fk.target`), so cross-namespace
+* FKs survive per-namespace conversion. The `annotations` block (storage-type
+* derived) is omitted here — the per-namespace tree consumer reads only the
+* per-table fields.
+*/
+function contractNamespaceToSchemaIR(storage, namespaceId, options) {
+	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
+	const namespace = storage.namespaces[namespaceId];
+	if (!namespace) return new SqlSchemaIR({ tables: {} });
+	const storageTypes = { ...storage.types ?? {} };
+	const tables = {};
+	for (const [tableName, tableDefRaw] of Object.entries(namespace.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${namespaceId}.entries.table.${tableName}`);
+		tables[tableName] = convertTable(tableName, tableDefRaw, storageTypes, options.expandNativeType, options.renderDefault, storage);
+	}
+	return new SqlSchemaIR({ tables });
+}
+function contractToSchemaIR(contract, options) {
+	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
+	if (!contract) return new SqlSchemaIR({ tables: {} });
+	const storage = contract.storage;
+	const storageTypes = { ...storage.types ?? {} };
+	const tables = {};
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${ns.id}.entries.table.${tableName}`);
+		const tableDef = tableDefRaw;
+		if (tables[tableName] !== void 0) throw new Error(`contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`);
+		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault, storage);
+	}
+	return new SqlSchemaIR({
+		tables,
+		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace, options.resolveEnumNamespaceSchema))
+	});
+}
+function deriveAnnotations(storage, annotationNamespace, _resolveEnumNamespaceSchema) {
+	const storageTypes = {};
+	for (const typeInstance of Object.values(storage.types ?? {})) if (isStorageTypeInstance(typeInstance)) storageTypes[typeInstance.nativeType] = typeInstance;
+	const envelope = { ...Object.keys(storageTypes).length > 0 ? { storageTypes } : {} };
+	if (Object.keys(envelope).length === 0) return void 0;
+	return { [annotationNamespace]: envelope };
+}
+//#endregion
 //#region src/core/migrations/control-policy.ts
 /**
 * The control policy that governs a single call. The `external` default is an
@@ -1478,43 +863,10 @@ function callAllowedUnderControlPolicy(policy, subject) {
 		case "observed": return false;
 	}
 }
-function defaultSubjectLabel(factoryName, subject) {
-	if (subject?.table) return `${factoryName}(${subject.table})`;
-	if (subject?.typeName) return `${factoryName}(${subject.typeName})`;
-	return factoryName;
-}
-function suppressionSummary(subjectLabel, subject, effectivePolicy) {
-	const namespace = subject?.namespaceId ?? "unknown";
-	const declared = subject?.explicitNodeControlPolicy;
-	if (effectivePolicy === "external" && declared === "managed") return `control policy suppressed: ${subjectLabel} — namespace '${namespace}' has effective control 'external' but table declared 'managed'`;
-	return `control policy suppressed: ${subjectLabel} — namespace '${namespace}' has effective control '${effectivePolicy}'${declared ? ` but table declared '${declared}'` : ""}`;
-}
-function buildSubjectSuppressionWarning(subject, effectivePolicy, factoryName, formatSubjectLabel) {
-	return {
-		kind: "controlPolicySuppressedCall",
-		summary: suppressionSummary(formatSubjectLabel(factoryName, subject), subject, effectivePolicy),
-		location: {
-			...ifDefined("namespace", subject?.namespaceId),
-			...ifDefined("table", subject?.table),
-			...ifDefined("column", subject?.column),
-			...ifDefined("type", subject?.typeName)
-		},
-		meta: {
-			controlPolicy: effectivePolicy,
-			factoryName,
-			...ifDefined("declaredControlPolicy", subject?.explicitNodeControlPolicy)
-		}
-	};
-}
-function defaultModificationFactoryNameForSubject(subject) {
-	if (subject.table) return "alterTable";
-	if (subject.typeName) return "alterType";
-	return "alterSchema";
-}
 /**
 * Partition the calls produced for a single set of subjects into those the
 * effective control policy permits (`kept`) and a list of
-* {@link SqlPlannerConflict} warnings describing the suppressed calls.
+* {@link SuppressionRecord}s describing the suppressed calls.
 *
 * **Prefer {@link partitionIssuesByControlPolicy}** for the schema-issue
 * pipeline: it filters subjects out of the planner's *input* so the planner
@@ -1526,21 +878,22 @@ function defaultModificationFactoryNameForSubject(subject) {
 */
 function partitionCallsByControlPolicy(options) {
 	const defaultControlPolicy = options.contract.defaultControlPolicy;
-	const formatSubjectLabel = options.formatSubjectLabel ?? defaultSubjectLabel;
 	const kept = [];
-	const warnings = [];
+	const suppressions = [];
 	for (const call of options.calls) {
 		const subject = options.resolveControlPolicySubject(call);
 		const policy = controlPolicyForCall(subject, defaultControlPolicy);
 		if (callAllowedUnderControlPolicy(policy, subject)) kept.push(call);
-		else {
-			const factoryName = options.resolveFactoryName(call);
-			warnings.push(buildSubjectSuppressionWarning(subject, policy, factoryName, formatSubjectLabel));
-		}
+		else suppressions.push({
+			subject,
+			policy,
+			factoryName: options.resolveFactoryName(call),
+			createsNewObject: subject?.createsNewObject ?? false
+		});
 	}
 	return Object.freeze({
 		kept: Object.freeze(kept),
-		warnings: Object.freeze(warnings)
+		suppressions: Object.freeze(suppressions)
 	});
 }
 /**
@@ -1557,23 +910,18 @@ function partitionCallsByControlPolicy(options) {
 * cannot reason about the live shape of a subject the user marked as
 * out-of-scope (`external`).
 *
-* `warnings` is one {@link SqlPlannerConflict} per suppressed subject (not per
-* suppressed issue). `factoryName` is inferred from the subject's issue mix:
-* if any of the subject's issues is whole-object creation, the warning takes
-* the corresponding creation factoryName (e.g. `createTable`,
-* `createEnumType`, `createSchema`); otherwise it falls back to
-* `defaultModificationFactoryName(subject)` — a synthetic label that names
-* the *kind* of mutation that would have run, since no concrete DDL call was
-* generated.
+* `suppressions` is one {@link SuppressionRecord} per suppressed subject (not
+* per suppressed issue). Its `factoryName` is the creation factory name when any
+* of the subject's issues is whole-object creation (e.g. `createTable`), else
+* `undefined` — the family never invents a modification verb for an op that
+* produced no call; the target renders the message.
 *
 * Unresolved-subject issues (`resolveControlPolicySubject` returns
-* `undefined`) emit one warning each; they cannot be deduplicated because
-* they carry no subject coordinate.
+* `undefined`) emit one record each; they cannot be deduplicated because they
+* carry no subject coordinate.
 */
 function partitionIssuesByControlPolicy(options) {
 	const defaultControlPolicy = options.contract.defaultControlPolicy;
-	const formatSubjectLabel = options.formatSubjectLabel ?? defaultSubjectLabel;
-	const inferModificationFactoryName = options.defaultModificationFactoryName ?? defaultModificationFactoryNameForSubject;
 	const plannable = [];
 	const suppressedSubjects = /* @__PURE__ */ new Map();
 	const unresolvedSuppressions = [];
@@ -1590,8 +938,12 @@ function partitionIssuesByControlPolicy(options) {
 			continue;
 		}
 		if (subject === void 0) {
-			const factoryName = creationFactoryName ?? "unknown";
-			unresolvedSuppressions.push(buildSubjectSuppressionWarning(void 0, policy, factoryName, formatSubjectLabel));
+			unresolvedSuppressions.push({
+				subject: void 0,
+				policy,
+				factoryName: creationFactoryName,
+				createsNewObject: false
+			});
 			continue;
 		}
 		const key = subjectKey(subject);
@@ -1604,18 +956,20 @@ function partitionIssuesByControlPolicy(options) {
 			...ifDefined("creationFactoryName", creationFactoryName)
 		});
 	}
-	const warnings = [...unresolvedSuppressions];
-	for (const entry of suppressedSubjects.values()) {
-		const factoryName = entry.creationFactoryName ?? inferModificationFactoryName(entry.subject);
-		warnings.push(buildSubjectSuppressionWarning(entry.subject, entry.policy, factoryName, formatSubjectLabel));
-	}
+	const suppressions = [...unresolvedSuppressions];
+	for (const entry of suppressedSubjects.values()) suppressions.push({
+		subject: entry.subject,
+		policy: entry.policy,
+		factoryName: entry.creationFactoryName,
+		createsNewObject: entry.subject.createsNewObject
+	});
 	return Object.freeze({
 		plannable: Object.freeze(plannable),
-		warnings: Object.freeze(warnings)
+		suppressions: Object.freeze(suppressions)
 	});
 }
 function subjectKey(subject) {
-	return `${subject.namespaceId}\u0000${subject.table ?? ""}\u0000${subject.typeName ?? ""}`;
+	return `${subject.namespaceId}\u0000${subject.entityKind ?? ""}\u0000${subject.entityName ?? ""}`;
 }
 //#endregion
 //#region src/core/migrations/field-event-planner.ts
@@ -1635,8 +989,8 @@ function planFieldEventOperations(options) {
 		for (const tableName of tableNames) {
 			const priorTableRaw = priorTables?.[tableName];
 			const newTableRaw = newTables?.[tableName];
-			const priorTable = priorTableRaw instanceof StorageTable ? priorTableRaw : void 0;
-			const newTable = newTableRaw instanceof StorageTable ? newTableRaw : void 0;
+			const priorTable = StorageTable.is(priorTableRaw) ? priorTableRaw : void 0;
+			const newTable = StorageTable.is(newTableRaw) ? newTableRaw : void 0;
 			const fieldNames = unionSorted(priorTable ? Object.keys(priorTable.columns) : [], newTable ? Object.keys(newTable.columns) : []);
 			for (const fieldName of fieldNames) {
 				const priorField = priorTable?.columns[fieldName];
@@ -1742,6 +1096,25 @@ function unionSorted(a, b) {
 	return [...set].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
 }
 //#endregion
+//#region src/core/migrations/native-type-expander.ts
+/**
+* Builds the codec-hook-composed `expandNativeType` callback the contract→IR
+* derivation uses to expand parameterized native types (e.g. `character` +
+* `{ length: 36 }` → `character(36)`). Returns `undefined` when no framework
+* components are supplied, so callers can omit the option entirely.
+*/
+function buildNativeTypeExpander(frameworkComponents) {
+	if (!frameworkComponents) return;
+	const codecHooks = extractCodecControlHooks(frameworkComponents);
+	return (input) => {
+		if (!input.typeParams) return input.nativeType;
+		if (!input.codecId) return input.nativeType;
+		const hooks = codecHooks.get(input.codecId);
+		if (!hooks?.expandNativeType) return input.nativeType;
+		return hooks.expandNativeType(input);
+	};
+}
+//#endregion
 //#region src/core/migrations/plan-helpers.ts
 const readOnlyEmptyObject = Object.freeze({});
 function cloneRecord(value) {
@@ -1853,6 +1226,6 @@ const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.fre
 //#region src/exports/control.ts
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, resolveValueSetValues, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, buildNativeTypeExpander, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, resolveValueSetValues, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map