@prisma-next/family-sql 0.12.0-dev.6 → 0.12.0-dev.61

package/dist/control.mjs

@@ -1,18 +1,19 @@
-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-BkjCQIde.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 extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-d3P9NA_8.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 { blindCast } from "@prisma-next/utils/casts";
 import { UNSPECIFIED_PSL_NAMESPACE_ID } 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) {
@@ -1023,7 +1024,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 +1058,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 +1079,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 +1170,14 @@ 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;
-	};
+	const getControlAdapter = () => adapter.create(stack);
 	const targetSerializer = target.contractSerializer;
 	const deserializeWithTargetSerializer = (contractJson) => {
 		return (targetSerializer ?? new SqlContractSerializer()).deserializeContract(contractJson);
@@ -1233,21 +1303,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 +1327,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 +1368,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 +1389,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);
 		},
@@ -1498,7 +1582,7 @@ function convertTable(name, table, storageTypes, expandNativeType, renderDefault
 		name,
 		columns,
 		...ifDefined("primaryKey", table.primaryKey),
-		foreignKeys: table.foreignKeys.map(convertForeignKey),
+		foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map(convertForeignKey),
 		uniques: table.uniques.map(convertUnique),
 		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes]
 	};
@@ -1520,10 +1604,10 @@ function detectDestructiveChanges(from, to) {
 	for (const namespaceId of namespaceIds) {
 		const fromNs = from.namespaces[namespaceId];
 		const toNs = to.namespaces[namespaceId];
-		const fromTables = fromNs?.tables;
+		const fromTables = fromNs?.entries.table;
 		if (!fromTables) continue;
 		for (const tableName of Object.keys(fromTables)) {
-			const toTableRaw = toNs?.tables[tableName];
+			const toTableRaw = toNs?.entries.table[tableName];
 			if (!(toTableRaw instanceof StorageTable)) {
 				conflicts.push({
 					kind: "tableRemoved",
@@ -1563,13 +1647,13 @@ function contractToSchemaIR(contract, options) {
 	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 nsEnums = ns.entries["type"];
+		if (nsEnums) for (const [k, v] of Object.entries(nsEnums)) allTypes[k] = blindCast(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}`);
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table)) {
+		if (!(tableDefRaw instanceof StorageTable)) throw new Error(`contractToSchemaIR: expected StorageTable at 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);
@@ -1604,7 +1688,7 @@ function deriveAnnotations(storage, annotationNamespace, resolveEnumStorageKey)
 		if (isStorageTypeInstance(typeInstance)) storageTypes[typeInstance.nativeType] = typeInstance;
 	}
 	for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
-		const nsEnums = ns.enum;
+		const nsEnums = ns.entries["type"];
 		if (!nsEnums) continue;
 		for (const entry of Object.values(nsEnums)) {
 			if (!isPostgresEnumStorageEntry(entry)) continue;
@@ -1616,6 +1700,176 @@ function deriveAnnotations(storage, annotationNamespace, resolveEnumStorageKey)
 	return { [annotationNamespace]: { storageTypes } };
 }
 //#endregion
+//#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);
+}
+/**
+* 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 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.
+*
+* **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 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 Object.freeze({
+		kept: Object.freeze(kept),
+		warnings: Object.freeze(warnings)
+	});
+}
+/**
+* Partition a list of schema-issue-shaped inputs by the effective control
+* policy of each issue's subject *before* the planner is invoked.
+*
+* `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`).
+*
+* `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.
+*
+* Unresolved-subject issues (`resolveControlPolicySubject` returns
+* `undefined`) emit one warning 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 = [];
+	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 (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));
+	}
+	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
 function planFieldEventOperations(options) {
 	const priorContract = options.priorContract;
@@ -1627,8 +1881,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 +2050,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 +2105,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, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map