@atscript/db 0.1.128 → 0.1.130

package/dist/sync.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_db_view = require("./db-view-C8-MsjND.cjs");
+const require_db_view = require("./db-view-hkwQ-fHJ.cjs");
 //#region src/schema/schema-hash.ts
 /** Extracts sorted field snapshots from a readable's field descriptors. */
 function extractFieldSnapshots(fields, typeMapper) {
@@ -569,7 +569,7 @@ const noColor = {
 	dim: (s) => s,
 	underline: (s) => s
 };
-var SyncEntry = class {
+var SyncEntry = class SyncEntry {
 	name;
 	/** 'V' = virtual view, 'M' = materialized view, 'E' = external view, undefined = table */
 	viewType;
@@ -637,6 +637,19 @@ var SyncEntry = class {
 		return { ...this };
 	}
 	/**
+	* This entry as an `error` entry with `msg` appended to its errors — the
+	* shape a DDL failure inside the entry's step reports (the planned work is
+	* kept, the status says it did not land).
+	* @since 0.1.129
+	*/
+	withError(msg) {
+		return new SyncEntry({
+			...this.toInit(),
+			status: "error",
+			errors: [...this.errors, msg]
+		});
+	}
+	/**
 	* Whether desired work is still pending after this entry — DDL that was
 	* not issued because the entry errored or safe mode skipped it (see
 	* `skipped`). A pending entry withholds its snapshot and the schema hash,
@@ -806,6 +819,79 @@ async function viewDefinitionChanged(view, store) {
 	const currentHash = computeTableHash(computeViewSnapshot(view));
 	return computeTableHash(storedSnapshot) !== currentHash;
 }
+/**
+* The plan entry of one table as `plan()` reports it (and as `run()` reports
+* an entry that issues no DDL): the discovery entry plus `dependsOn`, the
+* key change, and — in safe mode — the destructive parts hidden except the
+* skipped ones, which are pending and shown as skipped.
+*/
+function planTableInit(facts, safe, dependsOn) {
+	const init = {
+		...facts.planEntry,
+		dependsOn
+	};
+	const skipped = safe ? safeModeSkips(facts) : [];
+	const pk = facts.diff?.primaryKeyChanged;
+	if (pk) init.pkChange = {
+		from: pk.from,
+		to: pk.to,
+		rebuild: !skipped.includes("pk-rebuild")
+	};
+	if (!safe) return init;
+	return {
+		...init,
+		columnsToDrop: [],
+		typeChanges: skipped.includes("recreate") ? init.typeChanges : [],
+		skipped: skipped.length > 0 ? skipped : void 0,
+		recreated: false
+	};
+}
+/**
+* How a type change is applied on this table, in the executor's order:
+* `@db.sync.method "drop"` drop-and-recreate, `"recreate"` with data copy,
+* in-place modification (MySQL `MODIFY COLUMN`), or not at all (`"none"` —
+* an `error` entry, see {@link typeChangeErrors}).
+*/
+function typeChangeStrategy(readable, diff) {
+	const adapter = readable.dbAdapter;
+	if (willDropRecreate(readable, diff, void 0)) return "drop";
+	if (readable.syncMethod === "recreate" && adapter.recreateTable) return "recreate";
+	if (adapter.supportsColumnModify && adapter.syncColumns) return "modify";
+	return "none";
+}
+/**
+* The error messages of a type change the adapter cannot apply (strategy
+* `"none"`), one per column: either no `@db.sync.method` is declared, or the
+* declared one needs a primitive this adapter lacks.
+*/
+function typeChangeErrors(readable, diff) {
+	const method = readable.syncMethod;
+	const advice = method ? `@db.sync.method "${method}" is declared but the adapter has no ${method === "recreate" ? "recreateTable" : "dropTable"} — migrate manually.` : `Add @db.sync.method "recreate" or "drop", or migrate manually.`;
+	return diff.typeChanged.map((tc) => `Type change on ${readable.tableName}.${tc.field.physicalName} (${tc.existingType} → ${tc.field.designType}). ${advice}`);
+}
+/** `(a, b → c)` — the key change as the messages print it. */
+function pkLabel(change) {
+	return `(${change.from.join(", ")} → ${change.to.join(", ")})`;
+}
+/** A key rebuild on an adapter with neither `rebuildPrimaryKey` nor `recreateTable`. */
+function pkRebuildUnsupported(name, change) {
+	return `Primary key of "${name}" changed ${pkLabel(change)} but the adapter cannot rebuild primary keys. Migrate manually and re-run.`;
+}
+/**
+* Applies one table's discovered facts: rename → column ops (Path A live
+* introspection, Path B snapshot diff, Path C schema-less) → table options →
+* indexes / foreign keys / `afterSyncTable`. Never called for an entry the
+* plan already marks `error` (`SchemaSync.execute()` reports the plan entry
+* for those without DDL).
+*
+* A statement the engine refuses anywhere in those phases (since 0.1.129)
+* becomes an `error` entry — the plan entry plus `<phase> failed on <table>:
+* <cause>` — and the run goes on with the next table. The entry names the
+* foreign keys already dropped ahead of the failure (by `execute()` step 2
+* for a key-changing parent, or by Path A before the column ops): they stay
+* gone until the next run's `syncForeignKeys` re-adds the ones the model
+* still wants. `renamedFrom` on that entry is set only when the rename ran.
+*/
 async function executeSyncTable(facts, safe, deps, exec) {
 	const { readable, name, storedSnapshot, fkDiff } = facts;
 	const adapter = readable.dbAdapter;
@@ -816,90 +902,104 @@ async function executeSyncTable(facts, safe, deps, exec) {
 		dependsOn: exec.dependsOn
 	};
 	const ensureOpts = exec.deferForeignKeysTo ? { deferForeignKeysTo: exec.deferForeignKeysTo } : void 0;
-	if (facts.pendingRename && adapter.renameTable) {
-		await adapter.renameTable(facts.pendingRename);
-		init.renamedFrom = facts.pendingRename;
-		init.status = "alter";
-	}
-	const hasFkChanges = fkDiff ? hasForeignKeyChanges(fkDiff) : false;
-	if (adapter.getExistingColumns && adapter.syncColumns) {
-		const existing = facts.existing ?? await adapter.getExistingColumns();
-		if (existing.length === 0 && !init.renamedFrom) {
-			await adapter.ensureTable(ensureOpts);
-			init.status = "create";
-		} else if (existing.length > 0) {
-			const diff = facts.diff ?? computeColumnDiff(readable.fieldDescriptors, existing, adapter.typeMapper?.bind(adapter));
-			if (hasFkChanges && !adapter.syncForeignKeys && adapter.recreateTable) {
-				await adapter.recreateTable();
-				init.recreated = true;
-				init.status = "alter";
-				if (diff.primaryKeyChanged) init.pkChange = {
-					...diff.primaryKeyChanged,
-					rebuild: true
-				};
-			} else {
-				if (hasFkChanges && fkDiff && adapter.dropForeignKeys) {
-					const keysToDrop = [...fkDiff.removed.map((fk) => fkKey(fk.fields)), ...fkDiff.changed.map((fk) => fkKey(fk.desired.fields))];
-					if (keysToDrop.length > 0) {
-						await adapter.dropForeignKeys(keysToDrop);
-						init.status = "alter";
+	/** FK keys dropped before the statement that failed — named by the error entry. */
+	const droppedFks = [...exec.preDroppedFks ?? []];
+	let phase = "Rename";
+	try {
+		if (facts.pendingRename && adapter.renameTable) {
+			await adapter.renameTable(facts.pendingRename);
+			init.renamedFrom = facts.pendingRename;
+			init.status = "alter";
+		}
+		phase = "Column sync";
+		const hasFkChanges = fkDiff ? hasForeignKeyChanges(fkDiff) : false;
+		if (adapter.getExistingColumns && adapter.syncColumns) {
+			const existing = facts.existing ?? await adapter.getExistingColumns();
+			if (existing.length === 0 && !init.renamedFrom) {
+				await adapter.ensureTable(ensureOpts);
+				init.status = "create";
+			} else if (existing.length > 0) {
+				const diff = facts.diff ?? computeColumnDiff(readable.fieldDescriptors, existing, adapter.typeMapper?.bind(adapter));
+				if (hasFkChanges && !adapter.syncForeignKeys && adapter.recreateTable) {
+					await adapter.recreateTable();
+					init.recreated = true;
+					init.status = "alter";
+					if (diff.primaryKeyChanged) init.pkChange = {
+						...diff.primaryKeyChanged,
+						rebuild: true
+					};
+				} else {
+					if (hasFkChanges && fkDiff && adapter.dropForeignKeys) {
+						const keysToDrop = [...fkDiff.removed.map((fk) => fkKey(fk.fields)), ...fkDiff.changed.map((fk) => fkKey(fk.desired.fields))];
+						if (keysToDrop.length > 0) {
+							await adapter.dropForeignKeys(keysToDrop);
+							droppedFks.push(...keysToDrop);
+							init.status = "alter";
+						}
 					}
+					await applyColumnDiff(adapter, readable, diff, init, safe, deps.logger, ensureOpts);
 				}
-				await applyColumnDiff(adapter, readable, diff, init, safe, deps.logger, ensureOpts);
 			}
-		}
-	} else if (adapter.syncColumns) if (!storedSnapshot) {
-		const existed = adapter.tableExists ? await adapter.tableExists() : false;
-		await adapter.ensureTable(ensureOpts);
-		if (!existed) init.status = "create";
-	} else await applyColumnDiff(adapter, readable, facts.diff ?? computeColumnDiff(readable.fieldDescriptors, snapshotToExistingColumns(storedSnapshot), deps.resolveTypeMapper(adapter)), init, safe, deps.logger, ensureOpts);
-	else {
-		const existed = adapter.tableExists ? await adapter.tableExists() : true;
-		if (!init.recreated) {
+		} else if (adapter.syncColumns) if (!storedSnapshot) {
+			const existed = adapter.tableExists ? await adapter.tableExists() : false;
 			await adapter.ensureTable(ensureOpts);
 			if (!existed) init.status = "create";
+		} else await applyColumnDiff(adapter, readable, facts.diff ?? computeColumnDiff(readable.fieldDescriptors, snapshotToExistingColumns(storedSnapshot), deps.resolveTypeMapper(adapter)), init, safe, deps.logger, ensureOpts);
+		else {
+			const existed = adapter.tableExists ? await adapter.tableExists() : true;
+			if (!init.recreated) {
+				await adapter.ensureTable(ensureOpts);
+				if (!existed) init.status = "create";
+			}
 		}
-	}
-	const optionDiff = facts.optionDiff;
-	if (init.status !== "create" && !init.recreated && init.status !== "error" && optionDiff && optionDiff.changed.length > 0) {
-		const hasDestructive = optionDiff.changed.some((c) => c.destructive);
-		if (safe) {
-			if (hasDestructive) {
+		phase = "Table option sync";
+		const optionDiff = facts.optionDiff;
+		if (init.status !== "create" && !init.recreated && init.status !== "error" && optionDiff && optionDiff.changed.length > 0) {
+			const hasDestructive = optionDiff.changed.some((c) => c.destructive);
+			if (safe) {
+				if (hasDestructive) {
+					init.optionChanges = optionDiff.changed;
+					init.status = "alter";
+					markSkipped(init, "table-options");
+					deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — recreate skipped (safe mode)`);
+				}
+			} else {
 				init.optionChanges = optionDiff.changed;
-				init.status = "alter";
-				markSkipped(init, "table-options");
-				deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — recreate skipped (safe mode)`);
-			}
-		} else {
-			init.optionChanges = optionDiff.changed;
-			const nonDestructive = optionDiff.changed.filter((c) => !c.destructive);
-			if (nonDestructive.length > 0 && adapter.applyTableOptions) {
-				await adapter.applyTableOptions(nonDestructive);
-				init.status = "alter";
-			}
-			if (hasDestructive) {
-				if (willDropRecreate(readable, void 0, optionDiff)) {
-					deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — dropping and recreating`);
-					await dropAndRecreate(adapter, init, name, deps.logger, ensureOpts);
-				} else if (readable.syncMethod === "recreate" && adapter.recreateTable) {
-					deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — recreating with data preservation`);
-					await adapter.recreateTable();
+				const nonDestructive = optionDiff.changed.filter((c) => !c.destructive);
+				if (nonDestructive.length > 0 && adapter.applyTableOptions) {
+					await adapter.applyTableOptions(nonDestructive);
 					init.status = "alter";
-					init.recreated = true;
+				}
+				if (hasDestructive) {
+					if (willDropRecreate(readable, void 0, optionDiff)) {
+						deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — dropping and recreating`);
+						await dropAndRecreate(adapter, init, name, ensureOpts);
+					} else if (readable.syncMethod === "recreate" && adapter.recreateTable) {
+						deps.logger.warn?.(`[schema-sync] Destructive table option change on "${name}" — recreating with data preservation`);
+						await adapter.recreateTable();
+						init.status = "alter";
+						init.recreated = true;
+					}
 				}
 			}
 		}
-	}
-	if (init.status === "error") return new SyncEntry(init);
-	try {
+		if (init.status === "error") return new SyncEntry(init);
+		phase = "Index/FK sync";
 		await adapter.syncIndexes();
 		if (adapter.syncForeignKeys && !exec.deferForeignKeysTo) await adapter.syncForeignKeys();
 		if (adapter.afterSyncTable) await adapter.afterSyncTable();
 	} catch (error) {
-		const msg = `Index/FK sync failed on ${name}: ${error.message}`;
+		const dropped = droppedFks.length > 0 ? ` Dropped foreign keys before the failure: ${droppedFks.join(", ")} — the ones still in the model are re-added by the next run's syncForeignKeys.` : "";
+		const msg = `${phase} failed on ${name}: ${error.message}${dropped}`;
 		deps.logger.error?.(`[schema-sync] ${msg}`);
-		init.errors = [...init.errors ?? [], msg];
-		init.status = "error";
+		const planned = planTableInit(facts, safe, exec.dependsOn);
+		return new SyncEntry({
+			...planned,
+			status: "error",
+			errors: [...planned.errors ?? [], msg],
+			renamedFrom: init.renamedFrom,
+			recreated: false
+		});
 	}
 	return new SyncEntry(init);
 }
@@ -918,11 +1018,7 @@ async function executeDeferredForeignKeys(readable, entry, deps) {
 	} catch (error) {
 		const msg = `FK sync failed on ${readable.tableName}: ${error.message}`;
 		deps.logger.error?.(`[schema-sync] ${msg}`);
-		return new SyncEntry({
-			...entry.toInit(),
-			status: "error",
-			errors: [...entry.errors, msg]
-		});
+		return entry.withError(msg);
 	}
 }
 /** Determines whether a view's predecessor (on rename) or stale definition must be dropped. */
@@ -1000,12 +1096,9 @@ function safeModeSkips(facts) {
 	const out = [];
 	if (facts.planEntry.status === "error") return out;
 	if (fkDiff && hasForeignKeyChanges(fkDiff) && !adapter.syncForeignKeys && adapter.recreateTable) return out;
-	let recreated = false;
-	if (diff && diff.typeChanged.length > 0) {
-		if (willDropRecreate(readable, diff, void 0)) out.push("recreate");
-		else if (readable.syncMethod === "recreate" && adapter.recreateTable) recreated = true;
-	}
-	if (recreated) return out;
+	const strategy = diff && diff.typeChanged.length > 0 ? typeChangeStrategy(readable, diff) : "modify";
+	if (strategy === "drop") out.push("recreate");
+	else if (strategy === "recreate") return out;
 	if (diff && (diff.nullableChanged.length > 0 || diff.defaultChanged.length > 0) && needsDdlForNullableDefaults(adapter)) out.push("nullable-defaults");
 	if (diff?.primaryKeyChanged) out.push("pk-rebuild");
 	if (optionDiff?.changed.some((c) => c.destructive)) out.push("table-options");
@@ -1029,21 +1122,18 @@ function describeNullableDefaults(diff) {
 * `dropTable()` + `ensureTable()` for `@db.sync.method "drop"` and destructive
 * option changes. Sync-owned drops never CASCADE: when something outside the
 * sync inventory (a user view, an unmanaged FK) still depends on the table the
-* engine refuses, and that becomes an error entry for this table — not a
-* thrown run.
+* engine refuses — rethrown as `Drop of "<table>" failed: <cause>` for the
+* executor's phase catch, which makes it the table's error entry.
 */
-async function dropAndRecreate(adapter, init, name, logger, ensureOpts) {
+async function dropAndRecreate(adapter, init, name, ensureOpts) {
 	try {
 		await adapter.dropTable();
 		await adapter.ensureTable(ensureOpts);
-		init.recreated = true;
-		init.status = "alter";
 	} catch (error) {
-		const msg = `Drop of "${name}" failed: ${error.message}`;
-		logger.error?.(`[schema-sync] ${msg}`);
-		init.errors = [...init.errors ?? [], msg];
-		init.status = "error";
+		throw new Error(`Drop of "${name}" failed: ${error.message}`, { cause: error });
 	}
+	init.recreated = true;
+	init.status = "alter";
 }
 async function applyColumnDiff(adapter, readable, diff, init, safe, logger, ensureOpts) {
 	const name = readable.tableName;
@@ -1055,28 +1145,24 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger, ensu
 	}
 	let needsSyncColumns = false;
 	if (diff.typeChanged.length > 0 && init.status !== "error") {
-		const syncMethod = readable.syncMethod;
-		if (willDropRecreate(readable, diff, void 0)) if (safe) {
+		const strategy = typeChangeStrategy(readable, diff);
+		if (strategy === "drop") if (safe) {
 			init.typeChanges = describeTypeChanges(diff);
 			markSkipped(init, "recreate");
 			init.status = "alter";
 			const cols = init.typeChanges.map((tc) => `${tc.column}: ${tc.fromType} → ${tc.toType}`).join(", ");
 			logger.warn?.(`[schema-sync] Type change on "${name}" (${cols}) — drop-and-recreate skipped (safe mode)`);
-		} else await dropAndRecreate(adapter, init, name, logger, ensureOpts);
-		else if (syncMethod === "recreate" && adapter.recreateTable) {
+		} else await dropAndRecreate(adapter, init, name, ensureOpts);
+		else if (strategy === "recreate") {
 			await adapter.recreateTable();
 			init.recreated = true;
 			init.status = "alter";
-		} else if (adapter.supportsColumnModify && adapter.syncColumns) {
+		} else if (strategy === "modify") {
 			needsSyncColumns = true;
 			init.status = "alter";
 		} else {
-			const errors = [];
-			for (const change of diff.typeChanged) {
-				const msg = `Type change on ${name}.${change.field.physicalName} (${change.existingType} → ${change.field.designType}). Add @db.sync.method "recreate" or "drop", or migrate manually.`;
-				logger.error?.(`[schema-sync] ${msg}`);
-				errors.push(msg);
-			}
+			const errors = typeChangeErrors(readable, diff);
+			for (const msg of errors) logger.error?.(`[schema-sync] ${msg}`);
 			init.errors = errors;
 			init.status = "error";
 		}
@@ -1107,14 +1193,13 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger, ensu
 	}
 	if (diff.primaryKeyChanged && init.status !== "error") {
 		const { from, to } = diff.primaryKeyChanged;
-		const label = `(${from.join(", ")} → ${to.join(", ")})`;
 		if (init.recreated) init.pkChange = {
 			from,
 			to,
 			rebuild: true
 		};
 		else if (safe) {
-			logger.warn?.(`[schema-sync] Primary key of "${name}" changed ${label} — rebuild skipped (safe mode)`);
+			logger.warn?.(`[schema-sync] Primary key of "${name}" changed ${pkLabel(diff.primaryKeyChanged)} — rebuild skipped (safe mode)`);
 			init.pkChange = {
 				from,
 				to,
@@ -1138,7 +1223,7 @@ async function applyColumnDiff(adapter, readable, diff, init, safe, logger, ensu
 			};
 			init.status = "alter";
 		} else {
-			const msg = `Primary key of "${name}" changed ${label} but the adapter cannot rebuild primary keys. Migrate manually and re-run.`;
+			const msg = pkRebuildUnsupported(name, diff.primaryKeyChanged);
 			logger.error?.(`[schema-sync] ${msg}`);
 			init.errors = [...init.errors ?? [], msg];
 			init.status = "error";
@@ -1167,9 +1252,6 @@ function buildFkChangeDetails(desired, existing) {
 	if ((existing.onUpdate ?? void 0) !== (desired.onUpdate ?? void 0)) parts.push(`onUpdate ${existing.onUpdate ?? "noAction"} → ${desired.onUpdate ?? "noAction"}`);
 	return parts.join(", ");
 }
-function pkLabel(change) {
-	return `(${change.from.join(", ")} → ${change.to.join(", ")})`;
-}
 function sortedUnique(names) {
 	return [...new Set(names)].toSorted();
 }
@@ -1428,7 +1510,7 @@ var SchemaSync = class {
 		const trackedNames = new Set(previouslyTracked.map((e) => e.name));
 		const removedTracked = this.detectRemoved(allReadables, previouslyTracked);
 		const probeRecreateInbound = !safe && removedTracked.some((r) => !r.isView);
-		const tableFacts = await Promise.all(tables.map((r) => this.discoverTable(r, trackedNames, probeRecreateInbound)));
+		const tableFacts = await Promise.all(tables.map((r) => this.discoverTable(r, trackedNames, probeRecreateInbound, safe)));
 		const tableNames = new Set(tableFacts.map((t) => t.name));
 		const tableByName = new Map(tableFacts.map((t) => [t.name, t]));
 		const tableByDbName = new Map(tableFacts.map((t) => [t.dbName, t]));
@@ -1540,8 +1622,9 @@ var SchemaSync = class {
 	* Introspects one desired table and computes its plan entry.
 	* `probeRecreateInbound` — whether a drop-and-recreate's live inbound FKs
 	* are worth probing (a removed table exists that could block it).
+	* `safe` — safe mode skips the key rebuild, so its plan rule does not apply.
 	*/
-	async discoverTable(readable, trackedNames, probeRecreateInbound) {
+	async discoverTable(readable, trackedNames, probeRecreateInbound, safe) {
 		const adapter = readable.dbAdapter;
 		const name = readable.tableName;
 		const init = {
@@ -1576,7 +1659,7 @@ var SchemaSync = class {
 			} else if (facts.existing && facts.existing.length > 0) {
 				const typeMapper = adapter.typeMapper?.bind(adapter);
 				facts.diff = computeColumnDiff(readable.fieldDescriptors, facts.existing, typeMapper);
-				this.populatePlanFromDiff(facts.diff, init, name, readable.syncMethod, adapter.supportsColumnModify);
+				this.populatePlanFromDiff(facts.diff, init, readable, safe);
 			}
 		} else if (adapter.syncColumns) if (!storedSnapshot) {
 			if (!pendingRename) {
@@ -1588,7 +1671,7 @@ var SchemaSync = class {
 		} else {
 			const existing = snapshotToExistingColumns(storedSnapshot);
 			facts.diff = computeColumnDiff(readable.fieldDescriptors, existing, this.resolveTypeMapper(adapter));
-			this.populatePlanFromDiff(facts.diff, init, name, readable.syncMethod, adapter.supportsColumnModify);
+			this.populatePlanFromDiff(facts.diff, init, readable, safe);
 		}
 		else if (adapter.tableExists) {
 			if (!await adapter.tableExists()) init.status = "create";
@@ -1639,10 +1722,17 @@ var SchemaSync = class {
 				if (t.populated === true) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the table has rows; schema sync cannot rebuild a populated primary key. Migrate manually (or empty the table) and re-run.`);
 				else if (t.populated === "unknown") addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the adapter cannot tell whether the table has rows under its old name "${t.dbName}" — implement hasRows(tableName) on the adapter, or rename the table in a separate run first.`);
 				if (!safe) {
-					for (const fk of t.inboundFks ?? []) {
+					const liveInbound = (t.inboundFks ?? []).filter((fk) => {
 						const removed = d.removedByName.get(fk.table);
-						if (removed && !removed.isView) continue;
+						return !(removed && !removed.isView);
+					});
+					if (t.planEntry.status === "error" && liveInbound.length > 0) addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the table's own entry has errors — fix them and re-run: ${t.planEntry.errors?.[0] ?? "see its entry"}`);
+					for (const fk of liveInbound) {
 						const child = d.tableByDbName.get(fk.table);
+						if (child?.planEntry.status === "error") {
+							addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the referencing table "${child.name}" has errors — fix them and re-run: ${child.planEntry.errors?.[0] ?? "see its entry"}`);
+							continue;
+						}
 						if (child?.pendingRename) {
 							addRefusal(refusals, t.name, `Primary key of "${t.name}" changed ${label} but the referencing table "${child.name}" is renamed in the same run (from "${child.pendingRename}") — rename it in a separate run first, then retarget the foreign key and re-run.`);
 							continue;
@@ -1719,25 +1809,7 @@ var SchemaSync = class {
 				break;
 			case "table": {
 				const t = d.tableByName.get(step.name);
-				let init = {
-					...t.planEntry,
-					dependsOn: d.tableDependsOn.get(step.name)
-				};
-				const skipped = safe ? safeModeSkips(t) : [];
-				const pk = t.diff?.primaryKeyChanged;
-				if (pk) init.pkChange = {
-					from: pk.from,
-					to: pk.to,
-					rebuild: !skipped.includes("pk-rebuild")
-				};
-				if (safe) init = {
-					...init,
-					columnsToDrop: [],
-					typeChanges: skipped.includes("recreate") ? init.typeChanges : [],
-					skipped: skipped.length > 0 ? skipped : void 0,
-					recreated: false
-				};
-				entries.push(withRefusals(init, refusals.get(step.name)));
+				entries.push(withRefusals(planTableInit(t, safe, d.tableDependsOn.get(step.name)), refusals.get(step.name)));
 				break;
 			}
 			case "deferred-fks": break;
@@ -1760,7 +1832,28 @@ var SchemaSync = class {
 		/** Removed entries that were NOT dropped — they stay tracked (I2). */
 		const retained = [];
 		const droppedNames = /* @__PURE__ */ new Set();
-		for (const view of d.views) await dropOutdatedView(view, d.viewPlans.get(view.tableName), this.space);
+		/** Managed views whose stale definition could not be dropped (→ error entry, not recreated). */
+		const failedViews = /* @__PURE__ */ new Map();
+		/**
+		* Pending renames that did NOT run (the rename failed, or the entry
+		* issued no DDL): the object still exists under its old name, so it stays
+		* tracked there and keeps its old-name snapshot — the next run sees the
+		* rename as pending again. Keyed by the readable's (new) name.
+		*/
+		const stillUnderOldName = /* @__PURE__ */ new Map();
+		for (const view of d.views) {
+			const plan = d.viewPlans.get(view.tableName);
+			try {
+				await dropOutdatedView(view, plan, this.space);
+			} catch (error) {
+				failedViews.set(view.tableName, this.stepFailed(error, "View sync", view.tableName));
+				if (plan.isRenamed) stillUnderOldName.set(view.tableName, {
+					name: view.renamedFrom,
+					isView: true,
+					viewType: view.viewPlan.materialized ? "M" : "V"
+				});
+			}
+		}
 		const droppedViewEntries = /* @__PURE__ */ new Map();
 		for (const r of d.removed) {
 			if (!r.isView) continue;
@@ -1784,11 +1877,19 @@ var SchemaSync = class {
 				retained.push(r);
 			}
 		}
+		/** FK keys dropped here per child (by its name) — named by a later failure on that child. */
+		const preDroppedFks = /* @__PURE__ */ new Map();
 		if (!safe) for (const t of d.tables) {
 			if (!t.diff?.primaryKeyChanged) continue;
 			const keysByChild = /* @__PURE__ */ new Map();
 			for (const fk of t.inboundFks ?? []) keysByChild.set(fk.table, [...keysByChild.get(fk.table) ?? [], fkKey(fk.fields)]);
-			for (const [childName, fkKeys] of keysByChild) await d.tableByDbName.get(childName)?.readable.dbAdapter.dropForeignKeys?.(fkKeys);
+			for (const [childName, fkKeys] of keysByChild) {
+				const child = d.tableByDbName.get(childName);
+				if (child?.readable.dbAdapter.dropForeignKeys) {
+					await child.readable.dbAdapter.dropForeignKeys(fkKeys);
+					preDroppedFks.set(child.name, [...preDroppedFks.get(child.name) ?? [], ...fkKeys]);
+				}
+			}
 		}
 		const deferred = [];
 		const drops = {
@@ -1805,9 +1906,16 @@ var SchemaSync = class {
 					break;
 				case "table": {
 					const t = d.tableByName.get(step.name);
-					const entry = await executeSyncTable(t, safe, deps, {
+					const dependsOn = d.tableDependsOn.get(step.name);
+					const entry = t.planEntry.status === "error" ? new SyncEntry(planTableInit(t, safe, dependsOn)) : await executeSyncTable(t, safe, deps, {
 						deferForeignKeysTo: step.cycle,
-						dependsOn: d.tableDependsOn.get(step.name)
+						dependsOn,
+						preDroppedFks: preDroppedFks.get(t.name)
+					});
+					const renamed = t.planEntry.status !== "error" && entry.renamedFrom !== void 0;
+					if (t.pendingRename && !renamed) stillUnderOldName.set(t.name, {
+						name: t.pendingRename,
+						isView: false
 					});
 					if (step.cycle) deferred.push({
 						readable: t.readable,
@@ -1822,9 +1930,19 @@ var SchemaSync = class {
 						entries[index] = await executeDeferredForeignKeys(readable, entries[index], deps);
 					}
 					break;
-				case "view":
-					entries.push(await executeSyncView(d.views[step.index], d.viewEntries[step.index]));
+				case "view": {
+					const view = d.views[step.index];
+					const planned = d.viewEntries[step.index];
+					let msg = failedViews.get(view.tableName);
+					if (msg === void 0) try {
+						entries.push(await executeSyncView(view, planned));
+						break;
+					} catch (error) {
+						msg = this.stepFailed(error, "View sync", view.tableName);
+					}
+					entries.push(planned.withError(msg));
 					break;
+				}
 				case "external":
 					entries.push(d.externalEntries[step.index]);
 					break;
@@ -1851,8 +1969,8 @@ var SchemaSync = class {
 			await this.store.writeTableSnapshot(readable.tableName, snapshot);
 		}
 		for (const name of droppedNames) await this.store.deleteTableSnapshot(name);
-		for (const readable of allReadables) if (readable.renamedFrom) await this.store.deleteTableSnapshot(readable.renamedFrom);
-		await this.store.writeTrackedList(allReadables, retained);
+		for (const readable of allReadables) if (readable.renamedFrom && !stillUnderOldName.has(readable.tableName)) await this.store.deleteTableSnapshot(readable.renamedFrom);
+		await this.store.writeTrackedList(allReadables.filter((r) => !stillUnderOldName.has(r.tableName)), [...retained, ...stillUnderOldName.values()]);
 		if (pendingNames.size === 0) await this.store.writeHash(hash);
 		return {
 			status: "synced",
@@ -1898,6 +2016,12 @@ var SchemaSync = class {
 		for (const name of group) droppedNames.add(name);
 		return group.map((name) => d.dropEntries.get(name));
 	}
+	/** The error-entry message of a DDL failure inside a view step, logged at error level. */
+	stepFailed(error, phase, name) {
+		const msg = `${phase} failed on ${name}: ${error.message}`;
+		this.logger.error?.(`[schema-sync] ${msg}`);
+		return msg;
+	}
 	/**
 	* Surfaces the run outcome per the `onError` policy. Reporting must never be
 	* silently lost to the NoopLogger default — when no real logger is
@@ -1953,8 +2077,17 @@ var SchemaSync = class {
 	}
 	/**
 	* Populates plan init from a column diff (shared by Path A and Path B).
+	*
+	* The plan's rule set is canonical (since 0.1.129): every change the
+	* executor cannot apply without DDL it does not have is an `error` entry
+	* here, and `executeSyncTable` returns an errored plan entry untouched —
+	* so the executor's own copies of these rules are reached only when
+	* discovery had no diff (a pending rename whose old name it could not
+	* introspect).
 	*/
-	populatePlanFromDiff(diff, init, name, syncMethod, adapterSupportsModify) {
+	populatePlanFromDiff(diff, init, readable, safe) {
+		const name = readable.tableName;
+		const adapter = readable.dbAdapter;
 		init.columnsToAdd = diff.added;
 		init.columnsToRename = diff.renamed.map((r) => ({
 			from: r.oldName,
@@ -1968,9 +2101,13 @@ var SchemaSync = class {
 			init.status = "error";
 			init.errors = [...init.errors ?? [], ...diff.conflicts.map((c) => `Column rename conflict on ${name}: cannot rename "${c.oldName}" → "${c.field.physicalName}" because "${c.conflictsWith}" already exists.`)];
 		}
-		if (diff.typeChanged.length > 0 && !syncMethod && !adapterSupportsModify) {
+		if (diff.typeChanged.length > 0 && typeChangeStrategy(readable, diff) === "none") {
+			init.status = "error";
+			init.errors = [...init.errors ?? [], ...typeChangeErrors(readable, diff)];
+		}
+		if (diff.primaryKeyChanged && !safe && !adapter.rebuildPrimaryKey && !adapter.recreateTable && init.status !== "error") {
 			init.status = "error";
-			init.errors = [...init.errors ?? [], ...diff.typeChanged.map((tc) => `Type change on ${name}.${tc.field.physicalName} (${tc.existingType} → ${tc.field.designType}). Add @db.sync.method "recreate" or "drop", or migrate manually.`)];
+			init.errors = [...init.errors ?? [], pkRebuildUnsupported(name, diff.primaryKeyChanged)];
 		}
 	}
 	/**