@prisma-next/family-sql 0.12.0 → 0.13.0-dev.1

package/dist/control.mjs

@@ -1,18 +1,17 @@
-import { n as sqlFamilyAuthoringFieldPresets, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-F4JpCJl7.mjs";
-import { t as SqlContractSerializer } from "./sql-contract-serializer-8axtK4lg.mjs";
-import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-CYLsGCFO.mjs";
-import { t as collectSupportedCodecTypeIds } from "./verify-Crewz6hG.mjs";
-import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-r7BP5n3l.mjs";
+import { n as sqlFamilyAuthoringFieldPresets, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-D4lQ-qpj.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-CY7qnms7.mjs";
+import { a as contractToSchemaIR, c as extractCodecControlHooks, o as detectDestructiveChanges, s as resolveValueSetValues, t as verifySqlSchema } from "./verify-sql-schema-DlAgBiT_.mjs";
+import { t as collectSupportedCodecTypeIds } from "./verify-C-G0obRm.mjs";
+import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-CloimujU.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
 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 { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
 import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
-import { ensureSchemaStatement, ensureTableStatement, writeContractMarker } from "@prisma-next/sql-runtime";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { StorageTable, isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
-import { UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma-next/framework-components/psl-ast";
+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 { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -660,14 +659,12 @@ function buildPslDocumentAst(schemaIR, options) {
 	return {
 		kind: "document",
 		sourceId: "<sql-schema-ir>",
-		namespaces: [{
+		namespaces: [makePslNamespace({
 			kind: "namespace",
 			name: UNSPECIFIED_PSL_NAMESPACE_ID,
-			models: sortedModels,
-			enums,
-			compositeTypes: [],
+			entries: makePslNamespaceEntries(sortedModels, enums, [], []),
 			span: SYNTHETIC_SPAN
-		}],
+		})],
 		...types ? { types } : {},
 		span: SYNTHETIC_SPAN
 	};
@@ -1023,7 +1020,7 @@ function extractCodecTypeIdsFromContract(contract) {
 	if (typeof contract === "object" && contract !== null && "storage" in contract && typeof contract.storage === "object" && contract.storage !== null && "namespaces" in contract.storage && typeof contract.storage.namespaces === "object" && contract.storage.namespaces !== null) {
 		const namespaces = contract.storage.namespaces;
 		for (const ns of Object.values(namespaces)) {
-			const tbls = ns.tables;
+			const tbls = ns.entries.table;
 			if (typeof tbls !== "object" || tbls === null) continue;
 			for (const table of Object.values(tbls)) if (typeof table === "object" && table !== null && "columns" in table && typeof table.columns === "object" && table.columns !== null) {
 				const columns = table.columns;
@@ -1057,9 +1054,6 @@ function createVerifyResult(options) {
 	if (options.codecCoverageSkipped) result.codecCoverageSkipped = options.codecCoverageSkipped;
 	return result;
 }
-function isSqlControlAdapter(value) {
-	return typeof value === "object" && value !== null && "introspect" in value && typeof value.introspect === "function" && "readMarker" in value && typeof value.readMarker === "function" && "readAllMarkers" in value && typeof value.readAllMarkers === "function" && "lower" in value && typeof value.lower === "function";
-}
 function buildSqlTypeMetadataRegistry(options) {
 	const { target, adapter, extensionPacks: extensions } = options;
 	const registry = /* @__PURE__ */ new Map();
@@ -1081,6 +1075,81 @@ function buildSqlTypeMetadataRegistry(options) {
 	}
 	return registry;
 }
+/**
+* Builds a map from each extension id to the set of extension ids it
+* transitively depends on. Uses the same declared-dependency data that
+* `buildExtensionLoadOrder` in control-stack uses.
+*/
+function buildTransitiveDependsOnMap(extensions) {
+	const directDeps = /* @__PURE__ */ new Map();
+	for (const ext of extensions) {
+		const packs = ext.contractSpace?.contractJson?.extensionPacks;
+		const deps = packs !== null && typeof packs === "object" ? Object.keys(packs) : [];
+		directDeps.set(ext.id, deps);
+	}
+	const result = /* @__PURE__ */ new Map();
+	const resolve = (id, visiting) => {
+		const cached = result.get(id);
+		if (cached !== void 0) return cached;
+		const set = /* @__PURE__ */ new Set();
+		result.set(id, set);
+		for (const depId of directDeps.get(id) ?? []) {
+			set.add(depId);
+			if (!visiting.has(depId)) {
+				visiting.add(depId);
+				for (const transitive of resolve(depId, visiting)) set.add(transitive);
+				visiting.delete(depId);
+			}
+		}
+		return set;
+	};
+	for (const ext of extensions) resolve(ext.id, new Set([ext.id]));
+	return result;
+}
+/**
+* Asserts that no cross-space FK in any extension points against the
+* dependency direction.
+*
+* A cross-space FK (target.spaceId present) from extension A pointing at
+* space B is a violation when B depends on A (directly or transitively),
+* because that means A is pointing "upward" against the dependency arrows
+* established by the extension load order.
+*
+* Throws with a diagnostic naming the violating extension (source), the
+* target space, and the direction violation.
+*/
+function isObjectRecord(v) {
+	return typeof v === "object" && v !== null;
+}
+function assertNoCrossSpaceFkReverseReferences(extensions) {
+	const dependsOnMap = buildTransitiveDependsOnMap(extensions);
+	for (const ext of extensions) {
+		const namespaces = ext.contractSpace?.contractJson?.storage?.namespaces;
+		if (!isObjectRecord(namespaces)) continue;
+		for (const ns of Object.values(namespaces)) {
+			if (!isObjectRecord(ns)) continue;
+			const entries = ns["entries"];
+			if (!isObjectRecord(entries)) continue;
+			for (const slot of Object.values(entries)) {
+				if (!isObjectRecord(slot)) continue;
+				for (const table of Object.values(slot)) {
+					if (!isObjectRecord(table)) continue;
+					const foreignKeys = table["foreignKeys"];
+					if (!Array.isArray(foreignKeys)) continue;
+					for (const fk of foreignKeys) {
+						if (!isObjectRecord(fk)) continue;
+						const target = fk["target"];
+						if (!isObjectRecord(target)) continue;
+						if (target["spaceId"] === void 0) continue;
+						const targetSpaceId = target["spaceId"];
+						if (typeof targetSpaceId !== "string") continue;
+						if (dependsOnMap.get(targetSpaceId)?.has(ext.id)) throw new Error(`Cross-space FK reverse-reference detected: extension "${ext.id}" has a cross-space FK targeting space "${targetSpaceId}", but "${targetSpaceId}" depends on "${ext.id}". Cross-space FKs must follow the dependency direction (a space can only reference spaces it depends on, not spaces that depend on it).`);
+					}
+				}
+			}
+		}
+	}
+}
 function createSqlFamilyInstance(stack) {
 	if (!stack.adapter) throw new Error("SQL family requires an adapter descriptor in ControlStack");
 	const target = stack.target;
@@ -1097,17 +1166,15 @@ function createSqlFamilyInstance(stack) {
 			...sqlContractCanonicalizationHooks
 		});
 	}
+	assertNoCrossSpaceFkReverseReferences(extensions);
 	const { codecTypeImports, extensionIds } = stack;
 	const typeMetadataRegistry = buildSqlTypeMetadataRegistry({
 		target,
 		adapter,
 		extensionPacks: extensions
 	});
-	const getControlAdapter = () => {
-		const controlAdapter = adapter.create(stack);
-		if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter (missing introspect, readMarker, or readAllMarkers)");
-		return controlAdapter;
-	};
+	let controlAdapter;
+	const getControlAdapter = () => controlAdapter ??= adapter.create(stack);
 	const targetSerializer = target.contractSerializer;
 	const deserializeWithTargetSerializer = (contractJson) => {
 		return (targetSerializer ?? new SqlContractSerializer()).deserializeContract(contractJson);
@@ -1233,21 +1300,21 @@ function createSqlFamilyInstance(stack) {
 			const contractStorageHash = contract.storage.storageHash;
 			const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : contractStorageHash;
 			const contractTarget = contract.target;
-			await driver.query(ensureSchemaStatement.sql, ensureSchemaStatement.params);
-			await driver.query(ensureTableStatement.sql, ensureTableStatement.params);
-			const existingMarker = await getControlAdapter().readMarker(driver, APP_SPACE_ID);
+			const controlAdapter = getControlAdapter();
+			const lowererContext = { contract };
+			for (const query of controlAdapter.bootstrapSignMarkerQueries()) {
+				const lowered = controlAdapter.lower(query, lowererContext);
+				await driver.query(lowered.sql, lowered.params);
+			}
+			const existingMarker = await controlAdapter.readMarker(driver, APP_SPACE_ID);
 			let markerCreated = false;
 			let markerUpdated = false;
 			let previousHashes;
 			if (!existingMarker) {
-				const write = writeContractMarker({
-					space: APP_SPACE_ID,
+				await controlAdapter.insertMarker(driver, APP_SPACE_ID, {
 					storageHash: contractStorageHash,
-					profileHash: contractProfileHash,
-					contractJson: contractInput,
-					canonicalVersion: 1
+					profileHash: contractProfileHash
 				});
-				await driver.query(write.insert.sql, write.insert.params);
 				markerCreated = true;
 			} else {
 				const existingStorageHash = existingMarker.storageHash;
@@ -1257,14 +1324,10 @@ function createSqlFamilyInstance(stack) {
 						storageHash: existingStorageHash,
 						profileHash: existingProfileHash
 					};
-					const write = writeContractMarker({
-						space: APP_SPACE_ID,
+					if (!await controlAdapter.updateMarker(driver, APP_SPACE_ID, existingStorageHash, {
 						storageHash: contractStorageHash,
-						profileHash: contractProfileHash,
-						contractJson: contractInput,
-						canonicalVersion: existingMarker.canonicalVersion ?? 1
-					});
-					await driver.query(write.update.sql, write.update.params);
+						profileHash: contractProfileHash
+					})) throw new Error("CAS conflict: marker was modified by another process during sign");
 					markerUpdated = true;
 				}
 			}
@@ -1302,6 +1365,18 @@ function createSqlFamilyInstance(stack) {
 		async readAllMarkers(options) {
 			return getControlAdapter().readAllMarkers(options.driver);
 		},
+		async readLedger(options) {
+			return getControlAdapter().readLedger(options.driver, options.space);
+		},
+		async initMarker(options) {
+			return getControlAdapter().initMarker(options.driver, options.space, options.destination);
+		},
+		async updateMarker(options) {
+			return getControlAdapter().updateMarker(options.driver, options.space, options.expectedFrom, options.destination);
+		},
+		async writeLedgerEntry(options) {
+			return getControlAdapter().writeLedgerEntry(options.driver, options.space, options.entry);
+		},
 		async introspect(options) {
 			return getControlAdapter().introspect(options.driver, options.contract);
 		},
@@ -1311,6 +1386,12 @@ function createSqlFamilyInstance(stack) {
 		lowerAst(ast, context) {
 			return getControlAdapter().lower(ast, context);
 		},
+		bootstrapControlTableQueries() {
+			return getControlAdapter().bootstrapControlTableQueries();
+		},
+		bootstrapSignMarkerQueries() {
+			return getControlAdapter().bootstrapSignMarkerQueries();
+		},
 		toOperationPreview(operations) {
 			return sqlOperationsToPreview(operations);
 		},
@@ -1420,200 +1501,174 @@ 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);
-	return {
-		name,
-		nativeType: expandNativeType ? expandNativeType({
-			nativeType: resolved.nativeType,
-			codecId: resolved.codecId,
-			...ifDefined("typeParams", resolved.typeParams)
-		}) : resolved.nativeType,
-		nullable: column.nullable,
-		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0)
-	};
+//#region src/core/migrations/control-policy.ts
+/**
+* The control policy that governs a single call. The `external` default is an
+* un-overridable namespace floor: when the contract default is `external`, no
+* per-object `managed` override can escalate DDL above the floor, so the
+* policy is forced to `external` regardless of the node's own declaration.
+* Every other default defers to the node's effective control policy.
+*/
+function controlPolicyForCall(subject, defaultControlPolicy) {
+	if (defaultControlPolicy === "external") return "external";
+	return effectiveControlPolicy(subject?.explicitNodeControlPolicy, defaultControlPolicy);
 }
-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 (isPostgresEnumStorageEntry(referenced)) return {
-		codecId: referenced.codecId,
-		nativeType: referenced.nativeType,
-		typeParams: { values: referenced.values }
-	};
-	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 codec-instance or postgres-enum.`);
+/**
+* Whether a call is allowed to emit under a given control policy.
+*
+* - `managed` — full lifecycle, every op allowed.
+* - `tolerated` — create-if-absent only: allowed iff the call creates a whole
+*   new top-level object (and its subject was positively resolved). Anything
+*   that modifies an existing object, and anything whose subject could not be
+*   resolved, is suppressed.
+* - `external` / `observed` — no DDL at all.
+*/
+function callAllowedUnderControlPolicy(policy, subject) {
+	switch (policy) {
+		case "managed": return true;
+		case "tolerated": return subject?.createsNewObject === true;
+		case "external":
+		case "observed": return false;
+	}
 }
-function convertUnique(unique) {
-	return {
-		columns: unique.columns,
-		...ifDefined("name", unique.name)
-	};
+function defaultSubjectLabel(factoryName, subject) {
+	if (subject?.table) return `${factoryName}(${subject.table})`;
+	if (subject?.typeName) return `${factoryName}(${subject.typeName})`;
+	return factoryName;
 }
-function convertIndex(index) {
-	return {
-		columns: index.columns,
-		unique: false,
-		...ifDefined("name", index.name)
-	};
+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 convertForeignKey(fk) {
+function buildSubjectSuppressionWarning(subject, effectivePolicy, factoryName, formatSubjectLabel) {
 	return {
-		columns: fk.source.columns,
-		referencedTable: fk.target.tableName,
-		referencedSchema: fk.target.namespaceId,
-		referencedColumns: fk.target.columns,
-		...ifDefined("name", fk.name),
-		...ifDefined("onDelete", fk.onDelete),
-		...ifDefined("onUpdate", fk.onUpdate)
+		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 convertTable(name, table, storageTypes, expandNativeType, renderDefault) {
-	const columns = {};
-	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault);
-	const satisfiedIndexColumns = new Set([
-		...table.indexes.map((idx) => idx.columns.join(",")),
-		...table.uniques.map((unique) => unique.columns.join(",")),
-		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
-	]);
-	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);
-	}
-	return {
-		name,
-		columns,
-		...ifDefined("primaryKey", table.primaryKey),
-		foreignKeys: table.foreignKeys.map(convertForeignKey),
-		uniques: table.uniques.map(convertUnique),
-		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes]
-	};
+function defaultModificationFactoryNameForSubject(subject) {
+	if (subject.table) return "alterTable";
+	if (subject.typeName) return "alterType";
+	return "alterSchema";
 }
 /**
-* Detects destructive changes between two contract storages.
+* 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.
 *
-* 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.
+* **Prefer {@link partitionIssuesByControlPolicy}** for the schema-issue
+* pipeline: it filters subjects out of the planner's *input* so the planner
+* never has to reason about un-modeled state on `external`/`observed`
+* subjects. This call-level helper remains for paths that bypass the issue
+* pipeline — currently the codec-emitted field-event ops, which originate
+* from declared contract fields rather than from introspected schema state
+* and therefore cannot trip the diff engine.
 */
-function detectDestructiveChanges(from, to) {
-	if (!from) return [];
-	const hasOwn = (value, key) => Object.hasOwn(value, key);
-	const conflicts = [];
-	const namespaceIds = [...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?.tables;
-		if (!fromTables) continue;
-		for (const tableName of Object.keys(fromTables)) {
-			const toTableRaw = toNs?.tables[tableName];
-			if (!(toTableRaw instanceof StorageTable)) {
-				conflicts.push({
-					kind: "tableRemoved",
-					summary: `Table "${tableName}" was removed`
-				});
-				continue;
-			}
-			const toTable = toTableRaw;
-			const fromTableRaw = fromTables[tableName];
-			if (!(fromTableRaw instanceof StorageTable)) 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`
-			});
+function partitionCallsByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const formatSubjectLabel = options.formatSubjectLabel ?? defaultSubjectLabel;
+	const kept = [];
+	const warnings = [];
+	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));
 		}
 	}
-	return conflicts;
+	return Object.freeze({
+		kept: Object.freeze(kept),
+		warnings: Object.freeze(warnings)
+	});
 }
 /**
-* Converts a `Contract` to `SqlSchemaIR`.
+* Partition a list of schema-issue-shaped inputs by the effective control
+* policy of each issue's subject *before* the planner is invoked.
 *
-* Reads `contract.storage` for tables and `contract.storage.types` for type
-* annotations. Storage-type annotations are written under
-* `options.annotationNamespace`.
+* `plannable` is the list of issues whose subject's effective policy permits
+* the planner to act on them (`managed`, or `tolerated` for whole-object
+* creation issues only). Issues for `external`/`observed` subjects, and
+* non-creation issues for `tolerated` subjects, are dropped from the planner's
+* input entirely — they never enter introspection-driven planning, never feed
+* the diff engine, and never produce DDL calls that would have to be
+* post-filtered. This sidesteps a class of failure where the diff engine
+* cannot reason about the live shape of a subject the user marked as
+* out-of-scope (`external`).
 *
-* 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.
+* `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.
 *
-* Returns an empty schema IR when `contract` is `null` (new project).
-*/
-function contractToSchemaIR(contract, options) {
-	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
-	if (!contract) return { tables: {} };
-	const storage = contract.storage;
-	const allTypes = { ...storage.types ?? {} };
-	for (const ns of Object.values(storage.namespaces)) {
-		const nsEnums = ns.enum;
-		if (nsEnums) for (const [k, v] of Object.entries(nsEnums)) allTypes[k] = v;
-	}
-	const storageTypes = allTypes;
-	const tables = {};
-	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.tables)) {
-		if (!(tableDefRaw instanceof StorageTable)) throw new Error(`contractToSchemaIR: expected StorageTable at namespaces.${ns.id}.tables.${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);
-	}
-	return {
-		tables,
-		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace, options.resolveEnumStorageKey))
-	};
-}
-/**
-* Normalises a native enum storage entry to the codec-typed annotation shape
-* `{codecId, nativeType, typeParams}` the introspector writes and
-* `readExistingEnumValues` reads (`existing.codecId` + `existing.typeParams.values`).
-* Without this the projector would emit the raw `PostgresEnumStorageEntry`
-* shape (top-level `values`, no `typeParams`) and the enum would read as new.
+* Unresolved-subject issues (`resolveControlPolicySubject` returns
+* `undefined`) emit one warning each; they cannot be deduplicated because
+* they carry no subject coordinate.
 */
-function normalizeEnumAnnotation(entry) {
-	return toStorageTypeInstance({
-		codecId: entry.codecId,
-		nativeType: entry.nativeType,
-		typeParams: { values: entry.values }
-	});
-}
-function deriveAnnotations(storage, annotationNamespace, resolveEnumStorageKey) {
-	const storageTypes = {};
-	for (const typeInstance of Object.values(storage.types ?? {})) {
-		if (isPostgresEnumStorageEntry(typeInstance)) {
-			const key = resolveEnumStorageKey ? resolveEnumStorageKey(storage, UNBOUND_NAMESPACE_ID, typeInstance.nativeType) : typeInstance.nativeType;
-			storageTypes[key] = normalizeEnumAnnotation(typeInstance);
+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 = [];
+	for (const issue of options.issues) {
+		const subject = options.resolveControlPolicySubject(issue);
+		const policy = controlPolicyForCall(subject, defaultControlPolicy);
+		const creationFactoryName = options.resolveCreationFactoryName(issue);
+		if (policy === "managed") {
+			plannable.push(issue);
 			continue;
 		}
-		if (isStorageTypeInstance(typeInstance)) storageTypes[typeInstance.nativeType] = typeInstance;
-	}
-	for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
-		const nsEnums = ns.enum;
-		if (!nsEnums) continue;
-		for (const entry of Object.values(nsEnums)) {
-			if (!isPostgresEnumStorageEntry(entry)) continue;
-			const key = resolveEnumStorageKey ? resolveEnumStorageKey(storage, namespaceId, entry.nativeType) : entry.nativeType;
-			storageTypes[key] = normalizeEnumAnnotation(entry);
+		if (policy === "tolerated" && subject !== void 0 && creationFactoryName !== void 0 && subject.createsNewObject) {
+			plannable.push(issue);
+			continue;
+		}
+		if (subject === void 0) {
+			const factoryName = creationFactoryName ?? "unknown";
+			unresolvedSuppressions.push(buildSubjectSuppressionWarning(void 0, policy, factoryName, formatSubjectLabel));
+			continue;
 		}
+		const key = subjectKey(subject);
+		const existing = suppressedSubjects.get(key);
+		if (existing) {
+			if (existing.creationFactoryName === void 0 && creationFactoryName !== void 0) existing.creationFactoryName = creationFactoryName;
+		} else suppressedSubjects.set(key, {
+			subject,
+			policy,
+			...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));
 	}
-	if (Object.keys(storageTypes).length === 0) return void 0;
-	return { [annotationNamespace]: { storageTypes } };
+	return Object.freeze({
+		plannable: Object.freeze(plannable),
+		warnings: Object.freeze(warnings)
+	});
+}
+function subjectKey(subject) {
+	return `${subject.namespaceId}\u0000${subject.table ?? ""}\u0000${subject.typeName ?? ""}`;
 }
 //#endregion
 //#region src/core/migrations/field-event-planner.ts
@@ -1627,8 +1682,8 @@ function planFieldEventOperations(options) {
 	for (const namespaceId of namespaceIds) {
 		const priorNs = priorContract?.storage.namespaces[namespaceId];
 		const newNs = newContract.storage.namespaces[namespaceId];
-		const priorTables = priorNs?.tables;
-		const newTables = newNs?.tables;
+		const priorTables = priorNs?.entries.table;
+		const newTables = newNs?.entries.table;
 		const tableNames = unionSorted(priorTables ? Object.keys(priorTables) : [], newTables ? Object.keys(newTables) : []);
 		for (const tableName of tableNames) {
 			const priorTableRaw = priorTables?.[tableName];
@@ -1796,10 +1851,17 @@ function createMigrationPlan(options) {
 		...options.meta ? { meta: cloneRecord(options.meta) } : {}
 	});
 }
-function plannerSuccess(plan) {
+function plannerSuccess(plan, warnings) {
 	return Object.freeze({
 		kind: "success",
-		plan
+		plan,
+		...warnings && warnings.length > 0 ? { warnings: Object.freeze(warnings.map((conflict) => Object.freeze({
+			kind: conflict.kind,
+			summary: conflict.summary,
+			...conflict.why ? { why: conflict.why } : {},
+			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+		}))) } : {}
 	});
 }
 function plannerFailure(conflicts) {
@@ -1844,6 +1906,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, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, resolveValueSetValues, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map