@tailor-platform/sdk 2.2.0 → 2.3.0

package/dist/{register-ts-hook-CTth1eqj.mjs → register-ts-hook-ClI226n2.mjs}

@@ -1,13 +1,14 @@
 import { t as db } from "./schema--xYWRGfe.mjs";
+import { t as beginWaitPointScope } from "./wait-point-registry-TL99zotw.mjs";
 import { $ as CreateAuthHookRequestSchema, B as IdPLang, Bt as ApplicationSchemaUpdateAttemptStatus, C as CreateStaticWebsiteRequestSchema, Ct as AuthInvokerSchema, D as CreateSecretManagerSecretRequestSchema, Dt as AuthSCIMAttribute_Type, Et as AuthSCIMAttribute_Mutability, H as IdPPermissionPermit, Ht as CreateAIGatewayRequestSchema, I as PipelineResolver_OperationType, It as CreateApplicationRequestSchema, Jt as Condition_Operator, K as CreateExecutorExecutorRequestSchema, L as CreateIdPServiceRequestSchema, Lt as GetApplicationSchemaHealthResponse_ApplicationSchemaHealthStatus, M as CreatePipelineServiceRequestSchema, Mt as UserProfileProviderConfig_UserProfileProviderType, N as UpdatePipelineResolverRequestSchema, O as CreateSecretManagerVaultRequestSchema, Ot as AuthSCIMAttribute_Uniqueness, P as UpdatePipelineServiceRequestSchema, Q as CreateAuthConnectionRequestSchema, R as UpdateIdPServiceRequestSchema, Rt as UpdateApplicationRequestSchema, S as AddCustomDomainRequestSchema, St as AuthIDPConfig_AuthType, Tt as AuthOAuth2Client_GrantType, U as FunctionExecution_Status, Ut as UpdateAIGatewayRequestSchema, V as IdPPermissionOperator, Vt as Subgraph_ServiceType, X as ExecutorTargetType, Xt as PageDirection, Y as ExecutorJobStatus, Yt as FilterSchema, Z as ExecutorTriggerType, _ as TailorDBGQLPermission_Permit, _t as UpdateUserProfileConfigRequestSchema, a as CreateWorkflowRequestSchema, at as CreateAuthServiceRequestSchema, b as TailorDBType_Permission_Permit, bt as AuthConnection_Type, ct as UpdateAuthConnectionRequestSchema, d as CreateTailorDBServiceRequestSchema, dt as UpdateAuthMachineUserRequestSchema, et as CreateAuthIDPConfigRequestSchema, f as CreateTailorDBTypeRequestSchema, ft as UpdateAuthOAuth2ClientRequestSchema, g as TailorDBGQLPermission_Operator, gt as UpdateTenantConfigRequestSchema, h as TailorDBGQLPermission_Action, ht as UpdateAuthServiceRequestSchema, i as CreateWorkflowJobFunctionRequestSchema, it as CreateAuthSCIMResourceRequestSchema, j as CreatePipelineResolverRequestSchema, jt as TenantProviderConfig_TenantProviderType, k as UpdateSecretManagerSecretRequestSchema, kt as AuthSCIMConfig_AuthorizationType, l as WorkflowExecution_Status, lt as UpdateAuthHookRequestSchema, mt as UpdateAuthSCIMResourceRequestSchema, nt as CreateAuthOAuth2ClientRequestSchema, o as UpdateWorkflowJobFunctionExecutionPolicyRequestSchema, ot as CreateTenantConfigRequestSchema, p as UpdateTailorDBTypeRequestSchema, pt as UpdateAuthSCIMConfigRequestSchema, q as UpdateExecutorExecutorRequestSchema, qt as ConditionSchema, r as CreateWorkflowJobFunctionExecutionPolicyRequestSchema, rt as CreateAuthSCIMConfigRequestSchema, s as UpdateWorkflowRequestSchema, st as CreateUserProfileConfigRequestSchema, t as WorkspacePlatformUserRole, tt as CreateAuthMachineUserRequestSchema, u as WorkflowJobExecution_Status, ut as UpdateAuthIDPConfigRequestSchema, v as TailorDBTypeSchema, w as UpdateStaticWebsiteRequestSchema, wt as AuthOAuth2Client_ClientType, x as TailorDBType_PermitAction, xt as AuthHookPoint, y as TailorDBType_Permission_Operator, yt as AuthConnection_Status } from "./workspace_resource_pb-HNIL_Vfj.mjs";
 import { t as assertDefined } from "./assert-DBxo8jPo.mjs";
 import { a as parseBoolean, i as symbols, n as logger, o as renderTable, r as styles, s as renderFor, t as CIPromptError } from "./logger-DSdExfor.mjs";
-import { $ as createApplyLimiter, A as getDistDir, B as fetchUserInfo, D as getPluginGenerationDependencies, E as createBundleLog, F as fetchAll, G as initOAuth2Client, H as getOAuth2ClientId, I as fetchAllTolerant, J as isNotFoundError, K as initOperatorClient, L as fetchMachineUserToken, M as hashFile, O as hasGenerationHooks, P as defaultPlatformBaseUrl, Q as byName, R as fetchPaged, S as platformBundleDefinePlugin, U as getOrNull, V as getConsoleBaseUrl, W as getPlatformBaseUrl, X as rememberPlatformConfigForToken, Y as normalizeBaseUrl, Z as resolveStaticWebsiteUrls, _ as assertUniqueTailorDBTypeNamesWithExternal, b as createTsconfigPathsPlugin, d as HTTP_METHODS, et as LOG_LEVELS, g as assertUniqueLocalTailorDBTypeNames, i as resolverBundleKey, j as hashContent, k as createBundleCache, m as buildResolverOperationHookExpr, n as generatePluginFilesIfNeeded, o as getApplicationAuthNamespace, p as buildExecutorArgsExpr, q as isDefaultPlatform, r as loadApplication, s as WorkflowJobFunctionExecutionPolicySchema, t as defineApplication, v as stringifyFunction, x as resolveTSConfigWithFallback, y as createGeneratedEntryResolverPlugin } from "./application-BpLeawBg.mjs";
-import { c as stripTailorDBTypeBuilderHelpers, g as functionSchema, h as loadFilesWithIgnores, t as createExecutorService, u as TailorDBTypeSchema$1 } from "./service-goqlJJgA.mjs";
+import { $ as resolveStaticWebsiteUrls, A as hasGenerationHooks, B as fetchPaged, C as resolveTSConfigWithFallback, G as getOrNull, H as fetchUserInfo, I as defaultPlatformBaseUrl, J as initOperatorClient, K as getPlatformBaseUrl, L as fetchAll, M as getDistDir, N as hashContent, O as createBundleLog, P as hashFile, Q as rememberPlatformConfigForToken, R as fetchAllTolerant, S as createTsconfigPathsPlugin, U as getConsoleBaseUrl, W as getOAuth2ClientId, X as isNotFoundError, Y as isDefaultPlatform, Z as normalizeBaseUrl, _ as assertUniqueTailorDBTypeNamesWithExternal, b as tailorPrincipalMap, d as HTTP_METHODS, et as byName, g as assertUniqueLocalTailorDBTypeNames, i as resolverBundleKey, j as createBundleCache, k as getPluginGenerationDependencies, m as buildResolverOperationHookExpr, n as generatePluginFilesIfNeeded, nt as LOG_LEVELS, o as getApplicationAuthNamespace, p as buildExecutorArgsExpr, q as initOAuth2Client, r as loadApplication, s as WorkflowJobFunctionExecutionPolicySchema, t as defineApplication, tt as createApplyLimiter, v as PRINCIPAL_VAR, w as platformBundleDefinePlugin, x as createGeneratedEntryResolverPlugin, y as stringifyFunction, z as fetchMachineUserToken } from "./application-F-nl107y.mjs";
+import { _ as beginUserModuleRun, b as functionSchema, c as stripTailorDBTypeBuilderHelpers, g as IMPORT_NONCE_PARAM, h as loadFilesWithIgnores, t as createExecutorService, u as TailorDBTypeSchema$1, v as currentImportNonce } from "./service-C_WpbKHu.mjs";
 import { t as multiline } from "./multiline-sfHpTZZK.mjs";
 import { t as readPackageJson } from "./package-json-8b0O9TlX.mjs";
 import { t as userAgent } from "./user-agent-Bgsszb5I.mjs";
-import { i as isCLIError, n as formatCopyableCommand, t as createCLIError } from "./errors-CWj21238.mjs";
+import { a as typeOnlyImportHint, i as isCLIError, n as formatCopyableCommand, t as createCLIError } from "./errors-BVb6vYGy.mjs";
 import { n as tightenSecretFilePermissions, r as writeSecretFile } from "./secret-file-C3J4Gy8r.mjs";
 import { r as withSpan } from "./telemetry-BRVdwh14.mjs";
 import { a as generateIdpTruncateScriptCode, i as generateIdpSeedScriptCode, o as processIdpUser, r as processLinesDb, t as SeedGeneratorID } from "./seed-xqM9WIHP.mjs";
@@ -1375,7 +1376,8 @@ async function loadConfig(configPath, options = {}) {
 	const resolvedPath = path.resolve(process.cwd(), foundPath);
 	if (!fs$2.existsSync(resolvedPath)) throw new Error(`Configuration file not found: ${configPath}`);
 	const configUrl = pathToFileURL(resolvedPath);
-	if (options.importNonce) configUrl.searchParams.set("tailorImportNonce", options.importNonce);
+	const importNonce = options.importNonce ?? currentImportNonce();
+	if (importNonce) configUrl.searchParams.set(IMPORT_NONCE_PARAM, importNonce);
 	const configModule = await import(configUrl.href);
 	if (!configModule || !configModule.default) throw new Error("Invalid Tailor config module: default export not found");
 	const validated = AppConfigSchema.safeParse(configModule.default);
@@ -2421,9 +2423,9 @@ function toComparableProtoJson(schema, value) {
 * @param value - Value to serialize
 * @returns Stable serialized string
 */
-function stableStringify(value) {
-	if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : stableStringify(item)).join(",")}]`;
-	if (value && typeof value === "object") return `{${Object.entries(value).filter(([key, entryValue]) => key !== "$typeName" && entryValue !== void 0).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+function stableStringify$1(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => item === void 0 ? "null" : stableStringify$1(item)).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).filter(([key, entryValue]) => key !== "$typeName" && entryValue !== void 0).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify$1(entryValue)}`).join(",")}}`;
 	if (typeof value === "bigint") return JSON.stringify(value.toString());
 	return JSON.stringify(value);
 }
@@ -2434,7 +2436,7 @@ function stableStringify(value) {
 */
 function normalizeProtoConfig(value) {
 	if (value === void 0 || value === null) return value;
-	return JSON.parse(stableStringify(value));
+	return JSON.parse(stableStringify$1(value));
 }
 /**
 * Sort a string array for order-insensitive comparison.
@@ -2451,7 +2453,7 @@ function normalizeStringArray(values) {
 * @returns True when normalized values are equal
 */
 function areNormalizedEqual(left, right) {
-	return stableStringify(normalizeProtoConfig(left)) === stableStringify(normalizeProtoConfig(right));
+	return stableStringify$1(normalizeProtoConfig(left)) === stableStringify$1(normalizeProtoConfig(right));
 }
 
 //#endregion
@@ -7435,13 +7437,17 @@ function buildValidateStatements(fields, accessExpr, keyPrefix) {
 	}
 	return statements;
 }
+function principalDeclIfReferenced(...exprs) {
+	return exprs.some((expr) => expr?.includes("_principal")) ? ` const ${PRINCIPAL_VAR} = (${tailorPrincipalMap});` : "";
+}
 function wrapHook(objectExpr) {
-	return `((_invoker) => { const ${NOW} = new Date(); return ${objectExpr}; })(typeof _invoker !== "undefined" ? _invoker : undefined)`;
+	return `((_invoker) => { const ${NOW} = new Date();${principalDeclIfReferenced(objectExpr)} return ${objectExpr}; })(typeof _invoker !== "undefined" ? _invoker : undefined)`;
 }
 function wrapValidate(statements, typeValidateExpr) {
 	const issuesFn = typeValidateExpr ? " const __issues = (f, m) => { __errs[f] = m; };" : "";
+	const principalDecl = principalDeclIfReferenced(typeValidateExpr, ...statements);
 	const typeValidateStmt = typeValidateExpr ? ` ${typeValidateExpr};` : "";
-	return `((_invoker) => { const __errs = {};${issuesFn}\n${statements.join("\n")}${typeValidateStmt}\nreturn __errs; })(typeof _invoker !== "undefined" ? _invoker : undefined)`;
+	return `((_invoker) => { const __errs = {};${issuesFn}${principalDecl}\n${statements.join("\n")}${typeValidateStmt}\nreturn __errs; })(typeof _invoker !== "undefined" ? _invoker : undefined)`;
 }
 /**
 * Aggregate every field's create/update hook, default, and validate into
@@ -7464,8 +7470,10 @@ function buildTypeScripts(fields, options) {
 		const perFieldExpr = buildHookObject(fields, INPUT, OLD_RECORD, operation);
 		const typeLevelExpr = typeHookExpr?.[operation];
 		let expr;
-		if (perFieldExpr !== null && typeLevelExpr) expr = `((_invoker) => { const ${NOW} = new Date(); const __fl = ${perFieldExpr}; return Object.assign({}, __fl, ((${INPUT}) => ${typeLevelExpr})(Object.assign({}, ${INPUT}, __fl))); })(typeof _invoker !== "undefined" ? _invoker : undefined)`;
-		else if (typeLevelExpr) expr = wrapHook(typeLevelExpr);
+		if (perFieldExpr !== null && typeLevelExpr) {
+			const principalDecl = principalDeclIfReferenced(perFieldExpr, typeLevelExpr);
+			expr = `((_invoker) => { const ${NOW} = new Date();${principalDecl} const __fl = ${perFieldExpr}; return Object.assign({}, __fl, ((${INPUT}) => ${typeLevelExpr})(Object.assign({}, ${INPUT}, __fl))); })(typeof _invoker !== "undefined" ? _invoker : undefined)`;
+		} else if (typeLevelExpr) expr = wrapHook(typeLevelExpr);
 		else if (perFieldExpr !== null) expr = wrapHook(perFieldExpr);
 		if (expr) hook[operation] = { expr: expr + hashSuffix };
 	}
@@ -7501,12 +7509,12 @@ function formatMigrationDiff(diff) {
 	const lines = [];
 	const changesByType = /* @__PURE__ */ new Map();
 	for (const change of diff.changes) {
-		const existing = changesByType.get(change.typeName) ?? [];
+		const existing = changesByType.get(change.tableName) ?? [];
 		existing.push(change);
-		changesByType.set(change.typeName, existing);
+		changesByType.set(change.tableName, existing);
 	}
-	for (const [typeName, changes] of changesByType) {
-		lines.push(`${diff.namespace}.${typeName}:`);
+	for (const [tableName, changes] of changesByType) {
+		lines.push(`${diff.namespace}.${tableName}:`);
 		for (const change of changes) lines.push(formatDiffChange(change));
 	}
 	return lines.join("\n");
@@ -7518,10 +7526,11 @@ function formatMigrationDiff(diff) {
 */
 function formatDiffChange(change) {
 	switch (change.kind) {
-		case "type_added": return `  + [Type] ${change.typeName} (new type)`;
-		case "type_removed": return `  - [Type] ${change.typeName} (removed)`;
-		case "type_modified": return `  ~ [Type] ${change.typeName}: ${change.reason}`;
-		case "type_settings_modified": return `  ~ [Type Settings] ${change.typeName}: ${change.reason ?? "settings changed"}`;
+		case "table_added": return `  + [Table] ${change.tableName} (new table)`;
+		case "table_removed": return `  - [Table] ${change.tableName} (removed)`;
+		case "table_renamed": return `  ~ [Table] ${change.previousTableName} → ${change.tableName} (renamed)`;
+		case "table_modified": return `  ~ [Table] ${change.tableName}: ${change.reason}`;
+		case "table_settings_modified": return `  ~ [Table Settings] ${change.tableName}: ${change.reason ?? "settings changed"}`;
 		case "field_added": {
 			const typeStr = formatFieldType(change.after);
 			return `  + ${change.fieldName}: ${typeStr}`;
@@ -7529,6 +7538,7 @@ function formatDiffChange(change) {
 		case "field_removed": return `  - ${change.fieldName}: ${change.before.type}`;
 		case "field_modified":
 		case "field_type_modified": return `  ~ ${change.fieldName}: ${formatFieldModification(change.before, change.after)}`;
+		case "field_renamed": return `  ~ ${change.previousFieldName} → ${change.fieldName}: ${formatFieldType(change.after)} (renamed)`;
 		case "index_added": return `  + [Index] ${change.indexName}`;
 		case "index_removed": return `  - [Index] ${change.indexName}`;
 		case "index_modified": return `  ~ [Index] ${change.indexName}: ${change.reason ?? "modified"}`;
@@ -7539,10 +7549,10 @@ function formatDiffChange(change) {
 		case "relationship_removed": return `  - [Relationship${change.relationshipType ? ` (${change.relationshipType})` : ""}] ${change.relationshipName}`;
 		case "relationship_modified": return `  ~ [Relationship${change.relationshipType ? ` (${change.relationshipType})` : ""}] ${change.relationshipName}: ${change.reason ?? "modified"}`;
 		case "permission_modified": return `  ~ [Permission] ${change.reason ?? "modified"}`;
-		case "type_scripts_modified": return `  ~ [Type Scripts] ${change.typeName}: ${change.reason ?? "type-level hooks/validate changed"}`;
+		case "table_scripts_modified": return `  ~ [Table Scripts] ${change.tableName}: ${change.reason ?? "table-level hooks/validate changed"}`;
 		default: {
 			const unknown = change;
-			return `  ? ${unknown.typeName}.${unknown.fieldName ?? ""}`;
+			return `  ? ${unknown.tableName}.${unknown.fieldName ?? ""}`;
 		}
 	}
 }
@@ -7598,7 +7608,7 @@ function formatBreakingChanges(breakingChanges) {
 	if (breakingChanges.length === 0) return "";
 	const lines = ["Breaking changes detected:", ""];
 	for (const bc of breakingChanges) {
-		const location = bc.fieldName ? `${bc.typeName}.${bc.fieldName}` : bc.typeName;
+		const location = bc.fieldName ? `${bc.tableName}.${bc.fieldName}` : bc.tableName;
 		lines.push(`  - ${location}: ${bc.reason}`);
 	}
 	return lines.join("\n");
@@ -7612,19 +7622,21 @@ function formatWarnings(warnings) {
 	if (warnings.length === 0) return "";
 	const lines = ["Warning: data loss possible:", ""];
 	for (const w of warnings) {
-		const location = w.fieldName ? `${w.typeName}.${w.fieldName}` : w.typeName;
+		const location = w.fieldName ? `${w.tableName}.${w.fieldName}` : w.tableName;
 		lines.push(`  - ${location}: ${w.reason}`);
 	}
 	return lines.join("\n");
 }
 const DIFF_CHANGE_LABELS = {
-	type_added: "type(s) added",
-	type_removed: "type(s) removed",
-	type_modified: "type(s) modified",
-	type_settings_modified: "type setting(s) modified",
+	table_added: "table(s) added",
+	table_removed: "table(s) removed",
+	table_renamed: "table(s) renamed",
+	table_modified: "table(s) modified",
+	table_settings_modified: "table setting(s) modified",
 	field_added: "field(s) added",
 	field_removed: "field(s) removed",
 	field_modified: "field(s) modified",
+	field_renamed: "field(s) renamed",
 	field_type_modified: "field type(s) modified",
 	index_added: "index(es) added",
 	index_removed: "index(es) removed",
@@ -7636,7 +7648,7 @@ const DIFF_CHANGE_LABELS = {
 	relationship_removed: "relationship(s) removed",
 	relationship_modified: "relationship(s) modified",
 	permission_modified: "permission(s) modified",
-	type_scripts_modified: "type script(s) modified"
+	table_scripts_modified: "table script(s) modified"
 };
 /**
 * Format a summary of the migration diff
@@ -7656,13 +7668,32 @@ function formatDiffSummary(diff) {
 * Scalar type changes whose complete source domain is accepted by the target
 * representation without relying on per-row index recreation.
 *
+* The whole source domain has to cast, not just the values present when the
+* script runs: the field keeps its previous type until the post-migration
+* phase, so an application can still write any value the source type allows
+* after the script has passed over the table. A pair that needs the script to
+* rewrite values first — `string` to `integer`, say, where `"abc"` never
+* casts — would fail that late write at the post-migration phase.
+*
+* Values must also read back with their meaning intact. Date, datetime, and
+* time values are not stored in the textual form they were written in, so
+* converting them to or from another type reads back as a different instant;
+* those pairs stay off this list even though the platform accepts the schema
+* change.
+*
 * Keep this list deliberately narrow. Pair-specific platform experiments can
 * extend it once both indexed and unindexed read paths have been verified.
 */
 const IN_PLACE_TYPE_CHANGES = /* @__PURE__ */ new Set([
+	"boolean:string",
+	"decimal:float",
 	"decimal:string",
 	"enum:string",
+	"float:decimal",
+	"float:string",
+	"integer:decimal",
 	"integer:float",
+	"integer:string",
 	"uuid:string"
 ]);
 /**
@@ -7678,7 +7709,448 @@ function supportsInPlaceFieldTypeChange(before, after) {
 	if (before.serial || after.serial) return false;
 	if (before.vector || after.vector) return false;
 	if (before.foreignKey || after.foreignKey) return false;
-	return IN_PLACE_TYPE_CHANGES.has(`${before.type}:${after.type}`);
+	if (!IN_PLACE_TYPE_CHANGES.has(`${before.type}:${after.type}`)) return false;
+	return !(before.unique ?? false) || after.type !== "decimal" || before.type !== "float";
+}
+/**
+* Explain whether a field type change can be carried by a pair of migrations
+* that move values through a temporary field.
+*
+* The copy is a whole-value overwrite, so it can only carry a field whose value
+* stands on its own: a serial number belongs to a sequence the copy cannot
+* reproduce, a foreign key would dangle while both fields exist, a vector
+* belongs to an index built from it, and a nested value would need its members
+* converted individually. Arrays are excluded because collapsing one into a
+* single value has no answer the generated script could choose, and unique
+* fields because the duplicate-resolution scaffold the rename half would emit
+* only produces string values.
+* @param before - Previous field configuration
+* @param after - Target field configuration
+* @returns Eligibility and, when ineligible, the reason
+*/
+function getExpandContractFieldChangeEligibility(before, after) {
+	if (before.type === after.type) return {
+		eligible: false,
+		reason: "the field type did not change"
+	};
+	if (supportsInPlaceFieldTypeChange(before, after)) return {
+		eligible: false,
+		reason: `the ${before.type} to ${after.type} change is already supported in place`
+	};
+	if (before.unique || after.unique) return {
+		eligible: false,
+		reason: "the field is unique"
+	};
+	if (before.array || after.array) return {
+		eligible: false,
+		reason: "the field is an array"
+	};
+	if (before.type === "nested" || after.type === "nested") return {
+		eligible: false,
+		reason: "the field is nested"
+	};
+	if (before.serial || after.serial) return {
+		eligible: false,
+		reason: "the field uses a serial sequence"
+	};
+	if (before.vector || after.vector) return {
+		eligible: false,
+		reason: "the field is a vector"
+	};
+	if (before.foreignKey || after.foreignKey) return {
+		eligible: false,
+		reason: "the field is a foreign key"
+	};
+	return { eligible: true };
+}
+
+//#endregion
+//#region src/cli/commands/tailordb/migrate/snapshot-types.ts
+/**
+* Optional boolean properties of {@link SnapshotFieldConfig}, absent meaning
+* `false`. Every comparator over snapshot fields iterates this single list so
+* a newly added property cannot be silently skipped by one of them; a
+* comparator that ignores some of these must declare its exclusions
+* explicitly.
+*/
+const SNAPSHOT_FIELD_BOOLEAN_PROPS = [
+	"array",
+	"index",
+	"unique",
+	"foreignKey",
+	"vector"
+];
+/**
+* Type guard: is the operand a field-reference (object) operand?
+* @param {SnapshotPermissionOperand} operand - Operand to test
+* @returns {boolean} True if operand is a field-ref (not a value operand)
+*/
+function isSnapshotFieldRefOperand(operand) {
+	return typeof operand === "object" && operand !== null && !Array.isArray(operand);
+}
+
+//#endregion
+//#region src/cli/commands/tailordb/migrate/rename-detection.ts
+/**
+* Field and type rename detection for TailorDB migrations
+*
+* A rename has no dedicated platform API, so the diff decomposes it into
+* `field_removed` + `field_added` (`table_removed` + `table_added` for types).
+* This module detects removed/added pairs that are compatible enough to be a
+* rename so that `migration generate` can ask the user (or accept
+* `--rename Type.old:new` / `--rename OldType:NewType`) and record a single
+* `field_renamed` / `table_renamed` change instead.
+*/
+/** Modifiers a rename may change, since the Pre-phase relaxes them. */
+const RENAME_TOLERATED_BOOLEAN_PROPS = /* @__PURE__ */ new Set([
+	"index",
+	"unique",
+	"vector"
+]);
+/**
+* Whether copying values from `before` into `after` preserves their meaning,
+* i.e. the removed + added pair can be treated as a rename.
+*
+* Serial fields are excluded because their values are platform-generated and
+* cannot be written by a migration script.
+* @param {SnapshotFieldConfig} before - Removed field's configuration
+* @param {SnapshotFieldConfig} after - Added field's configuration
+* @returns {boolean} True if the pair is rename-compatible
+*/
+function isRenameCompatible(before, after) {
+	if (before.type !== after.type) return false;
+	for (const prop of SNAPSHOT_FIELD_BOOLEAN_PROPS) {
+		if (RENAME_TOLERATED_BOOLEAN_PROPS.has(prop)) continue;
+		if ((before[prop] ?? false) !== (after[prop] ?? false)) return false;
+	}
+	if ((before.foreignKeyType ?? "") !== (after.foreignKeyType ?? "")) return false;
+	if ((before.foreignKeyField ?? "") !== (after.foreignKeyField ?? "")) return false;
+	if (before.serial || after.serial) return false;
+	if (before.type === "enum") {
+		const afterValues = new Set((after.allowedValues ?? []).map((v) => v.value));
+		if ((before.allowedValues ?? []).some((v) => !afterValues.has(v.value))) return false;
+	}
+	const beforeNested = before.fields ?? {};
+	const afterNested = after.fields ?? {};
+	const beforeNames = Object.keys(beforeNested);
+	const afterNames = Object.keys(afterNested);
+	if (beforeNames.length !== afterNames.length) return false;
+	for (const name of beforeNames) {
+		const beforeMember = beforeNested[name];
+		const afterMember = afterNested[name];
+		if (!beforeMember || !afterMember) return false;
+		if (beforeMember.required !== afterMember.required) return false;
+		if (!isRenameCompatible(beforeMember, afterMember)) return false;
+	}
+	return true;
+}
+/**
+* Find removed + added field pairs in a diff that could be renames.
+* @param {MigrationDiff} diff - Migration diff to scan
+* @returns {FieldRenameCandidate[]} Candidates in diff order (may be empty)
+*/
+function findRenameCandidates(diff) {
+	const removedByType = /* @__PURE__ */ new Map();
+	const addedByType = /* @__PURE__ */ new Map();
+	for (const change of diff.changes) if (change.kind === "field_removed") {
+		const list = removedByType.get(change.tableName) ?? [];
+		list.push(change);
+		removedByType.set(change.tableName, list);
+	} else if (change.kind === "field_added") {
+		const list = addedByType.get(change.tableName) ?? [];
+		list.push(change);
+		addedByType.set(change.tableName, list);
+	}
+	const candidates = [];
+	for (const [tableName, removedChanges] of removedByType) {
+		const addedChanges = addedByType.get(tableName);
+		if (!addedChanges) continue;
+		for (const removed of removedChanges) {
+			const added = addedChanges.filter((a) => isRenameCompatible(removed.before, a.after));
+			if (added.length > 0) candidates.push({
+				tableName,
+				removed,
+				added
+			});
+		}
+	}
+	return candidates;
+}
+/**
+* Whether a rename spec matches a removed + added field pair between two
+* snapshots: the old field existed before and is gone now, and the new field
+* exists now but did not before. Field compatibility is checked separately
+* when the diff is recomputed with the spec.
+* @param {FieldRenameSpec} spec - Rename spec to test
+* @param {SchemaSnapshot} previousSnapshot - Previous schema snapshot
+* @param {SchemaSnapshot} currentSnapshot - Current schema snapshot
+* @returns {boolean} True if the spec matches a removed + added pair
+*/
+function renameSpecApplies(spec, previousSnapshot, currentSnapshot) {
+	const prevFields = previousSnapshot.tables[spec.tableName]?.fields;
+	const currFields = currentSnapshot.tables[spec.tableName]?.fields;
+	return Boolean(prevFields?.[spec.previousFieldName] && !currFields?.[spec.previousFieldName] && currFields?.[spec.fieldName] && !prevFields[spec.fieldName]);
+}
+/**
+* Assert that every rename spec matches a compatible removed + added field
+* pair between the two normalized snapshots.
+* @param {NormalizedSchemaSnapshot} previous - Previous normalized snapshot
+* @param {NormalizedSchemaSnapshot} current - Current normalized snapshot
+* @param {readonly FieldRenameSpec[]} fieldRenames - Rename specs to validate
+*/
+function assertValidFieldRenames(previous, current, fieldRenames) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const rename of fieldRenames) {
+		const { tableName, previousFieldName, fieldName } = rename;
+		const label = `${tableName}.${previousFieldName}:${fieldName}`;
+		for (const key of [`${tableName}.${previousFieldName}`, `${tableName}.${fieldName}`]) {
+			if (seen.has(key)) throw new Error(`Field "${key}" appears in more than one rename.`);
+			seen.add(key);
+		}
+		const prevType = previous.tables[tableName];
+		const currType = current.tables[tableName];
+		if (!prevType || !currType) throw new Error(`Cannot rename ${label}: type "${tableName}" must exist in both the previous and the current schema.`);
+		const prevField = prevType.fields[previousFieldName];
+		if (!prevField) throw new Error(`Cannot rename ${label}: field "${previousFieldName}" does not exist in the previous schema.`);
+		if (currType.fields[previousFieldName]) throw new Error(`Cannot rename ${label}: field "${previousFieldName}" still exists in the current schema.`);
+		const currField = currType.fields[fieldName];
+		if (!currField) throw new Error(`Cannot rename ${label}: field "${fieldName}" does not exist in the current schema.`);
+		if (prevType.fields[fieldName]) throw new Error(`Cannot rename ${label}: field "${fieldName}" already exists in the previous schema.`);
+		if (!isRenameCompatible(prevField, currField)) throw new Error(`Cannot rename ${label}: the fields are not rename-compatible (the field type, array-ness, and foreign key target must match, enum values must not be removed, nested member names, requiredness, and types must match recursively, and serial fields cannot be renamed).`);
+	}
+}
+const RENAME_OPTION_PATTERN = /^([^.:\s]+)\.([^.:\s]+):([^.:\s]+)$/;
+/**
+* Parse a `--rename` option value of the form `Type.old:new`.
+* @param {string} value - Raw option value
+* @returns {FieldRenameSpec} Parsed rename spec
+*/
+function parseRenameOption(value) {
+	const [, tableName, previousFieldName, fieldName] = value.match(RENAME_OPTION_PATTERN) ?? [];
+	if (!tableName || !previousFieldName || !fieldName) throw new Error(`Invalid --rename value "${value}". Expected format: "Type.oldField:newField".`);
+	if (previousFieldName === fieldName) throw new Error(`Invalid --rename value "${value}": old and new field names are identical.`);
+	return {
+		tableName,
+		previousFieldName,
+		fieldName
+	};
+}
+const DROP_OPTION_PATTERN = /^([^.:\s]+)\.([^.:\s]+)$/;
+/**
+* Parse a `--drop` option value of the form `Type.field`.
+* @param {string} value - Raw option value
+* @returns {FieldDropSpec} Parsed drop spec
+*/
+function parseDropOption(value) {
+	const [, tableName, fieldName] = value.match(DROP_OPTION_PATTERN) ?? [];
+	if (!tableName || !fieldName) throw new Error(`Invalid --drop value "${value}". Expected format: "Type.field".`);
+	return {
+		tableName,
+		fieldName
+	};
+}
+/**
+* Whether a drop spec matches a field that was removed between two snapshots:
+* the field existed before and is gone now.
+* @param {FieldDropSpec} spec - Drop spec to test
+* @param {SchemaSnapshot} previousSnapshot - Previous schema snapshot
+* @param {SchemaSnapshot} currentSnapshot - Current schema snapshot
+* @returns {boolean} True if the spec matches a removed field
+*/
+function dropSpecApplies(spec, previousSnapshot, currentSnapshot) {
+	const prevFields = previousSnapshot.tables[spec.tableName]?.fields;
+	const currFields = currentSnapshot.tables[spec.tableName]?.fields;
+	return Boolean(prevFields?.[spec.fieldName] && !currFields?.[spec.fieldName]);
+}
+/**
+* Parse an `--expand-contract` option value of the form `Type.field`.
+* @param {string} value - Raw option value
+* @returns {FieldExpandContractSpec} Parsed spec
+*/
+function parseExpandContractOption(value) {
+	const [, tableName, fieldName] = value.match(DROP_OPTION_PATTERN) ?? [];
+	if (!tableName || !fieldName) throw new Error(`Invalid --expand-contract value "${value}". Expected format: "Type.field".`);
+	return {
+		tableName,
+		fieldName
+	};
+}
+/**
+* Return a copy of a field config with foreign key references to the old type
+* name retargeted at the new name, so a self-referential type compares equal
+* to its renamed shape.
+* @param {SnapshotFieldConfig} field - Field configuration to retarget
+* @param {string} previousTableName - Type name before the rename
+* @param {string} tableName - Type name after the rename
+* @returns {SnapshotFieldConfig} Retargeted copy of the field
+*/
+function retargetSelfReferences(field, previousTableName, tableName) {
+	const nested = field.fields ? Object.fromEntries(Object.entries(field.fields).map(([name, member]) => [name, retargetSelfReferences(member, previousTableName, tableName)])) : void 0;
+	return {
+		...field,
+		...field.foreignKeyType === previousTableName && { foreignKeyType: tableName },
+		...nested && { fields: nested }
+	};
+}
+/**
+* JSON serialization with recursively sorted object keys, for deep equality.
+* @param {unknown} value - Value to serialize
+* @returns {string} Canonical JSON representation
+*/
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (typeof value === "object" && value !== null) return `{${Object.entries(value).filter(([, v]) => v !== void 0).toSorted(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stableStringify(v)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function isTypeRenameFieldCompatible(before, after) {
+	if (!isRenameCompatible(before, after)) return false;
+	if (before.required !== after.required) return false;
+	if ((before.unique ?? false) !== (after.unique ?? false)) return false;
+	if ((before.scale ?? null) !== (after.scale ?? null)) return false;
+	for (const [name, beforeMember] of Object.entries(before.fields ?? {})) {
+		const afterMember = after.fields?.[name];
+		if (!afterMember || !isTypeRenameFieldCompatible(beforeMember, afterMember)) return false;
+	}
+	return true;
+}
+/**
+* Whether copying every row of `before` into `after` preserves the data, i.e.
+* the removed + added type pair can be treated as a rename.
+*
+* A renamed type is created with its full constraints in the Pre-phase (there
+* is no relaxation machinery for a fresh type), so the shape must match
+* strictly: same field names with the same type, array-ness, required/unique
+* constraints, foreign key target (self references compare against the new
+* name), and scale; enum values must not be removed; indexes must match.
+* Serial values cannot be written by a script and file contents are not
+* copied by SQL, so types with serial or file fields are never candidates.
+* Name-derived and data-independent surfaces (pluralForm, description,
+* settings, permissions, hooks, validations, relationships) may differ.
+* @param {TailorDBSnapshotType} before - Removed type's snapshot
+* @param {TailorDBSnapshotType} after - Added type's snapshot
+* @returns {boolean} True if the pair is rename-compatible
+*/
+function isTypeRenameCompatible(before, after) {
+	if (Object.keys(before.files ?? {}).length > 0 || Object.keys(after.files ?? {}).length > 0) return false;
+	const beforeFieldNames = Object.keys(before.fields);
+	const afterFieldNames = Object.keys(after.fields);
+	if (beforeFieldNames.length !== afterFieldNames.length) return false;
+	for (const fieldName of beforeFieldNames) {
+		const beforeField = before.fields[fieldName];
+		const afterField = after.fields[fieldName];
+		if (!beforeField || !afterField) return false;
+		if (beforeField.foreignKeyType === before.name && beforeField.required) return false;
+		if (!isTypeRenameFieldCompatible(retargetSelfReferences(beforeField, before.name, after.name), afterField)) return false;
+	}
+	return stableStringify(before.indexes ?? {}) === stableStringify(after.indexes ?? {});
+}
+/**
+* Find removed + added type pairs in a diff that could be renames.
+* @param {MigrationDiff} diff - Migration diff to scan
+* @returns {TypeRenameCandidate[]} Candidates in diff order (may be empty)
+*/
+function findTypeRenameCandidates(diff) {
+	const removedChanges = diff.changes.filter((change) => change.kind === "table_removed");
+	const addedChanges = diff.changes.filter((change) => change.kind === "table_added");
+	const candidates = [];
+	for (const removed of removedChanges) {
+		const added = addedChanges.filter((a) => isTypeRenameCompatible(removed.before, a.after));
+		if (added.length > 0) candidates.push({
+			removed,
+			added
+		});
+	}
+	return candidates;
+}
+/**
+* Whether a type rename spec matches a removed + added type pair between two
+* snapshots: the old type existed before and is gone now, and the new type
+* exists now but did not before. Type compatibility is checked separately
+* when the diff is recomputed with the spec.
+* @param {TypeRenameSpec} spec - Rename spec to test
+* @param {SchemaSnapshot} previousSnapshot - Previous schema snapshot
+* @param {SchemaSnapshot} currentSnapshot - Current schema snapshot
+* @returns {boolean} True if the spec matches a removed + added pair
+*/
+function typeRenameSpecApplies(spec, previousSnapshot, currentSnapshot) {
+	return Boolean(previousSnapshot.tables[spec.previousTableName] && !currentSnapshot.tables[spec.previousTableName] && currentSnapshot.tables[spec.tableName] && !previousSnapshot.tables[spec.tableName]);
+}
+/**
+* Assert that every type rename spec matches a compatible removed + added
+* type pair between the two normalized snapshots.
+* @param {NormalizedSchemaSnapshot} previous - Previous normalized snapshot
+* @param {NormalizedSchemaSnapshot} current - Current normalized snapshot
+* @param {readonly TypeRenameSpec[]} typeRenames - Rename specs to validate
+*/
+function assertValidTypeRenames(previous, current, typeRenames) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const rename of typeRenames) {
+		const { previousTableName, tableName } = rename;
+		const label = `${previousTableName}:${tableName}`;
+		for (const key of [previousTableName, tableName]) {
+			if (seen.has(key)) throw new Error(`Type "${key}" appears in more than one rename.`);
+			seen.add(key);
+		}
+		const prevType = previous.tables[previousTableName];
+		if (!prevType) throw new Error(`Cannot rename ${label}: type "${previousTableName}" does not exist in the previous schema.`);
+		if (current.tables[previousTableName]) throw new Error(`Cannot rename ${label}: type "${previousTableName}" still exists in the current schema.`);
+		const currType = current.tables[tableName];
+		if (!currType) throw new Error(`Cannot rename ${label}: type "${tableName}" does not exist in the current schema.`);
+		if (previous.tables[tableName]) throw new Error(`Cannot rename ${label}: type "${tableName}" already exists in the previous schema.`);
+		if (!isTypeRenameCompatible(prevType, currType)) throw new Error(`Cannot rename ${label}: the types are not rename-compatible (every field must keep its name, type, array-ness, required/unique constraints, foreign key target, and scale, enum values must not be removed, indexes must match, self-referential foreign keys must be optional, and types with serial or file fields cannot be renamed).`);
+	}
+}
+/**
+* Whether a field's foreign key target changed in a way that is not explained
+* by a confirmed type rename. Such a retarget is breaking (stored references
+* may become invalid) and needs a reference fixup script; a retarget that
+* follows a rename does not, because record ids are preserved by the copy —
+* provided the referenced field is unchanged, since the copy only guarantees
+* that the same ids exist under the new type name.
+* @param {SnapshotFieldConfig} before - Field configuration before the change
+* @param {SnapshotFieldConfig} after - Field configuration after the change
+* @param {ReadonlyMap<string, string>} [typeRenameTargets] - Confirmed type renames (old name → new name)
+* @returns {boolean} True if the retarget is breaking
+*/
+function isBreakingForeignKeyRetarget(before, after, typeRenameTargets) {
+	return Boolean(before.foreignKeyType && after.foreignKeyType && before.foreignKeyType !== after.foreignKeyType && (typeRenameTargets?.get(before.foreignKeyType) !== after.foreignKeyType || (before.foreignKeyField ?? "") !== (after.foreignKeyField ?? "")));
+}
+const TYPE_RENAME_OPTION_PATTERN = /^([^.:\s]+):([^.:\s]+)$/;
+/**
+* Parse a `--rename` option value of the form `OldType:NewType`.
+* @param {string} value - Raw option value
+* @returns {TypeRenameSpec} Parsed rename spec
+*/
+function parseTypeRenameOption(value) {
+	const [, previousTableName, tableName] = value.match(TYPE_RENAME_OPTION_PATTERN) ?? [];
+	if (!previousTableName || !tableName) throw new Error(`Invalid --rename value "${value}". Expected format: "Type.oldField:newField" or "OldType:NewType".`);
+	if (previousTableName === tableName) throw new Error(`Invalid --rename value "${value}": old and new type names are identical.`);
+	return {
+		previousTableName,
+		tableName
+	};
+}
+const TYPE_DROP_OPTION_PATTERN = /^([^.:\s]+)$/;
+/**
+* Parse a `--drop` option value of the form `Type`.
+* @param {string} value - Raw option value
+* @returns {TypeDropSpec} Parsed drop spec
+*/
+function parseTypeDropOption(value) {
+	const [, tableName] = value.match(TYPE_DROP_OPTION_PATTERN) ?? [];
+	if (!tableName) throw new Error(`Invalid --drop value "${value}". Expected format: "Type.field" or "Type".`);
+	return { tableName };
+}
+/**
+* Whether a type drop spec matches a type that was removed between two
+* snapshots: the type existed before and is gone now.
+* @param {TypeDropSpec} spec - Drop spec to test
+* @param {SchemaSnapshot} previousSnapshot - Previous schema snapshot
+* @param {SchemaSnapshot} currentSnapshot - Current schema snapshot
+* @returns {boolean} True if the spec matches a removed type
+*/
+function typeDropSpecApplies(spec, previousSnapshot, currentSnapshot) {
+	return Boolean(previousSnapshot.tables[spec.tableName] && !currentSnapshot.tables[spec.tableName]);
 }
 
 //#endregion
@@ -7919,7 +8391,7 @@ const schemaSnapshotSchema = z.looseObject({
 	version: z.number(),
 	namespace: z.string(),
 	createdAt: z.string(),
-	types: snapshotRecordSchema(tailorDBSnapshotTypeSchema),
+	tables: snapshotRecordSchema(tailorDBSnapshotTypeSchema),
 	rebaseline: rebaselineMarkerSchema.optional()
 });
 const typeSettingsPatchSchema = z.looseObject({
@@ -7946,56 +8418,73 @@ const snapshotPermissionStateSchema = z.looseObject({
 	gqlPermission: snapshotGqlPermissionSchema.optional()
 });
 const typeAddedChangeSchema = z.looseObject({
-	kind: z.literal("type_added"),
-	typeName: z.string(),
+	kind: z.literal("table_added"),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	after: tailorDBSnapshotTypeSchema
 });
 const typeRemovedChangeSchema = z.looseObject({
-	kind: z.literal("type_removed"),
-	typeName: z.string(),
+	kind: z.literal("table_removed"),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	before: tailorDBSnapshotTypeSchema
 });
+const typeRenamedChangeSchema = z.looseObject({
+	kind: z.literal("table_renamed"),
+	tableName: z.string(),
+	reason: z.string().optional(),
+	previousTableName: z.string(),
+	before: tailorDBSnapshotTypeSchema,
+	after: tailorDBSnapshotTypeSchema
+});
 const typeModifiedChangeSchema = z.looseObject({
-	kind: z.literal("type_modified"),
-	typeName: z.string(),
+	kind: z.literal("table_modified"),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	before: typeSettingsPatchSchema.optional(),
 	after: typeSettingsPatchSchema.optional()
 });
 const typeSettingsModifiedChangeSchema = z.looseObject({
-	kind: z.literal("type_settings_modified"),
-	typeName: z.string(),
+	kind: z.literal("table_settings_modified"),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	before: snapshotTypeSettingsStateSchema,
 	after: snapshotTypeSettingsStateSchema
 });
 const fieldAddedChangeSchema = z.looseObject({
 	kind: z.literal("field_added"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	fieldName: z.string(),
 	after: snapshotFieldConfigSchema
 });
 const fieldRemovedChangeSchema = z.looseObject({
 	kind: z.literal("field_removed"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	fieldName: z.string(),
 	before: snapshotFieldConfigSchema
 });
 const fieldModifiedChangeSchema = z.looseObject({
 	kind: z.literal("field_modified"),
-	typeName: z.string(),
+	tableName: z.string(),
+	reason: z.string().optional(),
+	fieldName: z.string(),
+	before: snapshotFieldConfigSchema,
+	after: snapshotFieldConfigSchema
+});
+const fieldRenamedChangeSchema = z.looseObject({
+	kind: z.literal("field_renamed"),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	fieldName: z.string(),
+	previousFieldName: z.string(),
 	before: snapshotFieldConfigSchema,
 	after: snapshotFieldConfigSchema
 });
 const fieldTypeModifiedChangeSchema = z.looseObject({
 	kind: z.literal("field_type_modified"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	fieldName: z.string(),
 	before: snapshotFieldConfigSchema,
@@ -8003,21 +8492,21 @@ const fieldTypeModifiedChangeSchema = z.looseObject({
 });
 const indexAddedChangeSchema = z.looseObject({
 	kind: z.literal("index_added"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	indexName: z.string(),
 	after: snapshotIndexConfigSchema
 });
 const indexRemovedChangeSchema = z.looseObject({
 	kind: z.literal("index_removed"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	indexName: z.string(),
 	before: snapshotIndexConfigSchema
 });
 const indexModifiedChangeSchema = z.looseObject({
 	kind: z.literal("index_modified"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	indexName: z.string(),
 	before: snapshotIndexConfigSchema,
@@ -8025,21 +8514,21 @@ const indexModifiedChangeSchema = z.looseObject({
 });
 const fileAddedChangeSchema = z.looseObject({
 	kind: z.literal("file_added"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	fieldName: z.string(),
 	after: z.string()
 });
 const fileRemovedChangeSchema = z.looseObject({
 	kind: z.literal("file_removed"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	fieldName: z.string(),
 	before: z.string()
 });
 const fileModifiedChangeSchema = z.looseObject({
 	kind: z.literal("file_modified"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	fieldName: z.string(),
 	before: z.string(),
@@ -8047,7 +8536,7 @@ const fileModifiedChangeSchema = z.looseObject({
 });
 const relationshipAddedChangeSchema = z.looseObject({
 	kind: z.literal("relationship_added"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	relationshipName: z.string(),
 	relationshipType: z.enum(["forward", "backward"]).optional(),
@@ -8055,7 +8544,7 @@ const relationshipAddedChangeSchema = z.looseObject({
 });
 const relationshipRemovedChangeSchema = z.looseObject({
 	kind: z.literal("relationship_removed"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	relationshipName: z.string(),
 	relationshipType: z.enum(["forward", "backward"]).optional(),
@@ -8063,7 +8552,7 @@ const relationshipRemovedChangeSchema = z.looseObject({
 });
 const relationshipModifiedChangeSchema = z.looseObject({
 	kind: z.literal("relationship_modified"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	relationshipName: z.string(),
 	relationshipType: z.enum(["forward", "backward"]).optional(),
@@ -8072,7 +8561,7 @@ const relationshipModifiedChangeSchema = z.looseObject({
 });
 const permissionModifiedChangeSchema = z.looseObject({
 	kind: z.literal("permission_modified"),
-	typeName: z.string(),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	before: snapshotPermissionStateSchema.optional(),
 	after: snapshotPermissionStateSchema.optional()
@@ -8085,8 +8574,8 @@ const typeScriptsStateSchema = z.looseObject({
 	typeValidateExpr: z.string().optional()
 });
 const typeScriptsModifiedChangeSchema = z.looseObject({
-	kind: z.literal("type_scripts_modified"),
-	typeName: z.string(),
+	kind: z.literal("table_scripts_modified"),
+	tableName: z.string(),
 	reason: z.string().optional(),
 	before: typeScriptsStateSchema,
 	after: typeScriptsStateSchema
@@ -8094,11 +8583,13 @@ const typeScriptsModifiedChangeSchema = z.looseObject({
 const diffChangeSchema = z.discriminatedUnion("kind", [
 	typeAddedChangeSchema,
 	typeRemovedChangeSchema,
+	typeRenamedChangeSchema,
 	typeModifiedChangeSchema,
 	typeSettingsModifiedChangeSchema,
 	fieldAddedChangeSchema,
 	fieldRemovedChangeSchema,
 	fieldModifiedChangeSchema,
+	fieldRenamedChangeSchema,
 	fieldTypeModifiedChangeSchema,
 	indexAddedChangeSchema,
 	indexRemovedChangeSchema,
@@ -8113,14 +8604,14 @@ const diffChangeSchema = z.discriminatedUnion("kind", [
 	typeScriptsModifiedChangeSchema
 ]);
 const breakingChangeInfoSchema = z.looseObject({
-	typeName: z.string(),
+	tableName: z.string(),
 	fieldName: z.string().optional(),
 	reason: z.string(),
 	unsupported: z.boolean().optional(),
 	showThreeStepHint: z.boolean().optional()
 });
 const warningChangeInfoSchema = z.looseObject({
-	typeName: z.string(),
+	tableName: z.string(),
 	fieldName: z.string().optional(),
 	reason: z.string()
 });
@@ -8142,17 +8633,6 @@ const migrationDiffSchema = z.looseObject({
 	scriptSkipped: scriptSkippedInfoSchema.optional()
 });
 
-//#endregion
-//#region src/cli/commands/tailordb/migrate/snapshot-types.ts
-/**
-* Type guard: is the operand a field-reference (object) operand?
-* @param {SnapshotPermissionOperand} operand - Operand to test
-* @returns {boolean} True if operand is a field-ref (not a value operand)
-*/
-function isSnapshotFieldRefOperand(operand) {
-	return typeof operand === "object" && operand !== null && !Array.isArray(operand);
-}
-
 //#endregion
 //#region src/cli/commands/tailordb/migrate/snapshot.ts
 /**
@@ -8179,6 +8659,8 @@ const DB_TYPES_FILE_NAME = "db.ts";
 * Examples: 0001, 0002, 0003, ...
 */
 const MIGRATION_NUMBER_PATTERN = /^\d{4}$/;
+/** Highest migration number the four-digit directory name can hold. */
+const MAX_MIGRATION_NUMBER = 9999;
 /**
 * Platform default scale for decimal fields when scale is not explicitly specified.
 * Must stay in sync with the platform's default decimal scale.
@@ -8189,14 +8671,111 @@ function assertSupportedMigrationFileVersion(filePath, raw) {
 	if (typeof raw !== "object" || raw === null || !("version" in raw)) return;
 	const version = raw.version;
 	if (typeof version !== "number") return;
-	if (Number.isInteger(version) && version >= 1 && version <= 2) return;
-	const supportedRange = `${1}-${2}`;
+	if (Number.isInteger(version) && version >= 1 && version <= 5) return;
+	const supportedRange = `${1}-${5}`;
 	let guidance;
-	if (version > 2) guidance = `Upgrade to an SDK that supports migration file format version ${version}.`;
+	if (version > 5) guidance = `Upgrade to an SDK that supports migration file format version ${version}.`;
 	else if (version < 1) guidance = "Re-baseline with an SDK that still supports this migration history, then upgrade the SDK.";
 	else guidance = "Restore the migration file from version control or regenerate it.";
 	throw new UnsupportedMigrationFileVersionError(`Unsupported migration file format version ${version} at ${filePath}. This SDK supports migration file format versions ${supportedRange}. ${guidance}`);
 }
+/**
+* Diff change kinds renamed when TailorDB table terminology replaced "type".
+* Migration histories written before the rename persist the old names, so
+* diff.json files keep being read through this mapping.
+*/
+const LEGACY_CHANGE_KINDS = /* @__PURE__ */ new Map([
+	["type_added", "table_added"],
+	["type_removed", "table_removed"],
+	["type_renamed", "table_renamed"],
+	["type_modified", "table_modified"],
+	["type_settings_modified", "table_settings_modified"],
+	["type_scripts_modified", "table_scripts_modified"]
+]);
+/**
+* Rewrite pre-rename `type_*` change kinds to their current `table_*` names
+* so that the diff schema, which only knows the current names, accepts them.
+* @param {unknown} raw - Parsed diff.json contents
+* @returns {unknown} Diff contents with legacy change kinds rewritten
+*/
+function normalizeLegacyChangeKinds(raw) {
+	if (typeof raw !== "object" || raw === null || !("changes" in raw)) return raw;
+	const changes = raw.changes;
+	if (!Array.isArray(changes)) return raw;
+	const normalized = changes.map((change) => {
+		if (typeof change !== "object" || change === null || !("kind" in change)) return change;
+		const kind = change.kind;
+		if (typeof kind !== "string") return change;
+		const currentKind = LEGACY_CHANGE_KINDS.get(kind);
+		return currentKind === void 0 ? change : {
+			...change,
+			kind: currentKind
+		};
+	});
+	return {
+		...raw,
+		changes: normalized
+	};
+}
+/**
+* Persisted field names renamed when TailorDB table terminology replaced
+* "type". Applied to every entry that carries a table name, so diff.json files
+* written before the rename keep validating against the current schema.
+*/
+const LEGACY_ENTRY_FIELDS = /* @__PURE__ */ new Map([["typeName", "tableName"], ["previousTypeName", "previousTableName"]]);
+function renameLegacyEntryFields(entry) {
+	if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return entry;
+	const source = entry;
+	const renamed = {};
+	let changed = false;
+	for (const [key, value] of Object.entries(source)) {
+		const currentKey = LEGACY_ENTRY_FIELDS.get(key);
+		if (currentKey !== void 0 && !(currentKey in source)) {
+			renamed[currentKey] = value;
+			changed = true;
+		} else renamed[key] = value;
+	}
+	return changed ? renamed : entry;
+}
+/** Persisted arrays whose entries carry a table name. */
+const LEGACY_FIELD_CARRIERS = [
+	"changes",
+	"breakingChanges",
+	"warnings"
+];
+/**
+* Move a pre-rename `types` record to `tables` so schema.json files written
+* before the rename keep validating against the current schema.
+* @param {unknown} raw - Parsed schema.json contents
+* @returns {unknown} Snapshot contents with the legacy key moved
+*/
+function normalizeLegacyTablesKey(raw) {
+	if (typeof raw !== "object" || raw === null) return raw;
+	const source = raw;
+	if (!("types" in source) || "tables" in source) return raw;
+	const { types, ...rest } = source;
+	return {
+		...rest,
+		tables: types
+	};
+}
+/**
+* Rewrite the pre-rename `typeName` / `previousTypeName` keys to their current
+* names across every persisted position that carries a table name.
+* @param {unknown} raw - Parsed diff.json contents
+* @returns {unknown} Diff contents with legacy field names rewritten
+*/
+function normalizeLegacyFieldNames(raw) {
+	if (typeof raw !== "object" || raw === null) return raw;
+	const source = raw;
+	const normalized = { ...source };
+	for (const key of LEGACY_FIELD_CARRIERS) {
+		const entries = source[key];
+		if (!Array.isArray(entries)) continue;
+		normalized[key] = entries.map(renameLegacyEntryFields);
+	}
+	return normalized;
+}
 function createSnapshotRecord() {
 	return Object.create(null);
 }
@@ -8250,11 +8829,11 @@ function normalizeSnapshotType(type) {
 * @returns {NormalizedSchemaSnapshot} A new schema snapshot object branded as normalized
 */
 function normalizeSchemaSnapshot(snapshot) {
-	const types = createSnapshotRecord();
-	for (const [typeName, type] of Object.entries(snapshot.types)) types[typeName] = normalizeSnapshotType(type);
+	const tables = createSnapshotRecord();
+	for (const [tableName, type] of Object.entries(snapshot.tables)) tables[tableName] = normalizeSnapshotType(type);
 	return {
 		...snapshot,
-		types
+		tables
 	};
 }
 /**
@@ -8436,12 +9015,12 @@ function convertActionPermission(permission) {
 */
 function createSnapshotFromLocalTypes(types, namespace) {
 	const snapshotTypes = createSnapshotRecord();
-	for (const [typeName, type] of Object.entries(types)) snapshotTypes[typeName] = createSnapshotType(type);
+	for (const [tableName, type] of Object.entries(types)) snapshotTypes[tableName] = createSnapshotType(type);
 	return normalizeSchemaSnapshot({
-		version: 2,
+		version: 5,
 		namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		types: snapshotTypes
+		tables: snapshotTypes
 	});
 }
 /**
@@ -8458,7 +9037,7 @@ function loadSnapshot(filePath) {
 		throw new Error(`Invalid schema snapshot at ${filePath}: ${String(error)}`, { cause: error });
 	}
 	assertSupportedMigrationFileVersion(filePath, raw);
-	const result = schemaSnapshotSchema.safeParse(raw);
+	const result = schemaSnapshotSchema.safeParse(normalizeLegacyTablesKey(raw));
 	if (!result.success) throw new Error(`Invalid schema snapshot at ${filePath}: ${z.prettifyError(result.error)}`, { cause: result.error });
 	const snapshot = result.data;
 	return normalizeSchemaSnapshot(snapshot);
@@ -8477,7 +9056,7 @@ function loadDiff(filePath) {
 		throw new Error(`Invalid migration diff at ${filePath}: ${String(error)}`, { cause: error });
 	}
 	assertSupportedMigrationFileVersion(filePath, raw);
-	const result = migrationDiffSchema.safeParse(raw);
+	const result = migrationDiffSchema.safeParse(normalizeLegacyFieldNames(normalizeLegacyChangeKinds(raw)));
 	if (!result.success) throw new Error(`Invalid migration diff at ${filePath}: ${z.prettifyError(result.error)}`, { cause: result.error });
 	const parsed = result.data;
 	const warnings = parsed.warnings ?? deriveWarningsFromChanges(parsed);
@@ -8488,7 +9067,7 @@ function loadDiff(filePath) {
 	};
 }
 const FIELD_REMOVED_WARNING_REASON = "Field removed (existing data will no longer be accessible through the schema)";
-const TYPE_REMOVED_WARNING_REASON = "Type removed (all records of this type will be deleted during post-migration cleanup)";
+const TABLE_REMOVED_WARNING_REASON = "Type removed (all records of this type will be deleted during post-migration cleanup)";
 /**
 * Reconstruct data-loss warnings from removal changes for diff.json files
 * written before the warning tier existed
@@ -8498,13 +9077,13 @@ const TYPE_REMOVED_WARNING_REASON = "Type removed (all records of this type will
 function deriveWarningsFromChanges(diff) {
 	const warnings = [];
 	for (const change of diff.changes) if (change.kind === "field_removed") warnings.push({
-		typeName: change.typeName,
+		tableName: change.tableName,
 		fieldName: change.fieldName,
 		reason: FIELD_REMOVED_WARNING_REASON
 	});
-	else if (change.kind === "type_removed") warnings.push({
-		typeName: change.typeName,
-		reason: TYPE_REMOVED_WARNING_REASON
+	else if (change.kind === "table_removed") warnings.push({
+		tableName: change.tableName,
+		reason: TABLE_REMOVED_WARNING_REASON
 	});
 	return warnings;
 }
@@ -8555,19 +9134,19 @@ function getNextMigrationNumber(migrationsDir) {
 * @returns {NormalizedSchemaSnapshot} Normalized snapshot after applying diff
 */
 function applyDiffToSnapshot(snapshot, diff) {
-	const types = copySnapshotRecord(snapshot.types);
+	const tables = copySnapshotRecord(snapshot.tables);
 	for (const change of diff.changes) switch (change.kind) {
-		case "type_added":
-			types[change.typeName] = change.after;
+		case "table_added":
+			tables[change.tableName] = change.after;
 			break;
-		case "type_removed":
-			delete types[change.typeName];
+		case "table_removed":
+			delete tables[change.tableName];
 			break;
-		case "type_modified": {
-			const existing = types[change.typeName];
+		case "table_modified": {
+			const existing = tables[change.tableName];
 			if (existing && change.after) {
 				const after = change.after;
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					...after.indexes !== void 0 && { indexes: after.indexes },
 					...after.files !== void 0 && { files: after.files }
@@ -8575,9 +9154,9 @@ function applyDiffToSnapshot(snapshot, diff) {
 			}
 			break;
 		}
-		case "type_settings_modified": {
-			const existing = types[change.typeName];
-			if (existing) types[change.typeName] = {
+		case "table_settings_modified": {
+			const existing = tables[change.tableName];
+			if (existing) tables[change.tableName] = {
 				...existing,
 				description: change.after.description,
 				pluralForm: change.after.pluralForm,
@@ -8585,11 +9164,11 @@ function applyDiffToSnapshot(snapshot, diff) {
 			};
 			break;
 		}
-		case "type_scripts_modified": {
-			const existing = types[change.typeName];
+		case "table_scripts_modified": {
+			const existing = tables[change.tableName];
 			if (existing) {
 				const { typeHookExpr: _, typeValidateExpr: __, ...rest } = existing;
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...rest,
 					...change.after.typeHookExpr && { typeHookExpr: change.after.typeHookExpr },
 					...change.after.typeValidateExpr !== void 0 && { typeValidateExpr: change.after.typeValidateExpr }
@@ -8600,11 +9179,11 @@ function applyDiffToSnapshot(snapshot, diff) {
 		case "field_added":
 		case "field_modified":
 		case "field_type_modified": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing) {
 				const fields = copySnapshotRecord(existing.fields);
 				fields[change.fieldName] = change.after;
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					fields
 				};
@@ -8612,24 +9191,41 @@ function applyDiffToSnapshot(snapshot, diff) {
 			break;
 		}
 		case "field_removed": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing) {
 				const remainingFields = copySnapshotRecord(existing.fields);
 				delete remainingFields[change.fieldName];
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					fields: remainingFields
 				};
 			}
 			break;
 		}
+		case "field_renamed": {
+			const existing = tables[change.tableName];
+			if (existing) {
+				const fields = copySnapshotRecord(existing.fields);
+				delete fields[change.previousFieldName];
+				fields[change.fieldName] = change.after;
+				tables[change.tableName] = {
+					...existing,
+					fields
+				};
+			}
+			break;
+		}
+		case "table_renamed":
+			delete tables[change.previousTableName];
+			tables[change.tableName] = change.after;
+			break;
 		case "index_added":
 		case "index_modified": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing) {
 				const indexes = copySnapshotRecord(existing.indexes);
 				indexes[change.indexName] = change.after;
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					indexes
 				};
@@ -8637,11 +9233,11 @@ function applyDiffToSnapshot(snapshot, diff) {
 			break;
 		}
 		case "index_removed": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing && existing.indexes) {
 				const remainingIndexes = copySnapshotRecord(existing.indexes);
 				delete remainingIndexes[change.indexName];
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					indexes: Object.keys(remainingIndexes).length > 0 ? remainingIndexes : void 0
 				};
@@ -8650,11 +9246,11 @@ function applyDiffToSnapshot(snapshot, diff) {
 		}
 		case "file_added":
 		case "file_modified": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing) {
 				const files = copySnapshotRecord(existing.files);
 				files[change.fieldName] = change.after;
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					files
 				};
@@ -8662,11 +9258,11 @@ function applyDiffToSnapshot(snapshot, diff) {
 			break;
 		}
 		case "file_removed": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing && existing.files) {
 				const remainingFiles = copySnapshotRecord(existing.files);
 				delete remainingFiles[change.fieldName];
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					files: Object.keys(remainingFiles).length > 0 ? remainingFiles : void 0
 				};
@@ -8675,20 +9271,20 @@ function applyDiffToSnapshot(snapshot, diff) {
 		}
 		case "relationship_added":
 		case "relationship_modified": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing) {
 				const rel = change.after;
 				if ((change.relationshipType ?? (existing.forwardRelationships?.[change.relationshipName] ? "forward" : existing.backwardRelationships?.[change.relationshipName] ? "backward" : "forward")) === "forward") {
 					const forwardRelationships = copySnapshotRecord(existing.forwardRelationships);
 					forwardRelationships[change.relationshipName] = rel;
-					types[change.typeName] = {
+					tables[change.tableName] = {
 						...existing,
 						forwardRelationships
 					};
 				} else {
 					const backwardRelationships = copySnapshotRecord(existing.backwardRelationships);
 					backwardRelationships[change.relationshipName] = rel;
-					types[change.typeName] = {
+					tables[change.tableName] = {
 						...existing,
 						backwardRelationships
 					};
@@ -8697,20 +9293,20 @@ function applyDiffToSnapshot(snapshot, diff) {
 			break;
 		}
 		case "relationship_removed": {
-			const type = types[change.typeName];
+			const type = tables[change.tableName];
 			if (type) {
 				const targetType = change.relationshipType ?? (type.forwardRelationships?.[change.relationshipName] ? "forward" : type.backwardRelationships?.[change.relationshipName] ? "backward" : null);
 				if (targetType === "forward" && type.forwardRelationships?.[change.relationshipName]) {
 					const remaining = copySnapshotRecord(type.forwardRelationships);
 					delete remaining[change.relationshipName];
-					types[change.typeName] = {
+					tables[change.tableName] = {
 						...type,
 						forwardRelationships: Object.keys(remaining).length > 0 ? remaining : void 0
 					};
 				} else if (targetType === "backward" && type.backwardRelationships?.[change.relationshipName]) {
 					const remaining = copySnapshotRecord(type.backwardRelationships);
 					delete remaining[change.relationshipName];
-					types[change.typeName] = {
+					tables[change.tableName] = {
 						...type,
 						backwardRelationships: Object.keys(remaining).length > 0 ? remaining : void 0
 					};
@@ -8719,10 +9315,10 @@ function applyDiffToSnapshot(snapshot, diff) {
 			break;
 		}
 		case "permission_modified": {
-			const existing = types[change.typeName];
+			const existing = tables[change.tableName];
 			if (existing && change.after) {
 				const after = change.after;
-				types[change.typeName] = {
+				tables[change.tableName] = {
 					...existing,
 					permissions: {
 						record: after.recordPermission,
@@ -8735,7 +9331,7 @@ function applyDiffToSnapshot(snapshot, diff) {
 	}
 	return normalizeSchemaSnapshot({
 		...snapshot,
-		types,
+		tables,
 		createdAt: diff.createdAt
 	});
 }
@@ -8797,13 +9393,7 @@ function assertMigrationNumberExists(migrationsDir, migrationNumber) {
 function areFieldsDifferent(oldField, newField) {
 	if (oldField.type !== newField.type) return true;
 	if (oldField.required !== newField.required) return true;
-	for (const prop of [
-		"array",
-		"index",
-		"unique",
-		"foreignKey",
-		"vector"
-	]) if ((oldField[prop] ?? false) !== (newField[prop] ?? false)) return true;
+	for (const prop of SNAPSHOT_FIELD_BOOLEAN_PROPS) if ((oldField[prop] ?? false) !== (newField[prop] ?? false)) return true;
 	if (oldField.foreignKeyType !== newField.foreignKeyType) return true;
 	if (oldField.foreignKeyField !== newField.foreignKeyField) return true;
 	if ((oldField.description ?? "") !== (newField.description ?? "")) return true;
@@ -8859,23 +9449,24 @@ function areFieldsDifferent(oldField, newField) {
 }
 /**
 * Collect breaking changes for a field change
-* @param {string} typeName - Name of the type containing the field
+* @param {string} tableName - Name of the type containing the field
 * @param {string} fieldName - Name of the field being changed
 * @param {SnapshotFieldConfig | undefined} oldField - Old field configuration
 * @param {SnapshotFieldConfig | undefined} newField - New field configuration
+* @param {ReadonlyMap<string, string>} [typeRenameTargets] - Confirmed type renames (old name → new name)
 * @returns {BreakingChangeInfo[]} Breaking change information
 */
-function getBreakingFieldChanges(typeName, fieldName, oldField, newField) {
+function getBreakingFieldChanges(tableName, fieldName, oldField, newField, typeRenameTargets) {
 	const breakingChanges = [];
 	if (!oldField && newField && newField.required) breakingChanges.push({
-		typeName,
+		tableName,
 		fieldName,
 		reason: "Required field added"
 	});
 	if (oldField && newField && oldField.type !== newField.type) {
 		const supported = supportsInPlaceFieldTypeChange(oldField, newField);
 		breakingChanges.push({
-			typeName,
+			tableName,
 			fieldName,
 			reason: `Field type changed from ${oldField.type} to ${newField.type}`,
 			...!supported && {
@@ -8885,36 +9476,32 @@ function getBreakingFieldChanges(typeName, fieldName, oldField, newField) {
 		});
 	}
 	if (oldField && newField && !oldField.required && newField.required) breakingChanges.push({
-		typeName,
+		tableName,
 		fieldName,
 		reason: "Field changed from optional to required"
 	});
 	if (oldField && newField && (oldField.array ?? false) !== (newField.array ?? false)) {
 		const [fromType, toType] = oldField.array ? ["array", "single value"] : ["single value", "array"];
 		breakingChanges.push({
-			typeName,
+			tableName,
 			fieldName,
 			reason: `Field changed from ${fromType} to ${toType}`,
 			unsupported: true,
 			showThreeStepHint: true
 		});
 	}
-	if (oldField && newField) {
-		const oldForeignKeyType = oldField.foreignKeyType;
-		const newForeignKeyType = newField.foreignKeyType;
-		if (oldForeignKeyType && newForeignKeyType && oldForeignKeyType !== newForeignKeyType) breakingChanges.push({
-			typeName,
-			fieldName,
-			reason: `Foreign key target type changed from ${oldForeignKeyType} to ${newForeignKeyType}`
-		});
-	}
+	if (oldField && newField && isBreakingForeignKeyRetarget(oldField, newField, typeRenameTargets)) breakingChanges.push({
+		tableName,
+		fieldName,
+		reason: `Foreign key target type changed from ${oldField.foreignKeyType} to ${newField.foreignKeyType}`
+	});
 	if (oldField && newField && !(oldField.unique ?? false) && (newField.unique ?? false)) breakingChanges.push({
-		typeName,
+		tableName,
 		fieldName,
 		reason: "Unique constraint added to field"
 	});
 	if (oldField?.type === "decimal" && newField?.type === "decimal" && oldField.scale !== newField.scale) breakingChanges.push({
-		typeName,
+		tableName,
 		fieldName,
 		reason: `Decimal scale changed from ${oldField.scale} to ${newField.scale}`
 	});
@@ -8925,7 +9512,7 @@ function getBreakingFieldChanges(typeName, fieldName, oldField, newField) {
 		const newValuesSet = new Set(newAllowed.map((v) => v.value));
 		const removedValues = oldValues.filter((v) => !newValuesSet.has(v));
 		if (removedValues.length > 0) breakingChanges.push({
-			typeName,
+			tableName,
 			fieldName,
 			reason: `Enum values removed: ${removedValues.join(", ")}`
 		});
@@ -8935,37 +9522,62 @@ function getBreakingFieldChanges(typeName, fieldName, oldField, newField) {
 function addChange(ctx, change, oldField, newField) {
 	ctx.changes.push(change);
 	if (!change.fieldName) return;
-	const breakingChanges = getBreakingFieldChanges(change.typeName, change.fieldName, oldField, newField);
+	const breakingChanges = getBreakingFieldChanges(change.tableName, change.fieldName, oldField, newField, ctx.typeRenameTargets);
 	if (breakingChanges.length > 0) {
 		ctx.breakingChanges.push(...breakingChanges);
 		return;
 	}
 	if (change.kind === "field_removed") ctx.warnings.push({
-		typeName: change.typeName,
+		tableName: change.tableName,
 		fieldName: change.fieldName,
 		reason: FIELD_REMOVED_WARNING_REASON
 	});
 }
-function compareTypeFields(ctx, typeName, prevType, currType) {
+function compareTypeFields(ctx, tableName, prevType, currType, fieldRenames = []) {
 	const prevFieldNames = new Set(Object.keys(prevType.fields));
 	const currFieldNames = new Set(Object.keys(currType.fields));
-	for (const fieldName of currFieldNames) if (!prevFieldNames.has(fieldName)) {
-		const currField = assertDefined(currType.fields[fieldName], `field "${fieldName}" missing from currType`);
-		addChange(ctx, {
-			kind: "field_added",
-			typeName,
-			fieldName,
+	const renamedFromNames = new Set(fieldRenames.map((r) => r.previousFieldName));
+	const renamedToNames = new Set(fieldRenames.map((r) => r.fieldName));
+	for (const rename of fieldRenames) {
+		const prevField = assertDefined(prevType.fields[rename.previousFieldName], `renamed field "${rename.previousFieldName}" missing from prevType`);
+		const currField = assertDefined(currType.fields[rename.fieldName], `renamed field "${rename.fieldName}" missing from currType`);
+		ctx.changes.push({
+			kind: "field_renamed",
+			tableName,
+			fieldName: rename.fieldName,
+			previousFieldName: rename.previousFieldName,
+			before: prevField,
 			after: currField
-		}, void 0, currField);
+		});
+		ctx.breakingChanges.push({
+			tableName,
+			fieldName: rename.fieldName,
+			reason: `Field renamed from ${rename.previousFieldName} to ${rename.fieldName} (existing values must be copied by the migration script)`
+		});
 	}
-	for (const fieldName of prevFieldNames) if (!currFieldNames.has(fieldName)) {
-		const prevField = assertDefined(prevType.fields[fieldName], `field "${fieldName}" missing from prevType`);
-		addChange(ctx, {
-			kind: "field_removed",
-			typeName,
-			fieldName,
-			before: prevField
-		}, prevField, void 0);
+	for (const fieldName of currFieldNames) {
+		if (renamedToNames.has(fieldName)) continue;
+		if (!prevFieldNames.has(fieldName)) {
+			const currField = assertDefined(currType.fields[fieldName], `field "${fieldName}" missing from currType`);
+			addChange(ctx, {
+				kind: "field_added",
+				tableName,
+				fieldName,
+				after: currField
+			}, void 0, currField);
+		}
+	}
+	for (const fieldName of prevFieldNames) {
+		if (renamedFromNames.has(fieldName)) continue;
+		if (!currFieldNames.has(fieldName)) {
+			const prevField = assertDefined(prevType.fields[fieldName], `field "${fieldName}" missing from prevType`);
+			addChange(ctx, {
+				kind: "field_removed",
+				tableName,
+				fieldName,
+				before: prevField
+			}, prevField, void 0);
+		}
 	}
 	for (const fieldName of currFieldNames) {
 		if (!prevFieldNames.has(fieldName)) continue;
@@ -8973,7 +9585,7 @@ function compareTypeFields(ctx, typeName, prevType, currType) {
 		const currField = assertDefined(currType.fields[fieldName], `field "${fieldName}" missing from currType`);
 		if (areFieldsDifferent(prevField, currField)) addChange(ctx, {
 			kind: prevField.type === currField.type ? "field_modified" : "field_type_modified",
-			typeName,
+			tableName,
 			fieldName,
 			before: prevField,
 			after: currField
@@ -8985,20 +9597,20 @@ function compareTypeFields(ctx, typeName, prevType, currType) {
 * unique reasoning: enforcing a unique constraint over existing rows can fail
 * on duplicates, so both adding a unique index and re-pointing an existing
 * unique index at a different field set require a data migration.
-* @param {string} typeName - Name of the type containing the index
+* @param {string} tableName - Name of the type containing the index
 * @param {string} indexName - Name of the index being changed
 * @param {SnapshotIndexConfig | undefined} oldIndex - Old index configuration
 * @param {SnapshotIndexConfig | undefined} newIndex - New index configuration
 * @returns {BreakingChangeInfo | null} Breaking change info or null if not breaking
 */
-function isBreakingIndexChange(typeName, indexName, oldIndex, newIndex) {
+function isBreakingIndexChange(tableName, indexName, oldIndex, newIndex) {
 	if (!newIndex || !(newIndex.unique ?? false)) return null;
 	if (!oldIndex || !(oldIndex.unique ?? false)) return {
-		typeName,
+		tableName,
 		reason: `Unique constraint added to index "${indexName}"`
 	};
 	if (JSON.stringify(oldIndex.fields.toSorted()) !== JSON.stringify(newIndex.fields.toSorted())) return {
-		typeName,
+		tableName,
 		reason: `Unique index fields changed on index "${indexName}"`
 	};
 	return null;
@@ -9006,27 +9618,27 @@ function isBreakingIndexChange(typeName, indexName, oldIndex, newIndex) {
 /**
 * Compare type-level indexes
 * @param {DiffContext} ctx - Diff context
-* @param {string} typeName - Type name
+* @param {string} tableName - Type name
 * @param {Record<string, SnapshotIndexConfig> | undefined} oldIndexes - Previous indexes
 * @param {Record<string, SnapshotIndexConfig> | undefined} newIndexes - Current indexes
 * @returns {void}
 */
-function compareIndexes(ctx, typeName, oldIndexes, newIndexes) {
+function compareIndexes(ctx, tableName, oldIndexes, newIndexes) {
 	const oldKeys = new Set(Object.keys(oldIndexes || {}));
 	const newKeys = new Set(Object.keys(newIndexes || {}));
 	for (const [indexName, indexConfig] of Object.entries(newIndexes ?? {})) if (!oldKeys.has(indexName)) {
 		ctx.changes.push({
 			kind: "index_added",
-			typeName,
+			tableName,
 			indexName,
 			after: indexConfig
 		});
-		const breaking = isBreakingIndexChange(typeName, indexName, void 0, indexConfig);
+		const breaking = isBreakingIndexChange(tableName, indexName, void 0, indexConfig);
 		if (breaking) ctx.breakingChanges.push(breaking);
 	}
 	for (const [indexName, indexConfig] of Object.entries(oldIndexes ?? {})) if (!newKeys.has(indexName)) ctx.changes.push({
 		kind: "index_removed",
-		typeName,
+		tableName,
 		indexName,
 		before: indexConfig
 	});
@@ -9040,13 +9652,13 @@ function compareIndexes(ctx, typeName, oldIndexes, newIndexes) {
 			if ((oldIndex.unique ?? false) !== (newIndex.unique ?? false)) reasons.push("unique constraint changed");
 			ctx.changes.push({
 				kind: "index_modified",
-				typeName,
+				tableName,
 				indexName,
 				reason: reasons.join(", "),
 				before: oldIndex,
 				after: newIndex
 			});
-			const breaking = isBreakingIndexChange(typeName, indexName, oldIndex, newIndex);
+			const breaking = isBreakingIndexChange(tableName, indexName, oldIndex, newIndex);
 			if (breaking) ctx.breakingChanges.push(breaking);
 		}
 	}
@@ -9054,23 +9666,23 @@ function compareIndexes(ctx, typeName, oldIndexes, newIndexes) {
 /**
 * Compare type-level file fields
 * @param {DiffContext} ctx - Diff context
-* @param {string} typeName - Type name
+* @param {string} tableName - Type name
 * @param {Record<string, string> | undefined} oldFiles - Previous file fields
 * @param {Record<string, string> | undefined} newFiles - Current file fields
 * @returns {void}
 */
-function compareFiles(ctx, typeName, oldFiles, newFiles) {
+function compareFiles(ctx, tableName, oldFiles, newFiles) {
 	const oldKeys = new Set(Object.keys(oldFiles || {}));
 	const newKeys = new Set(Object.keys(newFiles || {}));
 	for (const [fileName, fileDesc] of Object.entries(newFiles ?? {})) if (!oldKeys.has(fileName)) ctx.changes.push({
 		kind: "file_added",
-		typeName,
+		tableName,
 		fieldName: fileName,
 		after: fileDesc
 	});
 	for (const [fileName, fileDesc] of Object.entries(oldFiles ?? {})) if (!newKeys.has(fileName)) ctx.changes.push({
 		kind: "file_removed",
-		typeName,
+		tableName,
 		fieldName: fileName,
 		before: fileDesc
 	});
@@ -9078,7 +9690,7 @@ function compareFiles(ctx, typeName, oldFiles, newFiles) {
 		const oldDesc = assertDefined(assertDefined(oldFiles, "oldFiles is undefined when oldKeys has entry")[fileName], `file "${fileName}" missing from oldFiles`);
 		if (oldDesc !== newDesc) ctx.changes.push({
 			kind: "file_modified",
-			typeName,
+			tableName,
 			fieldName: fileName,
 			reason: "description changed",
 			before: oldDesc,
@@ -9089,25 +9701,25 @@ function compareFiles(ctx, typeName, oldFiles, newFiles) {
 /**
 * Compare type-level relationships
 * @param {DiffContext} ctx - Diff context
-* @param {string} typeName - Type name
+* @param {string} tableName - Type name
 * @param {"forward" | "backward"} relationshipType - Relationship direction to compare
 * @param {Record<string, SnapshotRelationship> | undefined} oldRelationships - Previous relationships
 * @param {Record<string, SnapshotRelationship> | undefined} newRelationships - Current relationships
 * @returns {void}
 */
-function compareRelationships(ctx, typeName, relationshipType, oldRelationships, newRelationships) {
+function compareRelationships(ctx, tableName, relationshipType, oldRelationships, newRelationships) {
 	const oldKeys = new Set(Object.keys(oldRelationships || {}));
 	const newKeys = new Set(Object.keys(newRelationships || {}));
 	for (const [relName, rel] of Object.entries(newRelationships ?? {})) if (!oldKeys.has(relName)) ctx.changes.push({
 		kind: "relationship_added",
-		typeName,
+		tableName,
 		relationshipName: relName,
 		relationshipType,
 		after: rel
 	});
 	for (const [relName, rel] of Object.entries(oldRelationships ?? {})) if (!newKeys.has(relName)) ctx.changes.push({
 		kind: "relationship_removed",
-		typeName,
+		tableName,
 		relationshipName: relName,
 		relationshipType,
 		before: rel
@@ -9122,7 +9734,7 @@ function compareRelationships(ctx, typeName, relationshipType, oldRelationships,
 		if (oldRel.description !== newRel.description) reasons.push("description changed");
 		if (reasons.length > 0) ctx.changes.push({
 			kind: "relationship_modified",
-			typeName,
+			tableName,
 			relationshipName: relName,
 			relationshipType,
 			reason: reasons.join(", "),
@@ -9134,14 +9746,14 @@ function compareRelationships(ctx, typeName, relationshipType, oldRelationships,
 /**
 * Compare type-level permissions
 * @param {DiffContext} ctx - Diff context
-* @param {string} typeName - Type name
+* @param {string} tableName - Type name
 * @param {SnapshotRecordPermission | undefined} oldRecordPerm - Previous record permission
 * @param {SnapshotRecordPermission | undefined} newRecordPerm - Current record permission
 * @param {SnapshotGqlPermission | undefined} oldGqlPerm - Previous GQL permission
 * @param {SnapshotGqlPermission | undefined} newGqlPerm - Current GQL permission
 * @returns {void}
 */
-function comparePermissions(ctx, typeName, oldRecordPerm, newRecordPerm, oldGqlPerm, newGqlPerm) {
+function comparePermissions(ctx, tableName, oldRecordPerm, newRecordPerm, oldGqlPerm, newGqlPerm) {
 	const oldComparableRecordPerm = comparableRecordPermission(oldRecordPerm);
 	const newComparableRecordPerm = comparableRecordPermission(newRecordPerm);
 	const recordPermChanged = JSON.stringify(oldComparableRecordPerm ?? null) !== JSON.stringify(newComparableRecordPerm ?? null);
@@ -9154,7 +9766,7 @@ function comparePermissions(ctx, typeName, oldRecordPerm, newRecordPerm, oldGqlP
 		if (gqlPermChanged) reasons.push("GQL permission");
 		ctx.changes.push({
 			kind: "permission_modified",
-			typeName,
+			tableName,
 			reason: `${reasons.join(" and ")} changed`,
 			before: {
 				recordPermission: oldComparableRecordPerm,
@@ -9234,13 +9846,13 @@ function comparableTypeSettings(type) {
 function snapshotTypeSettingsState(type) {
 	return typeSettingsState(type.description, type.pluralForm, type.settings ?? {});
 }
-function compareTypeSettings(ctx, typeName, previous, current) {
+function compareTypeSettings(ctx, tableName, previous, current) {
 	const previousComparable = comparableTypeSettings(previous);
 	const currentComparable = comparableTypeSettings(current);
 	if (JSON.stringify(previousComparable) === JSON.stringify(currentComparable)) return;
 	ctx.changes.push({
-		kind: "type_settings_modified",
-		typeName,
+		kind: "table_settings_modified",
+		tableName,
 		reason: "settings changed",
 		before: snapshotTypeSettingsState(previous),
 		after: snapshotTypeSettingsState(current)
@@ -9252,66 +9864,190 @@ function typeScriptsState(type) {
 		...type.typeValidateExpr !== void 0 && { typeValidateExpr: type.typeValidateExpr }
 	};
 }
-function compareTypeScripts(ctx, typeName, previous, current) {
+function compareTypeScripts(ctx, tableName, previous, current) {
 	const prevState = typeScriptsState(previous);
 	const currState = typeScriptsState(current);
 	if (JSON.stringify(prevState) === JSON.stringify(currState)) return;
 	ctx.changes.push({
-		kind: "type_scripts_modified",
-		typeName,
-		reason: "type-level scripts changed",
+		kind: "table_scripts_modified",
+		tableName,
+		reason: "table-level scripts changed",
 		before: prevState,
 		after: currState
 	});
 }
 /**
-* Compare two snapshots and generate a diff
-* @param {SchemaSnapshot} previous - Previous schema snapshot
-* @param {SchemaSnapshot} current - Current schema snapshot
+* Restate the schema an expand migration starts from, with each converted field
+* relaxed to optional.
+*
+* The expand script clears the original field once it has carried the value
+* across. That write reaches the field under the contract recorded on the
+* removal, which the deploy restores for the duration of the migration, so a
+* field left required would reject it.
+* @param previous - Snapshot the expand migration starts from
+* @param plans - Field changes carried through temporary fields
+* @returns Snapshot to compare the expand migration against
+*/
+function buildExpandBaseSnapshot(previous, plans) {
+	const tables = copySnapshotRecord(previous.tables);
+	for (const plan of plans) {
+		const type = tables[plan.tableName];
+		const original = type?.fields[plan.fieldName];
+		if (!type || !original) continue;
+		const fields = copySnapshotRecord(type.fields);
+		fields[plan.fieldName] = {
+			...original,
+			required: false
+		};
+		tables[plan.tableName] = {
+			...type,
+			fields
+		};
+	}
+	return normalizeSchemaSnapshot({
+		...previous,
+		tables
+	});
+}
+/**
+* Build the diff for the migration that converts values into temporary fields.
+*
+* Adding an optional field and removing one are both non-breaking, so nothing
+* in the comparison marks the script as required — yet it is the only thing
+* carrying the values across before the original field is dropped.
+* @param previous - Snapshot the expand migration starts from
+* @param intermediate - Snapshot the expand migration produces
+* @param plans - Field changes carried through temporary fields
+* @returns Diff to write for the expand migration
+*/
+function buildExpandDiff(previous, intermediate, plans) {
+	return {
+		...compareSnapshots(buildExpandBaseSnapshot(previous, plans), intermediate),
+		requiresMigrationScript: true
+	};
+}
+/**
+* Build the schema state that sits between an expand and a contract migration:
+* each converted field is replaced by its temporary counterpart.
+*
+* The original field is dropped here rather than in the contract migration so
+* the contract can reuse its name. It stays readable while the expand script
+* runs, because a field removed by a migration is retained until that same
+* migration's post phase.
+*
+* The temporary field is optional and non-unique regardless of its final
+* contract, since the expand script fills it in batches.
+* @param previous - Snapshot the expand migration starts from
+* @param plans - Field changes carried through temporary fields
+* @returns Snapshot the contract migration compares against
+*/
+function buildIntermediateSnapshot(previous, plans) {
+	const tables = copySnapshotRecord(previous.tables);
+	for (const plan of plans) {
+		const type = tables[plan.tableName];
+		if (!type) continue;
+		const fields = copySnapshotRecord(type.fields);
+		const { hooks: _hooks, validate: _validate, ...carried } = plan.after;
+		fields[plan.tempFieldName] = {
+			...carried,
+			required: false,
+			unique: false
+		};
+		delete fields[plan.fieldName];
+		tables[plan.tableName] = {
+			...type,
+			fields
+		};
+	}
+	return normalizeSchemaSnapshot({
+		...previous,
+		tables
+	});
+}
+/**
+* Compare two normalized snapshots and generate a diff
+* @param {NormalizedSchemaSnapshot} previous - Previous normalized snapshot
+* @param {NormalizedSchemaSnapshot} current - Current normalized snapshot
+* @param {CompareSnapshotsOptions} [options] - Comparison options
 * @returns {MigrationDiff} Migration diff between snapshots
 */
-function compareSnapshots(previous, current) {
-	return compareNormalizedSnapshots(normalizeSchemaSnapshot(previous), normalizeSchemaSnapshot(current));
-}
-function compareNormalizedSnapshots(previous, current) {
+function compareSnapshots(previous, current, options) {
+	const fieldRenames = options?.fieldRenames ?? [];
+	assertValidFieldRenames(previous, current, fieldRenames);
+	const renamesByType = /* @__PURE__ */ new Map();
+	for (const rename of fieldRenames) {
+		const list = renamesByType.get(rename.tableName) ?? [];
+		list.push(rename);
+		renamesByType.set(rename.tableName, list);
+	}
+	const typeRenames = options?.typeRenames ?? [];
+	assertValidTypeRenames(previous, current, typeRenames);
+	const typeRenameTargets = new Map(typeRenames.map((r) => [r.previousTableName, r.tableName]));
+	const renamedToTypeNames = new Set(typeRenames.map((r) => r.tableName));
 	const ctx = {
 		changes: [],
 		breakingChanges: [],
-		warnings: []
-	};
-	const previousTypeNames = new Set(Object.keys(previous.types));
-	const currentTypeNames = new Set(Object.keys(current.types));
-	for (const [typeName, type] of Object.entries(current.types)) if (!previousTypeNames.has(typeName)) ctx.changes.push({
-		kind: "type_added",
-		typeName,
-		after: type
-	});
-	for (const [typeName, type] of Object.entries(previous.types)) if (!currentTypeNames.has(typeName)) {
+		warnings: [],
+		typeRenameTargets
+	};
+	const previousTypeNames = new Set(Object.keys(previous.tables));
+	const currentTypeNames = new Set(Object.keys(current.tables));
+	for (const rename of typeRenames) {
+		const prevType = assertDefined(previous.tables[rename.previousTableName], `renamed type "${rename.previousTableName}" missing from previous snapshot`);
+		const currType = assertDefined(current.tables[rename.tableName], `renamed type "${rename.tableName}" missing from current snapshot`);
 		ctx.changes.push({
-			kind: "type_removed",
-			typeName,
-			before: type
-		});
-		ctx.warnings.push({
-			typeName,
-			reason: TYPE_REMOVED_WARNING_REASON
-		});
-	}
-	for (const typeName of currentTypeNames) {
-		if (!previousTypeNames.has(typeName)) continue;
-		const prevType = assertDefined(previous.types[typeName], `type "${typeName}" missing from previous snapshot`);
-		const currType = assertDefined(current.types[typeName], `type "${typeName}" missing from current snapshot`);
-		compareTypeSettings(ctx, typeName, prevType, currType);
-		compareTypeScripts(ctx, typeName, prevType, currType);
-		compareTypeFields(ctx, typeName, prevType, currType);
-		compareIndexes(ctx, typeName, prevType.indexes, currType.indexes);
-		compareFiles(ctx, typeName, prevType.files, currType.files);
-		compareRelationships(ctx, typeName, "forward", prevType.forwardRelationships, currType.forwardRelationships);
-		compareRelationships(ctx, typeName, "backward", prevType.backwardRelationships, currType.backwardRelationships);
-		comparePermissions(ctx, typeName, prevType.permissions?.record, currType.permissions?.record, prevType.permissions?.gql, currType.permissions?.gql);
+			kind: "table_renamed",
+			tableName: rename.tableName,
+			previousTableName: rename.previousTableName,
+			before: prevType,
+			after: currType
+		});
+		ctx.breakingChanges.push({
+			tableName: rename.tableName,
+			reason: `Type renamed from ${rename.previousTableName} to ${rename.tableName} (existing records must be copied by the migration script)`
+		});
+		ctx.breakingChanges.push({
+			tableName: rename.tableName,
+			reason: `GraphQL API names derived from ${rename.previousTableName}/${prevType.pluralForm} change to ${rename.tableName}/${currType.pluralForm} — breaking for API clients`
+		});
+	}
+	for (const [tableName, type] of Object.entries(current.tables)) {
+		if (renamedToTypeNames.has(tableName)) continue;
+		if (!previousTypeNames.has(tableName)) ctx.changes.push({
+			kind: "table_added",
+			tableName,
+			after: type
+		});
+	}
+	for (const [tableName, type] of Object.entries(previous.tables)) {
+		if (typeRenameTargets.has(tableName)) continue;
+		if (!currentTypeNames.has(tableName)) {
+			ctx.changes.push({
+				kind: "table_removed",
+				tableName,
+				before: type
+			});
+			ctx.warnings.push({
+				tableName,
+				reason: TABLE_REMOVED_WARNING_REASON
+			});
+		}
+	}
+	for (const tableName of currentTypeNames) {
+		if (!previousTypeNames.has(tableName)) continue;
+		const prevType = assertDefined(previous.tables[tableName], `type "${tableName}" missing from previous snapshot`);
+		const currType = assertDefined(current.tables[tableName], `type "${tableName}" missing from current snapshot`);
+		compareTypeSettings(ctx, tableName, prevType, currType);
+		compareTypeScripts(ctx, tableName, prevType, currType);
+		compareTypeFields(ctx, tableName, prevType, currType, renamesByType.get(tableName));
+		compareIndexes(ctx, tableName, prevType.indexes, currType.indexes);
+		compareFiles(ctx, tableName, prevType.files, currType.files);
+		compareRelationships(ctx, tableName, "forward", prevType.forwardRelationships, currType.forwardRelationships);
+		compareRelationships(ctx, tableName, "backward", prevType.backwardRelationships, currType.backwardRelationships);
+		comparePermissions(ctx, tableName, prevType.permissions?.record, currType.permissions?.record, prevType.permissions?.gql, currType.permissions?.gql);
 	}
 	return {
-		version: 2,
+		version: 5,
 		namespace: current.namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 		changes: ctx.changes,
@@ -9325,8 +10061,8 @@ function compareNormalizedSnapshots(previous, current) {
 /**
 * Compare a snapshot against canonical TailorDBSnapshotType-shaped local types.
 * Callers are expected to pre-convert TailorDBService.types to TailorDBSnapshotType via
-* `createSnapshotType`. As a safety net, `compareSnapshots` re-runs idempotent
-* normalization on both sides, so a caller that forgets will still get correct
+* `createSnapshotType`. As a safety net, both sides are re-run through idempotent
+* normalization here, so a caller that forgets will still get correct
 * comparisons (no silent false drift).
 * @param {SchemaSnapshot} snapshot - Schema snapshot to compare against
 * @param {Record<string, TailorDBSnapshotType>} localTypes - Local snapshot-shaped types
@@ -9334,12 +10070,13 @@ function compareNormalizedSnapshots(previous, current) {
 * @returns {MigrationDiff} Migration diff
 */
 function compareLocalTypesWithSnapshot(snapshot, localTypes, namespace) {
-	return compareSnapshots(snapshot, {
-		version: 2,
+	const currentSnapshot = {
+		version: 5,
 		namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		types: localTypes
-	});
+		tables: localTypes
+	};
+	return compareSnapshots(normalizeSchemaSnapshot(snapshot), normalizeSchemaSnapshot(currentSnapshot));
 }
 /**
 * Validate migration files in a directory
@@ -9640,11 +10377,11 @@ function convertRemoteTypeToSnapshot(remoteType, expectedType) {
 * @returns {NormalizedSchemaSnapshot} Normalized snapshot-shaped remote state
 */
 function createSnapshotFromRemoteTypes(remoteTypes, namespace, remoteGqlPermissions = [], expectedSnapshot) {
-	const types = createSnapshotRecord();
-	for (const remoteType of remoteTypes) types[remoteType.name] = convertRemoteTypeToSnapshot(remoteType, expectedSnapshot?.types[remoteType.name]);
+	const tables = createSnapshotRecord();
+	for (const remoteType of remoteTypes) tables[remoteType.name] = convertRemoteTypeToSnapshot(remoteType, expectedSnapshot?.tables[remoteType.name]);
 	for (const permission of remoteGqlPermissions) {
-		const { typeName } = permission;
-		const snapshotType = types[typeName];
+		const { typeName: tableName } = permission;
+		const snapshotType = tables[tableName];
 		if (!snapshotType) continue;
 		const gqlPermission = convertRemoteGqlPermissionToSnapshot(permission.permission);
 		if (!gqlPermission) continue;
@@ -9654,10 +10391,10 @@ function createSnapshotFromRemoteTypes(remoteTypes, namespace, remoteGqlPermissi
 		};
 	}
 	return normalizeSchemaSnapshot({
-		version: 2,
+		version: 5,
 		namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		types
+		tables
 	});
 }
 function fieldDifferenceValue(value) {
@@ -9744,13 +10481,7 @@ function addNestedFieldDifferences(differences, prefix, remoteField, snapshotFie
 function addFieldDifferences(differences, prefix, remoteField, snapshotField) {
 	addFieldDifference(differences, prefix, "type", remoteField.type, snapshotField.type);
 	addFieldDifference(differences, prefix, "required", remoteField.required, snapshotField.required);
-	for (const key of [
-		"array",
-		"index",
-		"unique",
-		"foreignKey",
-		"vector"
-	]) addBooleanFieldDifference(differences, prefix, key, remoteField, snapshotField);
+	for (const key of SNAPSHOT_FIELD_BOOLEAN_PROPS) addBooleanFieldDifference(differences, prefix, key, remoteField, snapshotField);
 	addFieldDifference(differences, prefix, "foreignKeyType", remoteField.foreignKeyType, snapshotField.foreignKeyType);
 	addFieldDifference(differences, prefix, "foreignKeyField", remoteField.foreignKeyField, snapshotField.foreignKeyField);
 	addFieldDifference(differences, prefix, "description", remoteField.description ?? "", snapshotField.description ?? "");
@@ -9763,17 +10494,17 @@ function addFieldDifferences(differences, prefix, remoteField, snapshotField) {
 }
 /**
 * Compare a single field between remote and snapshot
-* @param {string} typeName - Name of the type
+* @param {string} tableName - Name of the type
 * @param {string} fieldName - Name of the field
 * @param {SnapshotFieldConfig} remoteField - Remote field config
 * @param {SnapshotFieldConfig} snapshotField - Snapshot field config
 * @returns {SchemaDrift | null} Drift info or null if fields match
 */
-function compareFields(typeName, fieldName, remoteField, snapshotField) {
+function compareFields(tableName, fieldName, remoteField, snapshotField) {
 	const differences = [];
 	addFieldDifferences(differences, "", remoteField, snapshotField);
 	if (differences.length > 0) return {
-		typeName,
+		tableName,
 		kind: "field_mismatch",
 		fieldName,
 		details: differences.join("; ")
@@ -9819,24 +10550,24 @@ function remoteHasScripts(remoteType) {
 function compareScriptHashes(remoteTypes, snapshot) {
 	const drifts = [];
 	const remoteByName = new Map(remoteTypes.map((t) => [t.name, t]));
-	for (const [typeName, snapshotType] of Object.entries(snapshot.types)) {
+	for (const [tableName, snapshotType] of Object.entries(snapshot.tables)) {
 		const localHash = computeSourceScriptHash(snapshotType.fields, {
 			typeHookExpr: snapshotType.typeHookExpr,
 			typeValidateExpr: snapshotType.typeValidateExpr
 		});
-		const remoteType = remoteByName.get(typeName);
+		const remoteType = remoteByName.get(tableName);
 		if (!remoteType) continue;
 		if (localHash) {
 			const remoteHash = extractRemoteScriptHash(remoteType);
 			if (localHash !== remoteHash) drifts.push({
-				typeName,
+				tableName,
 				kind: "script_mismatch",
-				details: remoteHash ? `Type '${typeName}' scripts differ between remote and snapshot` : `Type '${typeName}' has no script hash on remote`
+				details: remoteHash ? `Type '${tableName}' scripts differ between remote and snapshot` : `Type '${tableName}' has no script hash on remote`
 			});
 		} else if (remoteHasScripts(remoteType)) drifts.push({
-			typeName,
+			tableName,
 			kind: "script_mismatch",
-			details: `Type '${typeName}' has scripts on remote but not in snapshot`
+			details: `Type '${tableName}' has scripts on remote but not in snapshot`
 		});
 	}
 	return drifts;
@@ -9854,27 +10585,27 @@ function stripFieldScriptProps(field) {
 	return rest;
 }
 function createRemoteComparableSnapshot(snapshot) {
-	const types = createSnapshotRecord();
-	for (const [typeName, type] of Object.entries(snapshot.types)) {
+	const tables = createSnapshotRecord();
+	for (const [tableName, type] of Object.entries(snapshot.tables)) {
 		const fields = createSnapshotRecord();
 		for (const [fieldName, field] of Object.entries(type.fields)) {
 			if (SYSTEM_FIELDS.has(fieldName)) continue;
 			fields[fieldName] = stripFieldScriptProps(field);
 		}
 		const { typeHookExpr: _, typeValidateExpr: __, ...typeRest } = type;
-		types[typeName] = {
+		tables[tableName] = {
 			...typeRest,
 			fields
 		};
 	}
 	return normalizeSchemaSnapshot({
 		...snapshot,
-		types
+		tables
 	});
 }
 function fieldDriftFromChange(change) {
-	return compareFields(change.typeName, change.fieldName, change.before, change.after) ?? {
-		typeName: change.typeName,
+	return compareFields(change.tableName, change.fieldName, change.before, change.after) ?? {
+		tableName: change.tableName,
 		kind: "field_mismatch",
 		fieldName: change.fieldName,
 		details: `Field '${change.fieldName}' differs between remote and snapshot`
@@ -9882,100 +10613,111 @@ function fieldDriftFromChange(change) {
 }
 function schemaDriftFromDiffChange(change) {
 	switch (change.kind) {
-		case "type_added": return {
-			typeName: change.typeName,
+		case "table_added": return {
+			tableName: change.tableName,
 			kind: "type_missing_remote",
-			details: `Type '${change.typeName}' exists in snapshot but not in remote`
+			details: `Type '${change.tableName}' exists in snapshot but not in remote`
 		};
-		case "type_removed": return {
-			typeName: change.typeName,
+		case "table_removed": return {
+			tableName: change.tableName,
 			kind: "type_missing_local",
-			details: `Type '${change.typeName}' exists in remote but not in snapshot`
+			details: `Type '${change.tableName}' exists in remote but not in snapshot`
+		};
+		case "table_renamed": return {
+			tableName: change.tableName,
+			kind: "type_settings_mismatch",
+			details: `Type '${change.previousTableName}' was renamed to '${change.tableName}'`
 		};
-		case "type_settings_modified":
-		case "type_modified": return {
-			typeName: change.typeName,
+		case "table_settings_modified":
+		case "table_modified": return {
+			tableName: change.tableName,
 			kind: "type_settings_mismatch",
 			details: change.reason ?? "Type settings differ between remote and snapshot"
 		};
 		case "field_added": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "field_missing_remote",
 			fieldName: change.fieldName,
 			details: `Field '${change.fieldName}' exists in snapshot but not in remote`
 		};
 		case "field_removed": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "field_missing_local",
 			fieldName: change.fieldName,
 			details: `Field '${change.fieldName}' exists in remote but not in snapshot`
 		};
 		case "field_modified":
 		case "field_type_modified": return fieldDriftFromChange(change);
+		case "field_renamed": return {
+			tableName: change.tableName,
+			kind: "field_mismatch",
+			fieldName: change.fieldName,
+			details: `Field '${change.previousFieldName}' was renamed to '${change.fieldName}'`
+		};
 		case "index_added": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "index_missing_remote",
 			indexName: change.indexName,
 			details: `Index '${change.indexName}' exists in snapshot but not in remote`
 		};
 		case "index_removed": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "index_missing_local",
 			indexName: change.indexName,
 			details: `Index '${change.indexName}' exists in remote but not in snapshot`
 		};
 		case "index_modified": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "index_mismatch",
 			indexName: change.indexName,
 			details: change.reason ?? `Index '${change.indexName}' differs between remote and snapshot`
 		};
 		case "file_added": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "file_missing_remote",
 			fileName: change.fieldName,
 			details: `File '${change.fieldName}' exists in snapshot but not in remote`
 		};
 		case "file_removed": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "file_missing_local",
 			fileName: change.fieldName,
 			details: `File '${change.fieldName}' exists in remote but not in snapshot`
 		};
 		case "file_modified": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "file_mismatch",
 			fileName: change.fieldName,
 			details: change.reason ?? `File '${change.fieldName}' differs between remote and snapshot`
 		};
 		case "relationship_added": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "relationship_missing_remote",
 			relationshipName: change.relationshipName,
 			relationshipType: change.relationshipType,
 			details: `Relationship '${change.relationshipName}' exists in snapshot but not in remote`
 		};
 		case "relationship_removed": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "relationship_missing_local",
 			relationshipName: change.relationshipName,
 			relationshipType: change.relationshipType,
 			details: `Relationship '${change.relationshipName}' exists in remote but not in snapshot`
 		};
 		case "relationship_modified": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "relationship_mismatch",
 			relationshipName: change.relationshipName,
 			relationshipType: change.relationshipType,
 			details: change.reason ?? `Relationship '${change.relationshipName}' differs between remote and snapshot`
 		};
 		case "permission_modified": return {
-			typeName: change.typeName,
+			tableName: change.tableName,
 			kind: "permission_mismatch",
 			details: change.reason ?? "Permissions differ between remote and snapshot"
 		};
-		case "type_scripts_modified": return {
-			typeName: change.typeName,
+		case "table_scripts_modified": return {
+			tableName: change.tableName,
 			kind: "script_mismatch",
 			details: change.reason ?? "Type-level scripts differ between remote and snapshot"
 		};
@@ -9983,7 +10725,7 @@ function schemaDriftFromDiffChange(change) {
 	}
 }
 function compareNormalizedRemoteWithSnapshot(remoteSnapshot, snapshot) {
-	return compareNormalizedSnapshots(remoteSnapshot, snapshot).changes.map(schemaDriftFromDiffChange);
+	return compareSnapshots(remoteSnapshot, snapshot).changes.map(schemaDriftFromDiffChange);
 }
 /**
 * Format schema drifts for display
@@ -9995,12 +10737,12 @@ function formatSchemaDrifts(drifts) {
 	const lines = [];
 	const driftsByType = /* @__PURE__ */ new Map();
 	for (const drift of drifts) {
-		const existing = driftsByType.get(drift.typeName) ?? [];
+		const existing = driftsByType.get(drift.tableName) ?? [];
 		existing.push(drift);
-		driftsByType.set(drift.typeName, existing);
+		driftsByType.set(drift.tableName, existing);
 	}
-	for (const [typeName, typeDrifts] of driftsByType) {
-		lines.push(`  Type '${typeName}':`);
+	for (const [tableName, typeDrifts] of driftsByType) {
+		lines.push(`  Type '${tableName}':`);
 		for (const drift of typeDrifts) if (drift.fieldName) lines.push(`    - Field '${drift.fieldName}': ${drift.details}`);
 		else if (drift.indexName) lines.push(`    - Index '${drift.indexName}': ${drift.details}`);
 		else if (drift.fileName) lines.push(`    - File '${drift.fileName}': ${drift.details}`);
@@ -10014,12 +10756,7 @@ function formatSchemaDrifts(drifts) {
 
 //#endregion
 //#region src/cli/commands/tailordb/migrate/file-state.ts
-const MIGRATION_FILE_KINDS = [
-	"schema",
-	"diff",
-	"migrate",
-	"db"
-];
+const MIGRATION_FILE_KINDS = Object.keys(MIGRATION_FILE_NAMES);
 function getMigrationArtifactNumbers(migrationsDir) {
 	if (!fs$2.existsSync(migrationsDir)) return [];
 	return fs$2.readdirSync(migrationsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && MIGRATION_NUMBER_PATTERN.test(entry.name)).map((entry) => Number.parseInt(entry.name, 10)).filter((migrationNumber) => MIGRATION_FILE_KINDS.some((kind) => fs$2.existsSync(getMigrationFilePath(migrationsDir, migrationNumber, kind)))).toSorted((a, b) => a - b);
@@ -10391,7 +11128,7 @@ function convertOperandToProto(operand) {
 function generateAllTypeManifestsFromSnapshot(snapshot, options = {}) {
 	const manifests = /* @__PURE__ */ new Map();
 	const { executorUsedTypes, ...baseOptions } = options;
-	for (const [typeName, snapshotType] of Object.entries(snapshot.types)) {
+	for (const [typeName, snapshotType] of Object.entries(snapshot.tables)) {
 		const typeOptions = {
 			...baseOptions,
 			subscribed: executorUsedTypes?.has(typeName) ?? false
@@ -10407,7 +11144,7 @@ function generateAllTypeManifestsFromSnapshot(snapshot, options = {}) {
 * @returns {SnapshotTypeComparison} Comparison result
 */
 function compareSnapshotWithRemote(snapshot, existingTypeNames) {
-	const snapshotTypeNames = new Set(Object.keys(snapshot.types));
+	const snapshotTypeNames = new Set(Object.keys(snapshot.tables));
 	const creates = [];
 	const updates = [];
 	const deletes = [];
@@ -10531,6 +11268,8 @@ function protoGqlOperand(operand) {
 * - `field_added` with `required: true`: relax to `required: false`.
 * - `field_modified` optional→required, unique constraint added, enum
 *   value removed: keep the looser side until Post-phase.
+* - `field_renamed`: keep the old field (readable by migrate.ts) and relax
+*   the new field's required/unique constraints until Post-phase.
 * - `field_type_modified`: keep the complete previous field config until
 *   Post-phase so migrate.ts runs against the previous type contract.
 *
@@ -10540,8 +11279,11 @@ function protoGqlOperand(operand) {
 * - `index_modified` that gains a unique constraint or re-points a unique
 *   index at different fields: keep the previous definition until Post-phase.
 *
-* Type-level deletions (`type_removed`) are handled by the deploy flow,
-* which retains the type until Post-phase rather than via this module.
+* Type-level deletions (`table_removed`) and renames (`table_renamed`) are
+* handled by the deploy flow rather than via this module: the old type is
+* retained until Post-phase, and a renamed type's new type is created with
+* its full constraints in the Pre-phase (the copy script writes complete
+* rows, so nothing needs relaxing).
 *
 * Post-phase then sends the final schema, after migrate.ts has had a chance
 * to fix up data.
@@ -10553,7 +11295,8 @@ const PRE_MIGRATION_FIELD_KINDS = /* @__PURE__ */ new Set([
 	"field_added",
 	"field_modified",
 	"field_type_modified",
-	"field_removed"
+	"field_removed",
+	"field_renamed"
 ]);
 /**
 * Type guard: is the change a field-level change that needs pre-migration
@@ -10599,16 +11342,16 @@ function createPreMigrationSnapshotType(snapshotType, typeChanges, typeScriptsCh
 /**
 * Build a map of field changes that require pre-migration schema adjustment.
 * @param {PendingMigration[]} pendingMigrations - Pending migrations to scan
-* @returns {PreMigrationChangesMap} Map of changes keyed by typeName/fieldName
+* @returns {PreMigrationChangesMap} Map of changes keyed by tableName/fieldName
 */
 function buildPreMigrationChangesMap(pendingMigrations) {
 	const map = /* @__PURE__ */ new Map();
 	for (const migration of pendingMigrations) for (const change of migration.diff.changes) {
 		if (!isPreMigrationFieldChange(change)) continue;
 		if (!change.fieldName) continue;
-		const perType = map.get(change.typeName) ?? /* @__PURE__ */ new Map();
+		const perType = map.get(change.tableName) ?? /* @__PURE__ */ new Map();
 		perType.set(change.fieldName, change);
-		map.set(change.typeName, perType);
+		map.set(change.tableName, perType);
 	}
 	return map;
 }
@@ -10631,6 +11374,15 @@ function applyPreMigrationFieldAdjustments(fields, typeChanges) {
 			fields[fieldName] = convertFieldConfigToProto(change.before);
 			continue;
 		}
+		if (change.kind === "field_renamed") {
+			fields[change.previousFieldName] = convertFieldConfigToProto(change.before);
+			const newField = fields[fieldName];
+			if (newField) {
+				if (change.after.required) newField.required = false;
+				if (change.after.unique ?? false) newField.unique = false;
+			}
+			continue;
+		}
 		const field = fields[fieldName];
 		if (!field) continue;
 		if (change.kind === "field_added") {
@@ -10662,17 +11414,17 @@ function applyPreMigrationFieldAdjustments(fields, typeChanges) {
 * Build a map of type-level index changes that require pre-migration schema
 * adjustment (the breaking ones — see {@link isBreakingIndexChange}).
 * @param {PendingMigration[]} pendingMigrations - Pending migrations to scan
-* @returns {PreMigrationIndexChangesMap} Map of changes keyed by typeName/indexName
+* @returns {PreMigrationIndexChangesMap} Map of changes keyed by tableName/indexName
 */
 function buildPreMigrationIndexChangesMap(pendingMigrations) {
 	const map = /* @__PURE__ */ new Map();
 	for (const migration of pendingMigrations) for (const change of migration.diff.changes) {
 		if (change.kind !== "index_added" && change.kind !== "index_modified") continue;
 		const before = change.kind === "index_modified" ? change.before : void 0;
-		if (!isBreakingIndexChange(change.typeName, change.indexName, before, change.after)) continue;
-		const perType = map.get(change.typeName) ?? /* @__PURE__ */ new Map();
+		if (!isBreakingIndexChange(change.tableName, change.indexName, before, change.after)) continue;
+		const perType = map.get(change.tableName) ?? /* @__PURE__ */ new Map();
 		perType.set(change.indexName, change);
-		map.set(change.typeName, perType);
+		map.set(change.tableName, perType);
 	}
 	return map;
 }
@@ -10841,8 +11593,8 @@ function appliedConfiguredDisabledGqlOperations(remoteDisabled, configuredDisabl
 function deployComparableSnapshot(snapshot, remoteTypes, gqlOperations) {
 	const remoteTypesByName = new Map(remoteTypes.map((type) => [type.name, type]));
 	const configuredDisabled = configuredDisabledGqlOperations(gqlOperations);
-	const types = {};
-	for (const [typeName, type] of Object.entries(snapshot.types)) {
+	const tables = {};
+	for (const [typeName, type] of Object.entries(snapshot.tables)) {
 		const settings = { ...type.settings };
 		const remoteSettings = remoteTypesByName.get(typeName)?.schema?.settings;
 		if (type.settings?.publishEvents === void 0 && remoteSettings?.publishRecordEvents) settings.publishEvents = true;
@@ -10854,11 +11606,11 @@ function deployComparableSnapshot(snapshot, remoteTypes, gqlOperations) {
 		const comparableSettings = definedWhenNotEmpty(settings);
 		if (comparableSettings) comparableType.settings = comparableSettings;
 		else delete comparableType.settings;
-		types[typeName] = comparableType;
+		tables[typeName] = comparableType;
 	}
 	return {
 		...snapshot,
-		types
+		tables
 	};
 }
 /**
@@ -11431,8 +12183,12 @@ async function detectPendingMigrations(client, workspaceId, namespacesWithMigrat
 			}
 			if (diff.scriptSkipped) {
 				const migrationLabel = `${namespace}/${formatMigrationNumber(file.number)}`;
-				if (hasScript) logger.warn(`Migration ${migrationLabel} has both a skip acknowledgment and migrate.ts; executing migrate.ts.`);
-				else logger.info(`Migration ${migrationLabel} runs without a script (skip acknowledged at ${diff.scriptSkipped.acknowledgedAt}: ${diff.scriptSkipped.reason})`);
+				if (hasScript) throw new Error(`Migration ${migrationLabel} has both a --no-script skip acknowledgment and migrate.ts.\nTo resolve, either:\n  - Keep the script and clear the stale acknowledgment: ${formatMigrationScriptCommand({
+					migrationNumber: file.number,
+					namespace,
+					configPath
+				})}\n  - Or keep the skip: delete migrate.ts`);
+				logger.info(`Migration ${migrationLabel} runs without a script (skip acknowledged at ${diff.scriptSkipped.acknowledgedAt}: ${diff.scriptSkipped.reason})`);
 			}
 			pendingMigrations.push({
 				number: file.number,
@@ -11848,17 +12604,20 @@ async function applyTailorDB(client, result, phase = "create-update") {
 */
 function getAffectedTypeNames(migration) {
 	const typeNames = /* @__PURE__ */ new Set();
-	for (const change of migration.diff.changes) typeNames.add(change.typeName);
+	for (const change of migration.diff.changes) typeNames.add(change.tableName);
 	return typeNames;
 }
 /**
-* Get the set of type names to be deleted by a migration
+* Get the set of type names to be deleted by a migration. A renamed type's
+* old name is included: the old type survives the Pre-phase and the script
+* (which copies its rows into the new type), then is dropped here.
 * @param {PendingMigration} migration - Pending migration
 * @returns {Set<string>} Set of type names to delete
 */
 function getDeletedTypeNames(migration) {
 	const typeNames = /* @__PURE__ */ new Set();
-	for (const change of migration.diff.changes) if (change.kind === "type_removed") typeNames.add(change.typeName);
+	for (const change of migration.diff.changes) if (change.kind === "table_removed") typeNames.add(change.tableName);
+	else if (change.kind === "table_renamed") typeNames.add(change.previousTableName);
 	return typeNames;
 }
 /**
@@ -11911,11 +12670,11 @@ const migrationSnapshotCache = {
 		return snapshot;
 	}
 };
-function buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges) {
-	const snapshotType = migrationSnapshotCache.load(migration).types[typeName];
+function buildSnapshotTypeManifest(migration, tableName, tailorDBInputs, executorUsedTypes, typeChanges) {
+	const snapshotType = migrationSnapshotCache.load(migration).tables[tableName];
 	if (!snapshotType) return void 0;
 	const input = tailorDBInputs.find((i) => i.namespace === migration.namespace);
-	const typeScriptsChange = migration.diff.changes.find((change) => change.kind === "type_scripts_modified" && change.typeName === typeName);
+	const typeScriptsChange = migration.diff.changes.find((change) => change.kind === "table_scripts_modified" && change.tableName === tableName);
 	return generateTailorDBTypeManifestFromSnapshot(typeChanges ? createPreMigrationSnapshotType(snapshotType, typeChanges, typeScriptsChange) : snapshotType, {
 		subscribed: executorUsedTypes.has(snapshotType.name),
 		namespaceGqlOperations: input?.config.gqlOperations
@@ -11947,30 +12706,30 @@ async function executeSingleMigrationPrePhase(client, changeSet, migration, tail
 	const affectedTypes = getAffectedTypeNames(migration);
 	const createdBeforeMigration = new Set(processedTypes.created);
 	for (const create of changeSet.type.creates) {
-		const typeName = create.request.tailordbType?.name;
-		if (!typeName || !affectedTypes.has(typeName) || createdBeforeMigration.has(typeName)) continue;
-		const typeChanges = preMigrationChanges.get(typeName);
-		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges);
+		const tableName = create.request.tailordbType?.name;
+		if (!tableName || !affectedTypes.has(tableName) || createdBeforeMigration.has(tableName)) continue;
+		const typeChanges = preMigrationChanges.get(tableName);
+		const snapshotType = buildSnapshotTypeManifest(migration, tableName, tailorDBInputs, executorUsedTypes, typeChanges);
 		if (!snapshotType) continue;
 		const clonedRequest = structuredClone(create.request);
 		clonedRequest.tailordbType = snapshotType;
 		if (typeChanges && typeChanges.size > 0 && clonedRequest.tailordbType.schema?.fields) applyPreMigrationFieldAdjustments(clonedRequest.tailordbType.schema.fields, typeChanges);
-		const indexChanges = preMigrationIndexChanges.get(typeName);
+		const indexChanges = preMigrationIndexChanges.get(tableName);
 		if (indexChanges && indexChanges.size > 0 && clonedRequest.tailordbType.schema?.indexes) applyPreMigrationIndexAdjustments(clonedRequest.tailordbType.schema.indexes, indexChanges);
-		processedTypes.created.add(typeName);
+		processedTypes.created.add(tableName);
 		await client.createTailorDBType(clonedRequest);
 	}
 	for (const create of changeSet.type.creates) {
-		const typeName = create.request.tailordbType?.name;
-		if (!typeName || !affectedTypes.has(typeName) || !createdBeforeMigration.has(typeName)) continue;
-		const typeChanges = preMigrationChanges.get(typeName);
-		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges);
+		const tableName = create.request.tailordbType?.name;
+		if (!tableName || !affectedTypes.has(tableName) || !createdBeforeMigration.has(tableName)) continue;
+		const typeChanges = preMigrationChanges.get(tableName);
+		const snapshotType = buildSnapshotTypeManifest(migration, tableName, tailorDBInputs, executorUsedTypes, typeChanges);
 		if (!snapshotType) continue;
 		const clonedTypeRequest = structuredClone(snapshotType);
 		if (typeChanges && typeChanges.size > 0 && clonedTypeRequest.schema?.fields) applyPreMigrationFieldAdjustments(clonedTypeRequest.schema.fields, typeChanges);
-		const indexChanges = preMigrationIndexChanges.get(typeName);
+		const indexChanges = preMigrationIndexChanges.get(tableName);
 		if (indexChanges && indexChanges.size > 0 && clonedTypeRequest.schema?.indexes) applyPreMigrationIndexAdjustments(clonedTypeRequest.schema.indexes, indexChanges);
-		processedTypes.updated.add(typeName);
+		processedTypes.updated.add(tableName);
 		await client.updateTailorDBType({
 			workspaceId: create.request.workspaceId,
 			namespaceName: create.request.namespaceName,
@@ -11978,17 +12737,17 @@ async function executeSingleMigrationPrePhase(client, changeSet, migration, tail
 		});
 	}
 	for (const update of changeSet.type.updates) {
-		const typeName = update.request.tailordbType?.name;
-		if (!typeName || !affectedTypes.has(typeName)) continue;
-		const typeChanges = preMigrationChanges.get(typeName);
-		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges);
+		const tableName = update.request.tailordbType?.name;
+		if (!tableName || !affectedTypes.has(tableName)) continue;
+		const typeChanges = preMigrationChanges.get(tableName);
+		const snapshotType = buildSnapshotTypeManifest(migration, tableName, tailorDBInputs, executorUsedTypes, typeChanges);
 		if (!snapshotType) continue;
 		const clonedRequest = structuredClone(update.request);
 		clonedRequest.tailordbType = snapshotType;
 		if (typeChanges && typeChanges.size > 0 && clonedRequest.tailordbType.schema?.fields) applyPreMigrationFieldAdjustments(clonedRequest.tailordbType.schema.fields, typeChanges);
-		const indexChanges = preMigrationIndexChanges.get(typeName);
+		const indexChanges = preMigrationIndexChanges.get(tableName);
 		if (indexChanges && indexChanges.size > 0 && clonedRequest.tailordbType.schema?.indexes) applyPreMigrationIndexAdjustments(clonedRequest.tailordbType.schema.indexes, indexChanges);
-		processedTypes.updated.add(typeName);
+		processedTypes.updated.add(tableName);
 		await client.updateTailorDBType(clonedRequest);
 	}
 	if (!processedTypes.gqlPermissionsProcessed.has(migration.namespace)) {
@@ -11996,12 +12755,12 @@ async function executeSingleMigrationPrePhase(client, changeSet, migration, tail
 		const gqlPermissionUpdatesForNamespace = changeSet.gqlPermission.updates.filter((update) => update.request.namespaceName === migration.namespace);
 		const gqlPermissionTypeNames = new Set(gqlPermissionCreatesForNamespace.map((create) => create.name));
 		const missingTypeCreates = changeSet.type.creates.filter((create) => {
-			const typeName = create.request.tailordbType?.name;
-			return create.request.namespaceName === migration.namespace && typeName && gqlPermissionTypeNames.has(typeName) && !processedTypes.created.has(typeName);
+			const tableName = create.request.tailordbType?.name;
+			return create.request.namespaceName === migration.namespace && tableName && gqlPermissionTypeNames.has(tableName) && !processedTypes.created.has(tableName);
 		});
 		if (missingTypeCreates.length > 0) for (const create of missingTypeCreates) {
-			const typeName = create.request.tailordbType?.name;
-			if (typeName) processedTypes.created.add(typeName);
+			const tableName = create.request.tailordbType?.name;
+			if (tableName) processedTypes.created.add(tableName);
 			await client.createTailorDBType(create.request);
 		}
 		processedTypes.gqlPermissionsProcessed.add(migration.namespace);
@@ -12042,9 +12801,9 @@ async function executeSingleMigrationPostPhase(client, changeSet, migration, tai
 	const affectedTypes = getAffectedTypeNames(migration);
 	try {
 		for (const create of changeSet.type.creates) {
-			const typeName = create.request.tailordbType?.name;
-			if (!typeName || !affectedTypes.has(typeName) || !adjustedTypes.has(typeName)) continue;
-			const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes);
+			const tableName = create.request.tailordbType?.name;
+			if (!tableName || !affectedTypes.has(tableName) || !adjustedTypes.has(tableName)) continue;
+			const snapshotType = buildSnapshotTypeManifest(migration, tableName, tailorDBInputs, executorUsedTypes);
 			if (!snapshotType) continue;
 			await client.updateTailorDBType({
 				workspaceId: create.request.workspaceId,
@@ -12053,9 +12812,9 @@ async function executeSingleMigrationPostPhase(client, changeSet, migration, tai
 			});
 		}
 		for (const update of changeSet.type.updates) {
-			const typeName = update.request.tailordbType?.name;
-			if (!typeName || !affectedTypes.has(typeName) || !adjustedTypes.has(typeName)) continue;
-			const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes);
+			const tableName = update.request.tailordbType?.name;
+			if (!tableName || !affectedTypes.has(tableName) || !adjustedTypes.has(tableName)) continue;
+			const snapshotType = buildSnapshotTypeManifest(migration, tableName, tailorDBInputs, executorUsedTypes);
 			if (!snapshotType) continue;
 			await client.updateTailorDBType({
 				workspaceId: update.request.workspaceId,
@@ -12073,17 +12832,17 @@ async function executeSingleMigrationPostPhaseDeletions(client, changeSet, migra
 		const gqlPermissionsToDelete = changeSet.gqlPermission.deletes.filter((del) => {
 			const permKey = `${del.request.namespaceName}/${del.name}`;
 			if (deletedResources.gqlPermissions.has(permKey)) return false;
-			const typeName = del.name;
-			return deletedTypeNames.has(typeName);
+			const tableName = del.name;
+			return deletedTypeNames.has(tableName);
 		});
 		for (const del of gqlPermissionsToDelete) {
 			await client.deleteTailorDBGQLPermission(del.request);
 			deletedResources.gqlPermissions.add(`${del.request.namespaceName}/${del.name}`);
 		}
 		const typesToDelete = changeSet.type.deletes.filter((del) => {
-			const typeName = del.name;
-			if (!typeName || deletedResources.types.has(typeName)) return false;
-			return deletedTypeNames.has(typeName);
+			const tableName = del.name;
+			if (!tableName || deletedResources.types.has(tableName)) return false;
+			return deletedTypeNames.has(tableName);
 		});
 		for (const del of typesToDelete) {
 			await client.deleteTailorDBType(del.request);
@@ -12122,34 +12881,40 @@ async function rollbackSingleMigrationPrePhase(client, changeSet, migration, wor
 	}
 	const input = tailorDBInputs.find((i) => i.namespace === migration.namespace);
 	logger.warn(`Migration ${migration.namespace}/${formatMigrationNumber(migration.number)} failed; rolling back its pre-migration schema changes.`);
-	for (const typeName of rollbackTypes) {
-		const priorType = priorSnapshot.types[typeName];
-		try {
-			if (priorType) {
-				const manifest = generateTailorDBTypeManifestFromSnapshot(priorType, {
-					subscribed: executorUsedTypes.has(priorType.name),
-					namespaceGqlOperations: input?.config.gqlOperations
-				});
-				await client.updateTailorDBType({
-					workspaceId,
-					namespaceName: migration.namespace,
-					tailordbType: manifest
-				});
-			} else {
-				await client.deleteTailorDBGQLPermission({
-					workspaceId,
-					namespaceName: migration.namespace,
-					typeName
-				}).catch(() => void 0);
-				await client.deleteTailorDBType({
-					workspaceId,
-					namespaceName: migration.namespace,
-					tailordbTypeName: typeName
-				});
-			}
-		} catch (rollbackError) {
-			logger.warn(`Failed to roll back type '${typeName}' in namespace '${migration.namespace}': ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
-		}
+	const restoredTypes = [...rollbackTypes].flatMap((tableName) => {
+		const priorType = priorSnapshot.tables[tableName];
+		return priorType ? [{
+			tableName,
+			priorType
+		}] : [];
+	});
+	const newTypes = [...rollbackTypes].filter((tableName) => !priorSnapshot.tables[tableName]);
+	for (const { tableName, priorType } of restoredTypes) try {
+		const manifest = generateTailorDBTypeManifestFromSnapshot(priorType, {
+			subscribed: executorUsedTypes.has(priorType.name),
+			namespaceGqlOperations: input?.config.gqlOperations
+		});
+		await client.updateTailorDBType({
+			workspaceId,
+			namespaceName: migration.namespace,
+			tailordbType: manifest
+		});
+	} catch (rollbackError) {
+		logger.warn(`Failed to roll back type '${tableName}' in namespace '${migration.namespace}': ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+	}
+	for (const tableName of newTypes) try {
+		await client.deleteTailorDBGQLPermission({
+			workspaceId,
+			namespaceName: migration.namespace,
+			typeName: tableName
+		}).catch(() => void 0);
+		await client.deleteTailorDBType({
+			workspaceId,
+			namespaceName: migration.namespace,
+			tailordbTypeName: tableName
+		});
+	} catch (rollbackError) {
+		logger.warn(`Failed to roll back type '${tableName}' in namespace '${migration.namespace}': ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
 	}
 }
 /**
@@ -12167,7 +12932,7 @@ async function planTailorDB(context) {
 		const snapshot = migrationTestSnapshots?.get(tailordb.namespace);
 		tailordbs.push(snapshot ? {
 			...input,
-			types: snapshot.types
+			types: snapshot.tables
 		} : input);
 	}
 	const executors = forRemoval ? [] : Object.values(await application.executorService?.loadExecutors() ?? {});
@@ -12179,10 +12944,10 @@ async function planTailorDB(context) {
 	if (migrationTestSnapshots) {
 		for (const namespace of migrationTestSnapshots.keys()) if (!tailordbs.some((tailordb) => tailordb.namespace === namespace)) throw new Error(`Migration test snapshot targets unknown TailorDB namespace "${namespace}".`);
 		const namespaceByType = /* @__PURE__ */ new Map();
-		for (const tailordb of tailordbs) for (const typeName of Object.keys(tailordb.types)) {
-			const existingNamespace = namespaceByType.get(typeName);
-			if (existingNamespace) throw new Error(`Migration test snapshot has duplicate TailorDB type name "${typeName}" in namespaces "${existingNamespace}" and "${tailordb.namespace}".`);
-			namespaceByType.set(typeName, tailordb.namespace);
+		for (const tailordb of tailordbs) for (const tableName of Object.keys(tailordb.types)) {
+			const existingNamespace = namespaceByType.get(tableName);
+			if (existingNamespace) throw new Error(`Migration test snapshot has duplicate TailorDB type name "${tableName}" in namespaces "${existingNamespace}" and "${tailordb.namespace}".`);
+			namespaceByType.set(tableName, tailordb.namespace);
 		}
 	}
 	const migrationConfig = getNamespacesWithMigrations(config, path.dirname(config.path));
@@ -12361,17 +13126,17 @@ async function planTypes(client, workspaceId, tailordbs, executorUsedTypes, dele
 	* Build one type's metadata write, carrying the dependency records that belong
 	* to it. The type is what publishes record events, so the record lives there.
 	* @param namespace - Namespace holding the type
-	* @param typeName - Type name
+	* @param tableName - Type name
 	* @param explicitPublishEvents - `publishEvents` declared on the type, if any
 	* @returns The type's metadata write
 	*/
-	const typeMetaRequest = async (namespace, typeName, explicitPublishEvents) => {
+	const typeMetaRequest = async (namespace, tableName, explicitPublishEvents) => {
 		return addDependencyRecords(await buildMetaRequest({
-			trn: tailorDBTypeTrn(workspaceId, namespace, typeName),
+			trn: tailorDBTypeTrn(workspaceId, namespace, tableName),
 			appName: appName ?? "",
 			appId
 		}), {
-			key: eventSourceKey.tailorDBType(namespace, typeName),
+			key: eventSourceKey.tailorDBType(namespace, tableName),
 			dependentApps,
 			runAppIds,
 			pinned: explicitPublishEvents !== void 0
@@ -12390,46 +13155,46 @@ async function planTypes(client, workspaceId, tailordbs, executorUsedTypes, dele
 	};
 	for (const tailordb of tailordbs) {
 		const types = filteredTypesByNamespace?.get(tailordb.namespace) ?? tailordb.types;
-		for (const [typeName, type] of Object.entries(types)) assertNoPublishEventsConflict({
+		for (const [tableName, type] of Object.entries(types)) assertNoPublishEventsConflict({
 			explicit: type.settings?.publishEvents,
-			subscribed: executorUsedTypes.has(typeName),
-			conflict: publishEventsConflict.tailorDBType(typeName)
+			subscribed: executorUsedTypes.has(tableName),
+			conflict: publishEventsConflict.tailorDBType(tableName)
 		});
 	}
 	for (const tailordb of tailordbs) {
 		const existingTypes = await fetchTypes(tailordb.namespace);
 		const existingTypesMap = new Map(existingTypes.map((type) => [type.name, type]));
 		const types = filteredTypesByNamespace?.get(tailordb.namespace) ?? tailordb.types;
-		const typeMeta = (typeName) => typeMetaRequest(tailordb.namespace, typeName, types[typeName]?.settings?.publishEvents);
-		for (const [typeName, tailordbTypeSnapshot] of Object.entries(types)) {
+		const typeMeta = (tableName) => typeMetaRequest(tailordb.namespace, tableName, types[tableName]?.settings?.publishEvents);
+		for (const [tableName, tailordbTypeSnapshot] of Object.entries(types)) {
 			const tailordbType = generateTailorDBTypeManifestFromSnapshot(tailordbTypeSnapshot, {
-				subscribed: executorUsedTypes.has(typeName),
+				subscribed: executorUsedTypes.has(tableName),
 				namespaceGqlOperations: tailordb.config.gqlOperations
 			});
-			const existingType = existingTypesMap.get(typeName);
+			const existingType = existingTypesMap.get(tableName);
 			if (existingType) {
 				if (!forceApplyAll && areNormalizedEqual(normalizeComparableTailorDBType(existingType), normalizeComparableTailorDBType(tailordbType))) changeSet.unchanged.push({
-					name: typeName,
-					metaRequest: await typeMeta(typeName)
+					name: tableName,
+					metaRequest: await typeMeta(tableName)
 				});
 				else changeSet.updates.push({
-					name: typeName,
+					name: tableName,
 					request: {
 						workspaceId,
 						namespaceName: tailordb.namespace,
 						tailordbType
 					},
-					metaRequest: await typeMeta(typeName)
+					metaRequest: await typeMeta(tableName)
 				});
-				existingTypesMap.delete(typeName);
+				existingTypesMap.delete(tableName);
 			} else changeSet.creates.push({
-				name: typeName,
+				name: tableName,
 				request: {
 					workspaceId,
 					namespaceName: tailordb.namespace,
 					tailordbType
 				},
-				metaRequest: await typeMeta(typeName)
+				metaRequest: await typeMeta(tableName)
 			});
 		}
 		existingTypesMap.forEach((_type, name) => {
@@ -12561,29 +13326,29 @@ async function planGqlPermissions(client, workspaceId, tailordbs, deletedService
 			existingNameSet.add(gqlPermission.typeName);
 		});
 		const types = tailordb.types;
-		for (const [typeName, typeEntry] of Object.entries(types)) {
+		for (const [tableName, typeEntry] of Object.entries(types)) {
 			const gqlPermission = typeEntry.permissions?.gql;
 			if (!gqlPermission) continue;
 			const desiredPermission = protoGqlPermission(gqlPermission);
-			const existingPermission = existingGqlPermissions.find((entry) => entry.typeName === typeName);
-			if (existingNameSet.has(typeName)) {
-				if (!forceApplyAll && existingPermission && areNormalizedEqual(normalizeComparableGqlPermission(existingPermission.permission), normalizeComparableGqlPermission(desiredPermission))) changeSet.unchanged.push({ name: typeName });
+			const existingPermission = existingGqlPermissions.find((entry) => entry.typeName === tableName);
+			if (existingNameSet.has(tableName)) {
+				if (!forceApplyAll && existingPermission && areNormalizedEqual(normalizeComparableGqlPermission(existingPermission.permission), normalizeComparableGqlPermission(desiredPermission))) changeSet.unchanged.push({ name: tableName });
 				else changeSet.updates.push({
-					name: typeName,
+					name: tableName,
 					request: {
 						workspaceId,
 						namespaceName: tailordb.namespace,
-						typeName,
+						typeName: tableName,
 						permission: desiredPermission
 					}
 				});
-				existingNameSet.delete(typeName);
+				existingNameSet.delete(tableName);
 			} else changeSet.creates.push({
-				name: typeName,
+				name: tableName,
 				request: {
 					workspaceId,
 					namespaceName: tailordb.namespace,
-					typeName,
+					typeName: tableName,
 					permission: desiredPermission
 				}
 			});
@@ -15827,7 +16592,7 @@ async function planDeploymentTarget(params) {
 		const snapshot = migrationTestSnapshots?.get(service.namespace);
 		return snapshot ? {
 			...service,
-			types: snapshot.types,
+			types: snapshot.tables,
 			typeSourceInfo: {}
 		} : service;
 	});
@@ -16364,6 +17129,8 @@ function adjustApplicationForMigrationTest(application, internalContext) {
 async function deployInternal(options, cliContext, internalContext) {
 	return withSpan("deploy", async (rootSpan) => {
 		rootSpan.setAttribute("deploy.dry_run", options?.dryRun ?? false);
+		beginUserModuleRun();
+		beginWaitPointScope();
 		const configPaths = parseDeployConfigPaths(options?.configPath);
 		const dryRun = options?.dryRun ?? false;
 		const buildOnly = options?.buildOnly ?? parseBoolean(process.env.TAILOR_DEPLOY_BUILD_ONLY) === true;
@@ -20417,6 +21184,249 @@ async function openInConfiguredEditor(filePath) {
 	return await openInEditor(filePath, editor);
 }
 
+//#endregion
+//#region src/cli/commands/tailordb/migrate/expand-contract.ts
+/**
+* Planning for field type changes that move values through a temporary field.
+*
+* A change that cannot be applied in place is split into two migrations: the
+* first adds a temporary field and converts values into it, the second renames
+* that field back over the original.
+*/
+/** Longest field name the platform accepts. */
+const MAX_FIELD_NAME_LENGTH = 63;
+const TEMP_FIELD_SUFFIX = "Migrate";
+/**
+* Key identifying a field across snapshots and user-supplied options.
+* @param tableName - Name of the type holding the field
+* @param fieldName - Name of the field
+* @returns Key in `Type.field` form
+*/
+function fieldKey(tableName, fieldName) {
+	return `${tableName}.${fieldName}`;
+}
+/**
+* Derive the temporary field name to carry a field's converted values.
+*
+* Field names cannot hold an underscore, so the suffix is camelCase and a
+* collision is resolved by an ordinal rather than a separator.
+* @param fieldName - Field being converted
+* @param taken - Field names already in use for the same type
+* @returns Unused temporary field name
+* @throws {Error} When no candidate fits within the platform's length limit
+*/
+function buildTempFieldName(fieldName, taken) {
+	const base = `${fieldName}${TEMP_FIELD_SUFFIX}`;
+	for (let ordinal = 1; ordinal <= taken.size + 1; ordinal++) {
+		const candidate = ordinal === 1 ? base : `${base}${ordinal}`;
+		if (candidate.length > MAX_FIELD_NAME_LENGTH) break;
+		if (!taken.has(candidate)) return candidate;
+	}
+	throw new Error(`Cannot derive a temporary field name for "${fieldName}": every candidate is taken or exceeds ${MAX_FIELD_NAME_LENGTH} characters.`);
+}
+/**
+* Whether a field type change can be carried by a generated migration pair.
+*
+* The single answer behind the prompt, the flag hint, and planning, so a run
+* cannot recommend a conversion it would then reject.
+* @param options - Snapshots and the field to test
+* @returns Whether the conversion can be generated
+*/
+function canConvertField(options) {
+	return getExpandContractEligibility(options).eligible;
+}
+/**
+* Explain whether a field can be carried by a generated migration pair.
+* @param options - Snapshots and the field to test
+* @returns Eligibility and, when ineligible, the reason
+*/
+function getExpandContractEligibility(options) {
+	const { previous, current, tableName, fieldName } = options;
+	const before = previous.tables[tableName]?.fields[fieldName];
+	const after = current.tables[tableName]?.fields[fieldName];
+	if (!before || !after) return {
+		eligible: false,
+		reason: "the field does not exist in both schemas"
+	};
+	const fieldEligibility = getExpandContractFieldChangeEligibility(before, after);
+	if (!fieldEligibility.eligible) return fieldEligibility;
+	if (isFieldReferenced(previous.tables[tableName], fieldName) || isFieldReferenced(current.tables[tableName], fieldName)) return {
+		eligible: false,
+		reason: "another schema feature references the field"
+	};
+	return { eligible: true };
+}
+/**
+* Names a type already exposes, which a temporary field cannot reuse.
+* @param type - Type to enumerate
+* @returns Field, file, and relationship names
+*/
+function typeMemberNames(type) {
+	if (!type) return [];
+	return [
+		...Object.keys(type.fields),
+		...Object.keys(type.files ?? {}),
+		...Object.keys(type.forwardRelationships ?? {}),
+		...Object.keys(type.backwardRelationships ?? {})
+	];
+}
+function staticPropertyName(key, computed) {
+	if (!computed && key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+	if (key.type === "TemplateLiteral" && key.expressions.length === 0) return key.quasis[0]?.value.cooked ?? void 0;
+}
+const SCRIPT_CONTEXT_ARGUMENTS = /* @__PURE__ */ new Set([
+	"input",
+	"newRecord",
+	"oldRecord",
+	"invoker",
+	"now"
+]);
+function walkScriptAst(node, visit, ancestors = []) {
+	if (!node) return;
+	visit(node, ancestors);
+	const nestedAncestors = [...ancestors, node];
+	const record = node;
+	for (const [key, value] of Object.entries(record)) {
+		if (key === "type" || key === "parent") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (item && typeof item === "object" && "type" in item) walkScriptAst(item, visit, nestedAncestors);
+		} else if (value && typeof value === "object" && "type" in value) walkScriptAst(value, visit, nestedAncestors);
+	}
+}
+function unwrapFunction(node) {
+	return node.type === "ParenthesizedExpression" ? unwrapFunction(node.expression) : node;
+}
+function collectIssueBindings(program) {
+	const issueBindings = /* @__PURE__ */ new Set(["__issues"]);
+	walkScriptAst(program, (node) => {
+		if (node.type !== "CallExpression") return;
+		const callee = unwrapFunction(node.callee);
+		if (callee.type !== "ArrowFunctionExpression" && callee.type !== "FunctionExpression" || node.arguments[1]?.type !== "Identifier" || node.arguments[1].name !== "__issues") return;
+		const issueParameter = callee.params[1];
+		if (issueParameter?.type === "Identifier") issueBindings.add(issueParameter.name);
+	});
+	let addedBinding;
+	do {
+		const previousSize = issueBindings.size;
+		walkScriptAst(program, (node) => {
+			if (node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.init?.type === "Identifier" && issueBindings.has(node.init.name)) issueBindings.add(node.id.name);
+		});
+		addedBinding = issueBindings.size > previousSize;
+	} while (addedBinding);
+	return issueBindings;
+}
+function isWrapperArgumentProperty(node, ancestors) {
+	if (node.type !== "Property") return false;
+	const propertyName = staticPropertyName(node.key, node.computed);
+	if (!propertyName || !SCRIPT_CONTEXT_ARGUMENTS.has(propertyName)) return false;
+	const object = ancestors.at(-1);
+	const call = ancestors.at(-2);
+	if (object?.type !== "ObjectExpression" || call?.type !== "CallExpression") return false;
+	return call.arguments[0] === object && ["ArrowFunctionExpression", "FunctionExpression"].includes(unwrapFunction(call.callee).type);
+}
+function isWrapperParameterProperty(node, ancestors) {
+	if (node.type !== "Property") return false;
+	const propertyName = staticPropertyName(node.key, node.computed);
+	if (!propertyName || !SCRIPT_CONTEXT_ARGUMENTS.has(propertyName)) return false;
+	const pattern = ancestors.at(-1);
+	if (pattern?.type !== "ObjectPattern") return false;
+	for (let index = ancestors.length - 2; index >= 0; index--) {
+		const candidate = ancestors[index];
+		if (candidate && (candidate.type === "ArrowFunctionExpression" || candidate.type === "FunctionExpression") && candidate.params[0] === pattern) return ancestors.slice(0, index).some((ancestor) => ancestor.type === "CallExpression" && unwrapFunction(ancestor.callee) === candidate && ancestor.arguments[0]?.type === "ObjectExpression" && ancestor.arguments[0].properties.some((property) => property.type === "Property" && staticPropertyName(property.key, property.computed) === propertyName));
+	}
+	return false;
+}
+function isIssueMessage(node, ancestors, issueBindings) {
+	const call = ancestors.at(-1);
+	return call?.type === "CallExpression" && call.callee.type === "Identifier" && issueBindings.has(call.callee.name) && call.arguments.findIndex((argument) => argument === node) > 0;
+}
+function scriptReferencesField(script, fieldName) {
+	try {
+		const { program, errors } = parseSync("expand-contract-reference.js", script, { sourceType: "module" });
+		if (errors.length > 0) return true;
+		const issueBindings = collectIssueBindings(program);
+		let referenced = false;
+		walkScriptAst(program, (node, ancestors) => {
+			if (referenced) return;
+			if (node.type === "MemberExpression" && (staticPropertyName(node.property, node.computed) === fieldName || node.computed && staticPropertyName(node.property, true) === void 0)) referenced = true;
+			else if (node.type === "Property" && (staticPropertyName(node.key, node.computed) === fieldName || node.computed && staticPropertyName(node.key, true) === void 0) && (node.computed || !isWrapperArgumentProperty(node, ancestors) && !isWrapperParameterProperty(node, ancestors))) referenced = true;
+			else if (node.type === "CallExpression" && node.callee.type === "Identifier" && issueBindings.has(node.callee.name) && node.arguments[0] !== void 0 && node.arguments[0].type !== "SpreadElement" && staticPropertyName(node.arguments[0], true) === fieldName) referenced = true;
+			else if ((node.type === "Literal" || node.type === "TemplateLiteral") && staticPropertyName(node, true) === fieldName && !isIssueMessage(node, ancestors, issueBindings)) referenced = true;
+		});
+		return referenced;
+	} catch {
+		return true;
+	}
+}
+function permissionsReferenceField(permissions, fieldName) {
+	if (!permissions) return false;
+	return [...permissions.record ? Object.values(permissions.record).flatMap((policies) => policies) : [], ...permissions.gql ?? []].some((policy) => policy.conditions.some((condition) => {
+		const [left, , right] = condition;
+		return [left, right].some((operand) => isSnapshotFieldRefOperand(operand) && ("record" in operand && operand.record === fieldName || "newRecord" in operand && operand.newRecord === fieldName || "oldRecord" in operand && operand.oldRecord === fieldName));
+	}));
+}
+/**
+* Whether anything other than the field list names this field.
+*
+* The pair moves values through a differently named field, and only the field
+* list is rewritten. An index, relationship, permission, or script naming the
+* field would keep pointing at the name the pair drops.
+* @param type - Type holding the field
+* @param fieldName - Field being converted
+* @returns Whether another part of the type names the field
+*/
+function isFieldReferenced(type, fieldName) {
+	if (!type) return false;
+	if (Object.values(type.indexes ?? {}).some((index) => index.fields.includes(fieldName))) return true;
+	if ([...Object.values(type.forwardRelationships ?? {}), ...Object.values(type.backwardRelationships ?? {})].some((relationship) => relationship.sourceField === fieldName || relationship.targetField === fieldName)) return true;
+	if (permissionsReferenceField(type.permissions, fieldName)) return true;
+	return [
+		type.typeHookExpr?.create,
+		type.typeHookExpr?.update,
+		type.typeValidateExpr
+	].filter((script) => script !== void 0).some((script) => scriptReferencesField(script, fieldName));
+}
+/**
+* Split unsupported field type changes into the ones a migration pair can carry
+* and the ones that must still fail.
+* @param options - Snapshots, diff, and the changes the user approved
+* @returns Plans to generate and breaking changes to reject
+*/
+function planExpandContract(options) {
+	const { previous, current, diff, confirmed } = options;
+	const plans = [];
+	const planned = /* @__PURE__ */ new Set();
+	for (const change of diff.changes) {
+		if (change.kind !== "field_type_modified") continue;
+		const key = fieldKey(change.tableName, change.fieldName);
+		if (!confirmed.has(key)) continue;
+		if (!canConvertField({
+			previous,
+			current,
+			tableName: change.tableName,
+			fieldName: change.fieldName
+		})) continue;
+		const taken = /* @__PURE__ */ new Set([
+			...typeMemberNames(previous.tables[change.tableName]),
+			...typeMemberNames(current.tables[change.tableName]),
+			...plans.filter((plan) => plan.tableName === change.tableName).map((plan) => plan.tempFieldName)
+		]);
+		plans.push({
+			tableName: change.tableName,
+			fieldName: change.fieldName,
+			tempFieldName: buildTempFieldName(change.fieldName, taken),
+			before: change.before,
+			after: change.after
+		});
+		planned.add(key);
+	}
+	return {
+		plans,
+		blocked: diff.breakingChanges.filter((change) => change.unsupported && !(change.fieldName && planned.has(fieldKey(change.tableName, change.fieldName))))
+	};
+}
+
 //#endregion
 //#region src/cli/commands/tailordb/migrate/db-types-generator.ts
 /**
@@ -20434,11 +21444,13 @@ function extractBreakingChangeFields(diff) {
 	const optionalToRequired = /* @__PURE__ */ new Map();
 	const addedRequiredFields = /* @__PURE__ */ new Map();
 	const enumValueChanges = /* @__PURE__ */ new Map();
+	const renamedFields = /* @__PURE__ */ new Map();
+	const renamedTypes = /* @__PURE__ */ new Map();
 	for (const change of diff.changes) if (change.kind === "field_modified" || change.kind === "field_type_modified") {
 		const { before, after } = change;
 		if (!before.required && after.required) {
-			if (!optionalToRequired.has(change.typeName)) optionalToRequired.set(change.typeName, /* @__PURE__ */ new Set());
-			assertDefined(optionalToRequired.get(change.typeName), "optionalToRequired entry missing").add(change.fieldName);
+			if (!optionalToRequired.has(change.tableName)) optionalToRequired.set(change.tableName, /* @__PURE__ */ new Set());
+			assertDefined(optionalToRequired.get(change.tableName), "optionalToRequired entry missing").add(change.fieldName);
 		}
 		if (before.type === "enum" && after.type === "enum" && before.allowedValues && after.allowedValues) {
 			const beforeValues = before.allowedValues.map((v) => v.value);
@@ -20446,8 +21458,8 @@ function extractBreakingChangeFields(diff) {
 			const beforeSet = new Set(beforeValues);
 			const afterSet = new Set(afterValues);
 			if (beforeValues.some((v) => !afterSet.has(v)) || afterValues.some((v) => !beforeSet.has(v))) {
-				if (!enumValueChanges.has(change.typeName)) enumValueChanges.set(change.typeName, /* @__PURE__ */ new Map());
-				assertDefined(enumValueChanges.get(change.typeName), "enumValueChanges entry missing").set(change.fieldName, {
+				if (!enumValueChanges.has(change.tableName)) enumValueChanges.set(change.tableName, /* @__PURE__ */ new Map());
+				assertDefined(enumValueChanges.get(change.tableName), "enumValueChanges entry missing").set(change.fieldName, {
 					beforeValues,
 					afterValues
 				});
@@ -20456,33 +21468,55 @@ function extractBreakingChangeFields(diff) {
 	} else if (change.kind === "field_added") {
 		const { after } = change;
 		if (after.required) {
-			if (!addedRequiredFields.has(change.typeName)) addedRequiredFields.set(change.typeName, /* @__PURE__ */ new Map());
-			assertDefined(addedRequiredFields.get(change.typeName), "addedRequiredFields entry missing").set(change.fieldName, after);
+			if (!addedRequiredFields.has(change.tableName)) addedRequiredFields.set(change.tableName, /* @__PURE__ */ new Map());
+			assertDefined(addedRequiredFields.get(change.tableName), "addedRequiredFields entry missing").set(change.fieldName, after);
 		}
-	}
+	} else if (change.kind === "field_renamed") {
+		if (!renamedFields.has(change.tableName)) renamedFields.set(change.tableName, /* @__PURE__ */ new Map());
+		assertDefined(renamedFields.get(change.tableName), "renamedFields entry missing").set(change.fieldName, change.after);
+	} else if (change.kind === "table_renamed") renamedTypes.set(change.tableName, change.after);
 	return {
 		optionalToRequired,
 		addedRequiredFields,
-		enumValueChanges
+		enumValueChanges,
+		renamedFields,
+		clearedFields: /* @__PURE__ */ new Map(),
+		renamedTypes
 	};
 }
 /**
 * Generate the complete db.ts file content from a schema snapshot
 * @param {SchemaSnapshot} snapshot - Schema snapshot to generate types from
 * @param {MigrationDiff} [diff] - Optional migration diff for breaking change info
+* @param expandPlans - Field changes carried through temporary fields
 * @returns {string} Generated db.ts file contents
 */
-function generateDbTypesFromSnapshot(snapshot, diff) {
-	const types = Object.values(snapshot.types);
-	if (types.length === 0) return generateEmptyDbTypes(snapshot.namespace);
+function generateDbTypesFromSnapshot(snapshot, diff, expandPlans = []) {
 	const breakingChangeFields = diff ? extractBreakingChangeFields(diff) : {
 		optionalToRequired: /* @__PURE__ */ new Map(),
 		addedRequiredFields: /* @__PURE__ */ new Map(),
-		enumValueChanges: /* @__PURE__ */ new Map()
-	};
+		enumValueChanges: /* @__PURE__ */ new Map(),
+		renamedFields: /* @__PURE__ */ new Map(),
+		clearedFields: /* @__PURE__ */ new Map(),
+		renamedTypes: /* @__PURE__ */ new Map()
+	};
+	for (const plan of expandPlans) {
+		const injected = breakingChangeFields.renamedFields.get(plan.tableName) ?? /* @__PURE__ */ new Map();
+		injected.set(plan.tempFieldName, {
+			...plan.after,
+			required: false,
+			unique: false
+		});
+		breakingChangeFields.renamedFields.set(plan.tableName, injected);
+		const cleared = breakingChangeFields.clearedFields.get(plan.tableName) ?? /* @__PURE__ */ new Set();
+		cleared.add(plan.fieldName);
+		breakingChangeFields.clearedFields.set(plan.tableName, cleared);
+	}
+	const tables = [...Object.values(snapshot.tables), ...breakingChangeFields.renamedTypes.values()];
+	if (tables.length === 0) return generateEmptyDbTypes(snapshot.namespace);
 	const usedUtilityTypes = /* @__PURE__ */ new Set();
 	const typeDefinitions = [];
-	for (const type of types) {
+	for (const type of tables) {
 		const result = generateTableType(type, breakingChangeFields);
 		if (result.usedTimestamp) usedUtilityTypes.add("Timestamp");
 		typeDefinitions.push(result.typeDef);
@@ -20559,12 +21593,14 @@ function generateTableType(type, breakingChangeFields) {
 	const optionalToRequiredFields = breakingChangeFields.optionalToRequired.get(type.name) || /* @__PURE__ */ new Set();
 	const addedRequiredFields = breakingChangeFields.addedRequiredFields.get(type.name) || /* @__PURE__ */ new Map();
 	const enumValueChangesForType = breakingChangeFields.enumValueChanges.get(type.name) || /* @__PURE__ */ new Map();
+	const clearedFieldsForType = breakingChangeFields.clearedFields.get(type.name) ?? /* @__PURE__ */ new Set();
 	for (const [fieldName, fieldConfig] of Object.entries(type.fields)) {
 		if (fieldName === "id") continue;
 		const result = generateFieldType(fieldConfig, optionalToRequiredFields.has(fieldName), enumValueChangesForType.get(fieldName));
-		fieldLines.push(`    ${fieldName}: ${result.type};`);
+		const clearable = clearedFieldsForType.has(fieldName);
+		fieldLines.push(`    ${fieldName}: ${clearable ? generateClearableFieldType(fieldConfig) : result.type};`);
 		usedTimestamp = usedTimestamp || result.usedTimestamp;
-		usedColumnType = usedColumnType || result.usedColumnType;
+		usedColumnType = usedColumnType || result.usedColumnType || clearable;
 	}
 	for (const [fieldName, fieldConfig] of addedRequiredFields) {
 		const result = generateFieldType(fieldConfig, true, void 0);
@@ -20572,6 +21608,13 @@ function generateTableType(type, breakingChangeFields) {
 		usedTimestamp = usedTimestamp || result.usedTimestamp;
 		usedColumnType = usedColumnType || result.usedColumnType;
 	}
+	const renamedFieldsForType = breakingChangeFields.renamedFields.get(type.name) || /* @__PURE__ */ new Map();
+	for (const [fieldName, fieldConfig] of renamedFieldsForType) {
+		const result = generateFieldType(fieldConfig, fieldConfig.required, void 0);
+		fieldLines.push(`    ${fieldName}: ${result.type};`);
+		usedTimestamp = usedTimestamp || result.usedTimestamp;
+		usedColumnType = usedColumnType || result.usedColumnType;
+	}
 	return {
 		typeDef: `  ${type.name}: {\n${fieldLines.join("\n")}\n  }`,
 		usedTimestamp,
@@ -20622,6 +21665,19 @@ function generateEnumChangeColumnType(enumValueChange, config) {
 	if (!config.required) return `ColumnType<(${selectType}) | null, (${afterType}) | null, (${afterType}) | null>`;
 	return `ColumnType<${selectType}, ${afterType}, ${afterType}>`;
 }
+/**
+* Column type for a field the migration script both reads and clears.
+*
+* Kysely takes the select, insert, and update types from the three slots in
+* turn, so the update slot has to accept the null the script writes.
+* @param config - Field configuration in the pre-migration snapshot
+* @returns {string} Generated column type
+*/
+function generateClearableFieldType(config) {
+	const { type } = mapToTsType(config.type);
+	const base = config.array ? `${type}[]` : type;
+	return `ColumnType<${base} | null, ${base} | null, ${base} | null>`;
+}
 function generateOptionalToRequiredDateColumnType(config) {
 	if (config.type !== "date" && config.type !== "datetime") return null;
 	if (config.type === "date") {
@@ -20682,10 +21738,11 @@ function generateFieldType(config, isOptionalToRequired, enumValueChange) {
 * @param {string} migrationsDir - Migrations directory path
 * @param {number} migrationNumber - Migration number
 * @param {MigrationDiff} [diff] - Optional migration diff for breaking change info
+* @param expandPlans - Field changes carried through temporary fields
 * @returns {Promise<string>} Path to the written file
 */
-async function writeDbTypesFile(snapshot, migrationsDir, migrationNumber, diff) {
-	const content = generateDbTypesFromSnapshot(snapshot, diff);
+async function writeDbTypesFile(snapshot, migrationsDir, migrationNumber, diff, expandPlans = []) {
+	const content = generateDbTypesFromSnapshot(snapshot, diff, expandPlans);
 	const filePath = getMigrationFilePath(migrationsDir, migrationNumber, "db");
 	await fs.writeFile(filePath, content);
 	return filePath;
@@ -20750,16 +21807,18 @@ async function generateSchemaFile(snapshot, migrationsDir, migrationNumber) {
 * @param {number} migrationNumber - Migration number
 * @param {SchemaSnapshot} previousSnapshot - Previous schema snapshot (for db.ts generation)
 * @param {string} [description] - Optional description for the migration
+* @param expandPlans - Field changes carried through temporary fields
 * @returns {Promise<GenerateDiffResult>} Generated file info
 */
-async function generateDiffFiles(diff, migrationsDir, migrationNumber, previousSnapshot, description) {
+async function generateDiffFiles(diff, migrationsDir, migrationNumber, previousSnapshot, description, expandPlans = []) {
 	const migrationDir = getMigrationDirPath(migrationsDir, migrationNumber);
 	await fs.mkdir(migrationDir, { recursive: true });
 	const diffFilePath = getMigrationFilePath(migrationsDir, migrationNumber, "diff");
 	const migrateFilePath = getMigrationFilePath(migrationsDir, migrationNumber, "migrate");
 	const dbTypesFilePath = getMigrationFilePath(migrationsDir, migrationNumber, "db");
+	const writeScript = diff.requiresMigrationScript;
 	await ensureFileNotExists(diffFilePath);
-	if (diff.requiresMigrationScript) {
+	if (writeScript) {
 		await ensureFileNotExists(migrateFilePath);
 		await ensureFileNotExists(dbTypesFilePath);
 	}
@@ -20772,11 +21831,11 @@ async function generateDiffFiles(diff, migrationsDir, migrationNumber, previousS
 		diffFilePath,
 		migrationNumber
 	};
-	if (diff.requiresMigrationScript) {
-		const scriptContent = generateMigrationScript(diff);
+	if (writeScript) {
+		const scriptContent = generateMigrationScript(diff, expandPlans);
 		await fs.writeFile(migrateFilePath, scriptContent);
 		result.migrateFilePath = migrateFilePath;
-		await writeDbTypesFile(previousSnapshot, migrationsDir, migrationNumber, diff);
+		await writeDbTypesFile(previousSnapshot, migrationsDir, migrationNumber, diff, expandPlans);
 		result.dbTypesFilePath = dbTypesFilePath;
 	}
 	return result;
@@ -20784,13 +21843,16 @@ async function generateDiffFiles(diff, migrationsDir, migrationNumber, previousS
 /**
 * Generate migration script content based on diff
 * @param {MigrationDiff} diff - Migration diff
+* @param expandPlans - Field changes carried through temporary fields
 * @returns {string} Migration script content
 */
-function generateMigrationScript(diff) {
+function generateMigrationScript(diff, expandPlans = []) {
 	const updates = [];
+	const typeRenameTargets = new Map(diff.changes.filter((change) => change.kind === "table_renamed").map((change) => [change.previousTableName, change.tableName]));
+	for (const plan of expandPlans) updates.push(generateExpandConversionScript(plan));
 	for (const change of diff.changes) {
 		const decimalScaleScript = generateDecimalScaleChangeScript(change);
-		updates.push(...generateChangeScripts(change, decimalScaleScript !== null));
+		updates.push(...generateChangeScripts(change, decimalScaleScript !== null, typeRenameTargets));
 		if (decimalScaleScript) {
 			updates.push(decimalScaleScript);
 			const uniqueConstraintScript = generateUniqueConstraintScript(change);
@@ -20863,33 +21925,34 @@ describe(${JSON.stringify(`${diff.namespace} migration`)}, () => {
 * Generate scripts for a single change
 * @param {DiffChange} change - Diff change to generate script for
 * @param {boolean} deferUniqueConstraint - Generate the unique check after decimal re-serialization
+* @param {ReadonlyMap<string, string>} [typeRenameTargets] - Confirmed type renames (old name → new name)
 * @returns {string[]} Script contents, or an empty array if no script is needed
 */
-function generateChangeScripts(change, deferUniqueConstraint = false) {
+function generateChangeScripts(change, deferUniqueConstraint = false, typeRenameTargets) {
 	if (change.kind === "index_added" || change.kind === "index_modified") {
 		const before = change.kind === "index_modified" ? change.before : void 0;
-		if (!isBreakingIndexChange(change.typeName, change.indexName, before, change.after)) return [];
+		if (!isBreakingIndexChange(change.tableName, change.indexName, before, change.after)) return [];
 		const fields = change.after.fields;
 		const fieldList = fields.map((f) => `"${f}"`).join(", ");
 		const whereClauses = fields.map((f) => `.where("${f}", "=", dup.${f})`).join("\n        ");
 		return [`  // Resolve duplicate (${fields.join(", ")}) combinations before unique index "${change.indexName}" is enforced
   {
     const duplicates = await trx
-      .selectFrom("${change.typeName}")
+      .selectFrom("${change.tableName}")
       .select([${fieldList}])
       .groupBy([${fieldList}])
       .having((eb) => eb.fn.count("id"), ">", 1)
       .execute();
     for (const dup of duplicates) {
       const records = await trx
-        .selectFrom("${change.typeName}")
+        .selectFrom("${change.tableName}")
         .select(["id"])
         ${whereClauses}
         .execute();
       // Keep the first record; update or delete the others so the combination becomes unique
       for (let i = 1; i < records.length; i++) {
         await trx
-          .updateTable("${change.typeName}")
+          .updateTable("${change.tableName}")
           .set({ ${fields[0]}: null }) // TODO: Set appropriate unique value
           .where("id", "=", records[i].id)
           .execute();
@@ -20898,22 +21961,28 @@ function generateChangeScripts(change, deferUniqueConstraint = false) {
   }`];
 	}
 	if (change.kind === "field_added") {
-		if (change.after.required) return [`  // Populate ${change.fieldName} for existing ${change.typeName} records
+		if (change.after.required) return [`  // Populate ${change.fieldName} for existing ${change.tableName} records
   await trx
-    .updateTable("${change.typeName}")
+    .updateTable("${change.tableName}")
     .set({
       ${change.fieldName}: null, // TODO: Set appropriate default value
     })
     .execute();`];
 		return [];
 	}
+	if (change.kind === "field_renamed") {
+		const scripts = [generateFieldRenameCopyScript(change)];
+		if ((change.after.unique ?? false) && (!(change.before.unique ?? false) || renameCopyCanCollapseValues(change))) scripts.push(generateUniqueDedupeScript(change.tableName, change.fieldName, "suffix"));
+		return scripts;
+	}
+	if (change.kind === "table_renamed") return [generateTypeRenameCopyScript(change)];
 	if (change.kind !== "field_modified" && change.kind !== "field_type_modified") return [];
 	const { before, after } = change;
 	const scripts = [];
 	if (change.kind === "field_type_modified") scripts.push(generateFieldTypeChangeScript(change));
-	if (!before.required && after.required) scripts.push(`  // Set ${change.fieldName} for ${change.typeName} records where it is null
+	if (!before.required && after.required) scripts.push(`  // Set ${change.fieldName} for ${change.tableName} records where it is null
   await trx
-    .updateTable("${change.typeName}")
+    .updateTable("${change.tableName}")
     .set({
       ${change.fieldName}: null, // TODO: Set appropriate default value
     })
@@ -20931,25 +22000,25 @@ function generateChangeScripts(change, deferUniqueConstraint = false) {
 			const defaultValue = afterValues[0] ?? "NEW_VALUE";
 			scripts.push(`  // Migrate records with removed enum values: ${removedValues.join(", ")}
   await trx
-    .updateTable("${change.typeName}")
+    .updateTable("${change.tableName}")
     .set({ ${change.fieldName}: "${defaultValue}" }) // TODO: Set appropriate value
     .where("${change.fieldName}", "in", [${removedValues.map((v) => `"${v}"`).join(", ")}])
     .execute();`);
 		}
 	}
-	if (before.foreignKeyType && after.foreignKeyType && before.foreignKeyType !== after.foreignKeyType) scripts.push(`  // Migrate ${change.fieldName} references from ${before.foreignKeyType} to ${after.foreignKeyType}
+	if (isBreakingForeignKeyRetarget(before, after, typeRenameTargets)) scripts.push(`  // Migrate ${change.fieldName} references from ${before.foreignKeyType} to ${after.foreignKeyType}
   // Find records that don't have a valid reference in the new target table
   {
     const orphanedRecords = await trx
-      .selectFrom("${change.typeName}")
-      .leftJoin("${after.foreignKeyType}", "${change.typeName}.${change.fieldName}", "${after.foreignKeyType}.id")
-      .select(["${change.typeName}.id", "${change.typeName}.${change.fieldName}"])
+      .selectFrom("${change.tableName}")
+      .leftJoin("${after.foreignKeyType}", "${change.tableName}.${change.fieldName}", "${after.foreignKeyType}.id")
+      .select(["${change.tableName}.id", "${change.tableName}.${change.fieldName}"])
       .where("${after.foreignKeyType}.id", "is", null)
-      .where("${change.typeName}.${change.fieldName}", "is not", null)
+      .where("${change.tableName}.${change.fieldName}", "is not", null)
       .execute();
     for (const record of orphanedRecords) {
       await trx
-        .updateTable("${change.typeName}")
+        .updateTable("${change.tableName}")
         .set({ ${change.fieldName}: null }) // TODO: Set appropriate new reference
         .where("id", "=", record.id)
         .execute();
@@ -20957,13 +22026,70 @@ function generateChangeScripts(change, deferUniqueConstraint = false) {
   }`);
 	return scripts;
 }
+function renameCopyCanCollapseValues(change) {
+	const { before, after } = change;
+	if (before.type !== "decimal" || after.type !== "decimal") return false;
+	return (after.scale ?? 6) < (before.scale ?? 6);
+}
+function generateFieldRenameCopyScript(change) {
+	const { tableName, fieldName, previousFieldName, before, after } = change;
+	return `  // Copy ${tableName}.${previousFieldName} into ${fieldName} for every row.
+  // Overwrite unconditionally: stored values of previously removed fields are
+  // not pruned, so a stale value could otherwise resurface under ${fieldName}.${!before.required && after.required ? `
+  // TODO: ${previousFieldName} is optional but ${fieldName} is required.
+  // Resolve null values, or the post-migration phase will fail.` : ""}${renameCopyCanCollapseValues(change) ? `
+  // WARNING: ${fieldName} has a smaller decimal scale than ${previousFieldName}, so
+  // copied values that exceed it may be rounded half-up. Review the resulting
+  // precision before deploying.` : ""}
+  await trx
+    .updateTable("${tableName}")
+    .set((eb) => ({ ${fieldName}: eb.ref("${previousFieldName}") }))
+    .execute();`;
+}
+function generateTypeRenameCopyScript(change) {
+	const { tableName, previousTableName } = change;
+	const columnList = ["id", ...Object.keys(change.before.fields).filter((name) => name !== "id")].map((name) => JSON.stringify(name)).join(", ");
+	const selfRefColumns = Object.entries(change.after.fields).filter(([, field]) => field.foreignKeyType === tableName).map(([name]) => name);
+	return `  // Copy every ${previousTableName} row into ${tableName}, preserving ids so that
+  // stored foreign key references remain valid. ${previousTableName} stays readable
+  // until the post-migration phase drops it.
+  {
+    let lastId: string | undefined;
+    while (true) {
+      let query = trx
+        .selectFrom("${previousTableName}")
+        .select([${columnList}])
+        .orderBy("id", "asc")
+        .limit(100);
+      if (lastId) {
+        query = query.where("id", ">", lastId);
+      }
+      const rows = await query.execute();
+      if (rows.length === 0) break;
+
+      await trx.insertInto("${tableName}").values(${selfRefColumns.length > 0 ? `rows.map((row) => ({ ...row, ${selfRefColumns.map((name) => `${name}: null`).join(", ")} }))` : "rows"}).execute();
+      lastId = rows[rows.length - 1]!.id;
+    }
+  }${selfRefColumns.length > 0 ? `
+
+  // Backfill the self-referential column(s) now that every row exists.
+  await trx
+    .updateTable("${tableName}")
+    .set((eb) => ({
+${selfRefColumns.map((name) => `      ${name}: eb
+        .selectFrom("${previousTableName}")
+        .select("${previousTableName}.${name}")
+        .whereRef("${previousTableName}.id", "=", "${tableName}.id"),`).join("\n")}
+    }))
+    .execute();` : ""}`;
+}
 function generateFieldTypeChangeScript(change) {
-	return `  // Normalize ${change.typeName}.${change.fieldName} from ${change.before.type} to ${change.after.type} while the previous type is still active
+	return `  // Normalize ${change.tableName}.${change.fieldName} from ${change.before.type} to ${change.after.type} while the previous type is still active
   {
     let lastId: string | undefined;
     while (true) {
       let query = trx
-        .selectFrom("${change.typeName}")
+        .selectFrom("${change.tableName}")
         .select(["id", "${change.fieldName}"])
         .where("${change.fieldName}", "is not", null)
         .orderBy("id", "asc")
@@ -20982,7 +22108,7 @@ function generateFieldTypeChangeScript(change) {
         const normalizedValue: never = sourceValue;
         if (Object.is(normalizedValue, sourceValue)) continue;
         await trx
-          .updateTable("${change.typeName}")
+          .updateTable("${change.tableName}")
           .set({ [${JSON.stringify(change.fieldName)}]: normalizedValue })
           .where("id", "=", row.id)
           .execute();
@@ -20991,38 +22117,76 @@ function generateFieldTypeChangeScript(change) {
     }
   }`;
 }
+function generateExpandConversionScript(plan) {
+	return `  // Convert ${plan.tableName}.${plan.fieldName} into ${plan.tempFieldName}, which the next migration renames back to ${plan.fieldName}
+  {
+    let lastId: string | undefined;
+    while (true) {
+      let query = trx
+        .selectFrom("${plan.tableName}")
+        .select(["id", "${plan.fieldName}"])
+        .where("${plan.fieldName}", "is not", null)
+        .orderBy("id", "asc")
+        .limit(100);
+      if (lastId) {
+        query = query.where("id", ">", lastId);
+      }
+      const rows = await query.execute();
+      if (rows.length === 0) break;
+
+      for (const row of rows) {
+        // ${MIGRATION_REVIEW_REQUIRED_MARKER}: Remove this marker and the \`never\` annotation after reviewing the conversion.
+        // Produce a value accepted by the ${plan.after.type} type from the stored ${plan.before.type} value.
+        const sourceValue = row.${plan.fieldName};
+        const convertedValue: never = sourceValue;
+        // Clearing ${plan.fieldName} keeps a re-run from converting the row twice.
+        await trx
+          .updateTable("${plan.tableName}")
+          .set({
+            [${JSON.stringify(plan.tempFieldName)}]: convertedValue,
+            [${JSON.stringify(plan.fieldName)}]: null,
+          })
+          .where("id", "=", row.id)
+          .execute();
+      }
+      lastId = rows[rows.length - 1]!.id;
+    }
+  }`;
+}
 function generateUniqueConstraintScript(change) {
 	if (change.kind !== "field_modified" && change.kind !== "field_type_modified") return null;
 	const { before, after } = change;
 	if ((before.unique ?? false) || !(after.unique ?? false)) return null;
-	const duplicateResolution = change.kind === "field_type_modified" ? `      if (records.length > 1) {
-        throw new Error(
-          "TODO: Resolve duplicate ${change.typeName}.${change.fieldName} values before adding the unique constraint",
-        );
-      }` : `      // Keep first record, add suffix to others
-      for (let i = 1; i < records.length; i++) {
-        await trx
-          .updateTable("${change.typeName}")
-          .set({ ${change.fieldName}: \`\${records[i].${change.fieldName}}_\${i}\` }) // TODO: Set appropriate unique value
-          .where("id", "=", records[i].id)
-          .execute();
-      }`;
-	return `  // Ensure ${change.fieldName} values are unique before adding constraint
+	return generateUniqueDedupeScript(change.tableName, change.fieldName, change.kind === "field_type_modified" ? "throw" : "suffix");
+}
+function generateUniqueDedupeScript(tableName, fieldName, resolution) {
+	return `  // Ensure ${fieldName} values are unique before adding constraint
   {
     const duplicates = await trx
-      .selectFrom("${change.typeName}")
-      .select(["${change.fieldName}"])
-      .groupBy("${change.fieldName}")
+      .selectFrom("${tableName}")
+      .select(["${fieldName}"])
+      .groupBy("${fieldName}")
       .having((eb) => eb.fn.count("id"), ">", 1)
       .execute();
     for (const dup of duplicates) {
       // Load every record in this duplicate group before resolving it
       const records = await trx
-        .selectFrom("${change.typeName}")
-        .select(["id", "${change.fieldName}"])
-        .where("${change.fieldName}", "=", dup.${change.fieldName})
+        .selectFrom("${tableName}")
+        .select(["id", "${fieldName}"])
+        .where("${fieldName}", "=", dup.${fieldName})
         .execute();
-${duplicateResolution}
+${resolution === "throw" ? `      if (records.length > 1) {
+        throw new Error(
+          "TODO: Resolve duplicate ${tableName}.${fieldName} values before adding the unique constraint",
+        );
+      }` : `      // Keep first record, add suffix to others
+      for (let i = 1; i < records.length; i++) {
+        await trx
+          .updateTable("${tableName}")
+          .set({ ${fieldName}: \`\${records[i].${fieldName}}_\${i}\` }) // TODO: Set appropriate unique value
+          .where("id", "=", records[i].id)
+          .execute();
+      }`}
     }
   }`;
 }
@@ -21033,9 +22197,9 @@ function generateDecimalScaleChangeScript(change) {
 	const valueExpression = !before.required && after.required ? `row.${change.fieldName}!` : `row.${change.fieldName}`;
 	const beforeScale = before.scale ?? 6;
 	const roundingWarning = (after.scale ?? 6) < beforeScale ? `
-  // Values that exceed the new scale may be rounded half-up, so review the
-  // resulting precision before deploying.` : "";
-	return `  // Re-save existing ${change.typeName} rows so ${change.fieldName} is stored under the new scale.
+  // WARNING: Values that exceed the new scale may be rounded half-up, so
+  // review the resulting precision before deploying.` : "";
+	return `  // Re-save existing ${change.tableName} rows so ${change.fieldName} is stored under the new scale.
   // This is a workaround for a platform-side gap where rows written under the
   // previous scale could fail on later updates until re-saved. Keep it unless
   // your platform is confirmed to handle stored values across scale changes.${roundingWarning}
@@ -21043,7 +22207,7 @@ function generateDecimalScaleChangeScript(change) {
     let lastId: string | undefined;
     while (true) {
       let query = trx
-        .selectFrom("${change.typeName}")
+        .selectFrom("${change.tableName}")
         .select(["id", "${change.fieldName}"])
         .where("${change.fieldName}", "is not", null)
         .orderBy("id", "asc")
@@ -21056,7 +22220,7 @@ function generateDecimalScaleChangeScript(change) {
 
       for (const row of rows) {
         await trx
-          .updateTable("${change.typeName}")
+          .updateTable("${change.tableName}")
           .set({ ${change.fieldName}: ${valueExpression} })
           .where("id", "=", row.id)
           .where("${change.fieldName}", "=", ${valueExpression})
@@ -21344,14 +22508,46 @@ async function generate(options) {
 		logger.info("Add \"migration: { directory: \\\"./migrations\\\" }\" to your db config to enable migrations.");
 		return;
 	}
+	const renameFlags = [];
+	const typeRenameFlags = [];
+	for (const raw of options.renames ?? []) if (raw.includes(".")) renameFlags.push({
+		raw,
+		spec: parseRenameOption(raw)
+	});
+	else typeRenameFlags.push({
+		raw,
+		spec: parseTypeRenameOption(raw)
+	});
+	const dropFlags = [];
+	const typeDropFlags = [];
+	for (const raw of options.drops ?? []) if (raw.includes(".")) dropFlags.push({
+		raw,
+		spec: parseDropOption(raw)
+	});
+	else typeDropFlags.push({
+		raw,
+		spec: parseTypeDropOption(raw)
+	});
+	const expandContractFlags = (options.expandContracts ?? []).map((raw) => ({
+		raw,
+		spec: parseExpandContractOption(raw)
+	}));
+	if (options.init && (renameFlags.length > 0 || typeRenameFlags.length > 0 || dropFlags.length > 0 || typeDropFlags.length > 0 || expandContractFlags.length > 0)) throw new Error("--rename, --drop, and --expand-contract cannot be used together with --init.");
+	const droppedFieldKeys = new Set(dropFlags.map(({ spec }) => `${spec.tableName}.${spec.fieldName}`));
+	const conflictingFlags = renameFlags.filter(({ spec }) => droppedFieldKeys.has(`${spec.tableName}.${spec.previousFieldName}`));
+	if (conflictingFlags.length > 0) throw new Error(`--rename and --drop conflict for: ${conflictingFlags.map(({ spec }) => `${spec.tableName}.${spec.previousFieldName}`).join(", ")}`);
+	const droppedTypeNames = new Set(typeDropFlags.map(({ spec }) => spec.tableName));
+	const conflictingTypeFlags = typeRenameFlags.filter(({ spec }) => droppedTypeNames.has(spec.previousTableName));
+	if (conflictingTypeFlags.length > 0) throw new Error(`--rename and --drop conflict for: ${conflictingTypeFlags.map(({ spec }) => spec.previousTableName).join(", ")}`);
 	if (options.init) await handleInitOption(namespacesWithMigrations, options.yes);
 	let pluginManager;
 	if (plugins.length > 0) pluginManager = new PluginManager(plugins);
-	const { defineApplication } = await import("./application-BxLLiLsr.mjs");
+	const { defineApplication } = await import("./application-BZfk4HKm.mjs");
 	const application = defineApplication({
 		config,
 		pluginManager
 	});
+	const generations = [];
 	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
 		logger.info(`Processing namespace: ${styles.bold(namespace)}`);
 		assertValidMigrationFiles(migrationsDir, namespace);
@@ -21363,11 +22559,110 @@ async function generate(options) {
 		await tailordbService.loadTypes();
 		await tailordbService.processNamespacePlugins();
 		const localTypesObj = tailordbService.types;
-		const currentSnapshot = createSnapshotFromLocalTypes(localTypesObj, namespace);
-		const previousSnapshot = reconstructSnapshotFromMigrations(migrationsDir);
-		if (!previousSnapshot) await generateInitialSnapshot(currentSnapshot, migrationsDir);
-		else await generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migrationsDir, options);
+		generations.push({
+			namespace,
+			migrationsDir,
+			currentSnapshot: createSnapshotFromLocalTypes(localTypesObj, namespace),
+			previousSnapshot: reconstructSnapshotFromMigrations(migrationsDir)
+		});
 	}
+	const renameSpecsByNamespace = matchFlagsToNamespaces(renameFlags, generations, renameSpecApplies, "--rename does not match a removed + added field pair");
+	const typeRenameSpecsByNamespace = matchFlagsToNamespaces(typeRenameFlags, generations, typeRenameSpecApplies, "--rename does not match a removed + added type pair");
+	const dropSpecsByNamespace = matchFlagsToNamespaces(dropFlags, generations, dropSpecApplies, "--drop does not match a removed field");
+	const typeDropSpecsByNamespace = matchFlagsToNamespaces(typeDropFlags, generations, typeDropSpecApplies, "--drop does not match a removed type");
+	const expandContractKeysByNamespace = /* @__PURE__ */ new Map();
+	const matchedExpandContractFlags = /* @__PURE__ */ new Set();
+	const ineligibleExpandContracts = [];
+	for (const { namespace, previousSnapshot, currentSnapshot } of generations) {
+		if (!previousSnapshot) continue;
+		const applicable = [];
+		for (const flag of expandContractFlags) {
+			const { spec } = flag;
+			const before = previousSnapshot.tables[spec.tableName]?.fields[spec.fieldName];
+			const after = currentSnapshot.tables[spec.tableName]?.fields[spec.fieldName];
+			if (!before || !after || before.type === after.type) continue;
+			matchedExpandContractFlags.add(flag);
+			const eligibility = getExpandContractEligibility({
+				previous: previousSnapshot,
+				current: currentSnapshot,
+				tableName: spec.tableName,
+				fieldName: spec.fieldName
+			});
+			if (!eligibility.eligible) {
+				ineligibleExpandContracts.push(`--expand-contract cannot convert ${flag.raw} (namespace: ${namespace}): ${eligibility.reason}`);
+				continue;
+			}
+			applicable.push(flag);
+		}
+		expandContractKeysByNamespace.set(namespace, new Set(applicable.map(({ spec }) => fieldKey(spec.tableName, spec.fieldName))));
+	}
+	const unusedExpandContracts = expandContractFlags.filter((flag) => !matchedExpandContractFlags.has(flag));
+	if (unusedExpandContracts.length > 0) throw new Error(`--expand-contract does not match a field whose type changed: ${unusedExpandContracts.map((flag) => flag.raw).join(", ")}`);
+	if (ineligibleExpandContracts.length > 0) throw new Error(ineligibleExpandContracts.join("\n"));
+	const unresolvedCandidates = [];
+	for (const generation of generations) {
+		const { namespace, previousSnapshot, currentSnapshot } = generation;
+		if (!previousSnapshot) continue;
+		const diff = compareSnapshots(previousSnapshot, currentSnapshot);
+		if (!hasChanges(diff)) {
+			generation.diff = diff;
+			continue;
+		}
+		const resolution = await resolveRenames(previousSnapshot, currentSnapshot, diff, options, {
+			fieldRenames: renameSpecsByNamespace.get(namespace) ?? [],
+			typeRenames: typeRenameSpecsByNamespace.get(namespace) ?? [],
+			fieldDrops: dropSpecsByNamespace.get(namespace) ?? [],
+			typeDrops: typeDropSpecsByNamespace.get(namespace) ?? []
+		});
+		generation.diff = resolution.diff;
+		unresolvedCandidates.push(...resolution.unresolved);
+		generation.expandPlans = await resolveExpandContractPlans({
+			previousSnapshot,
+			currentSnapshot,
+			diff: resolution.diff,
+			options,
+			confirmedKeys: expandContractKeysByNamespace.get(namespace) ?? /* @__PURE__ */ new Set()
+		});
+	}
+	if (unresolvedCandidates.length > 0) {
+		const details = unresolvedCandidates.map(({ namespace, label, targets }) => `  - ${label} → ${targets.join(", ")}? (namespace: ${namespace})`).join("\n");
+		throw new Error(`Possible rename(s) detected:\n${details}\nRe-run with --rename "Type.oldField:newField" (field) or --rename "OldType:NewType" (type) to record a rename and scaffold a data copy script, or --drop "Type.field" / --drop "Type" to confirm the removal.`);
+	}
+	for (const { migrationsDir, currentSnapshot, previousSnapshot, diff, expandPlans } of generations) if (!previousSnapshot) await generateInitialSnapshot(currentSnapshot, migrationsDir);
+	else await generateDiffFromSnapshot(previousSnapshot, assertDefined(diff, "Migration diff was not resolved during preflight"), migrationsDir, options, currentSnapshot, expandPlans ?? []);
+}
+/**
+* Decide which unsupported field type changes to carry through a migration
+* pair, asking about each one that was not already named by a flag.
+* @param input - Snapshots, diff, command options, and flag-approved fields
+* @returns Approved plans, empty when nothing was confirmed
+*/
+async function resolveExpandContractPlans(input) {
+	const { previousSnapshot, currentSnapshot, diff, options, confirmedKeys } = input;
+	const confirmed = new Set(confirmedKeys);
+	if (!options.yes && canPrompt()) for (const change of diff.changes) {
+		if (change.kind !== "field_type_modified") continue;
+		const key = fieldKey(change.tableName, change.fieldName);
+		if (confirmed.has(key)) continue;
+		if (!canConvertField({
+			previous: previousSnapshot,
+			current: currentSnapshot,
+			tableName: change.tableName,
+			fieldName: change.fieldName
+		})) continue;
+		logger.newline();
+		logger.info(`${change.tableName}.${change.fieldName} changes from ${change.before.type} to ${change.after.type}, which cannot be applied in one step.`);
+		if (await prompt.confirm({
+			message: `Generate two migrations to convert ${change.tableName}.${change.fieldName} through a temporary field?`,
+			default: true
+		})) confirmed.add(key);
+	}
+	return planExpandContract({
+		previous: previousSnapshot,
+		current: currentSnapshot,
+		diff,
+		confirmed
+	}).plans;
 }
 /**
 * Generate the initial schema snapshot
@@ -21379,19 +22674,174 @@ async function generateInitialSnapshot(snapshot, migrationsDir) {
 	const result = await generateSchemaFile(snapshot, migrationsDir, 0);
 	logger.success(`Generated initial schema snapshot`);
 	logger.info(`  File: ${result.filePath}`);
-	logger.info(`  Types: ${Object.keys(snapshot.types).length}`);
+	logger.info(`  Types: ${Object.keys(snapshot.tables).length}`);
 	logger.log("\nThis is the baseline schema. Future changes will be tracked as diffs.");
 }
 /**
-* Generate diff from previous snapshot
+* Match `--rename` / `--drop` flags against every namespace's snapshots.
+* Throws when a flag applies to no namespace, so a typo cannot silently fall
+* back to remove + add.
+* @param {readonly { raw: string; spec: S }[]} flags - Parsed flags of one form
+* @param {readonly NamespaceGeneration[]} generations - Snapshots per namespace
+* @param {(spec: S, previous: SchemaSnapshot, current: SchemaSnapshot) => boolean} applies - Whether a spec matches a namespace's snapshot pair
+* @param {string} unmatchedError - Error prefix for flags that match no namespace
+* @returns {Map<string, S[]>} Applicable specs keyed by namespace
+*/
+function matchFlagsToNamespaces(flags, generations, applies, unmatchedError) {
+	const specsByNamespace = /* @__PURE__ */ new Map();
+	const matched = /* @__PURE__ */ new Set();
+	for (const { namespace, previousSnapshot, currentSnapshot } of generations) {
+		if (!previousSnapshot) continue;
+		const applicable = flags.filter(({ spec }) => applies(spec, previousSnapshot, currentSnapshot));
+		for (const flag of applicable) matched.add(flag);
+		specsByNamespace.set(namespace, applicable.map((flag) => flag.spec));
+	}
+	const unused = flags.filter((flag) => !matched.has(flag));
+	if (unused.length > 0) throw new Error(`${unmatchedError}: ${unused.map((flag) => flag.raw).join(", ")}`);
+	return specsByNamespace;
+}
+function availableRenameTargets(candidate, claimedFields) {
+	return candidate.added.filter((added) => !claimedFields.has(`${candidate.tableName}.${added.fieldName}`)).map((added) => added.fieldName);
+}
+/**
+* Ask the user whether a removed field was renamed to one of the compatible
+* added fields. Returns the confirmed new field name, or undefined.
+* @param {FieldRenameCandidate} candidate - Candidate to confirm
+* @param {string[]} addedFieldNames - Added field names still available as rename targets
+* @returns {Promise<string | undefined>} Confirmed new field name, if any
+*/
+async function promptRenameCandidate(candidate, addedFieldNames) {
+	const oldLabel = `${candidate.tableName}.${candidate.removed.fieldName}`;
+	const [firstFieldName] = addedFieldNames;
+	if (addedFieldNames.length === 1 && firstFieldName) return await prompt.confirm({
+		message: `${oldLabel} was removed and ${firstFieldName} was added with a compatible type. Was it renamed to ${firstFieldName}?`,
+		default: true
+	}) ? firstFieldName : void 0;
+	return await prompt.select({
+		message: `${oldLabel} was removed. Was it renamed to one of these added fields?`,
+		choices: [...addedFieldNames.map((fieldName) => ({
+			name: `Yes, renamed to ${fieldName}`,
+			value: fieldName
+		})), {
+			name: `No, ${candidate.removed.fieldName} was removed`,
+			value: null
+		}]
+	}) ?? void 0;
+}
+function availableTypeRenameTargets(candidate, claimedTypes) {
+	return candidate.added.filter((added) => !claimedTypes.has(added.tableName)).map((added) => added.tableName);
+}
+/**
+* Ask the user whether a removed type was renamed to one of the compatible
+* added types. Returns the confirmed new type name, or undefined.
+* @param {TypeRenameCandidate} candidate - Candidate to confirm
+* @param {string[]} addedTypeNames - Added type names still available as rename targets
+* @returns {Promise<string | undefined>} Confirmed new type name, if any
+*/
+async function promptTypeRenameCandidate(candidate, addedTypeNames) {
+	const oldTypeName = candidate.removed.tableName;
+	const [firstTypeName] = addedTypeNames;
+	if (addedTypeNames.length === 1 && firstTypeName) return await prompt.confirm({
+		message: `${oldTypeName} was removed and ${firstTypeName} was added with a compatible schema. Was it renamed to ${firstTypeName}?`,
+		default: true
+	}) ? firstTypeName : void 0;
+	return await prompt.select({
+		message: `${oldTypeName} was removed. Was it renamed to one of these added types?`,
+		choices: [...addedTypeNames.map((tableName) => ({
+			name: `Yes, renamed to ${tableName}`,
+			value: tableName
+		})), {
+			name: `No, ${oldTypeName} was removed`,
+			value: null
+		}]
+	}) ?? void 0;
+}
+/**
+* Resolve field and type renames for a diff: apply `--rename` flags, skip
+* candidates whose removal is confirmed by `--drop`, confirm the rest
+* interactively, and recompute the diff with the confirmed renames. When
+* prompting is unavailable (`--yes` or no TTY), the remaining candidates are
+* returned as unresolved for the caller to fail on.
+* @param {NormalizedSchemaSnapshot} previousSnapshot - Previous normalized schema snapshot
+* @param {NormalizedSchemaSnapshot} currentSnapshot - Current normalized schema snapshot
+* @param {MigrationDiff} diff - Diff computed without rename knowledge
+* @param {GenerateOptions} options - Generate options
+* @param {NamespaceRenameSpecs} specs - This namespace's `--rename` / `--drop` specs
+* @returns {Promise<RenameResolution>} Diff with confirmed renames and any unresolved candidates
+*/
+async function resolveRenames(previousSnapshot, currentSnapshot, diff, options, specs) {
+	const confirmed = [...specs.fieldRenames];
+	const claimedFields = new Set(confirmed.flatMap((spec) => [`${spec.tableName}.${spec.previousFieldName}`, `${spec.tableName}.${spec.fieldName}`]));
+	const droppedFields = new Set(specs.fieldDrops.map((spec) => `${spec.tableName}.${spec.fieldName}`));
+	const confirmedTypes = [...specs.typeRenames];
+	const claimedTypes = new Set(confirmedTypes.flatMap((spec) => [spec.previousTableName, spec.tableName]));
+	const droppedTypes = new Set(specs.typeDrops.map((spec) => spec.tableName));
+	const typeCandidates = findTypeRenameCandidates(diff).filter((candidate) => !droppedTypes.has(candidate.removed.tableName) && !claimedTypes.has(candidate.removed.tableName) && availableTypeRenameTargets(candidate, claimedTypes).length > 0);
+	const candidates = findRenameCandidates(diff).filter((candidate) => !droppedFields.has(`${candidate.tableName}.${candidate.removed.fieldName}`) && !claimedFields.has(`${candidate.tableName}.${candidate.removed.fieldName}`) && availableRenameTargets(candidate, claimedFields).length > 0);
+	const unresolved = [];
+	if (options.yes || !canPrompt()) {
+		for (const candidate of typeCandidates) unresolved.push({
+			namespace: diff.namespace,
+			label: candidate.removed.tableName,
+			targets: availableTypeRenameTargets(candidate, claimedTypes)
+		});
+		for (const candidate of candidates) unresolved.push({
+			namespace: diff.namespace,
+			label: `${candidate.tableName}.${candidate.removed.fieldName}`,
+			targets: availableRenameTargets(candidate, claimedFields)
+		});
+	} else {
+		for (const candidate of typeCandidates) {
+			const addedTypeNames = availableTypeRenameTargets(candidate, claimedTypes);
+			if (addedTypeNames.length === 0) continue;
+			const newTypeName = await promptTypeRenameCandidate(candidate, addedTypeNames);
+			if (newTypeName) {
+				confirmedTypes.push({
+					previousTableName: candidate.removed.tableName,
+					tableName: newTypeName
+				});
+				claimedTypes.add(candidate.removed.tableName);
+				claimedTypes.add(newTypeName);
+			}
+		}
+		for (const candidate of candidates) {
+			const addedFieldNames = availableRenameTargets(candidate, claimedFields);
+			if (addedFieldNames.length === 0) continue;
+			const newFieldName = await promptRenameCandidate(candidate, addedFieldNames);
+			if (newFieldName) {
+				confirmed.push({
+					tableName: candidate.tableName,
+					previousFieldName: candidate.removed.fieldName,
+					fieldName: newFieldName
+				});
+				claimedFields.add(`${candidate.tableName}.${candidate.removed.fieldName}`);
+				claimedFields.add(`${candidate.tableName}.${newFieldName}`);
+			}
+		}
+	}
+	if (confirmed.length === 0 && confirmedTypes.length === 0) return {
+		diff,
+		unresolved
+	};
+	return {
+		diff: compareSnapshots(previousSnapshot, currentSnapshot, {
+			fieldRenames: confirmed,
+			typeRenames: confirmedTypes
+		}),
+		unresolved
+	};
+}
+/**
+* Generate migration files from a diff resolved during preflight
 * @param {SchemaSnapshot} previousSnapshot - Previous schema snapshot
-* @param {SchemaSnapshot} currentSnapshot - Current schema snapshot
+* @param {MigrationDiff} diff - Diff with confirmed renames recorded
 * @param {string} migrationsDir - Migrations directory path
 * @param {GenerateOptions} options - Generate options
+* @param currentSnapshot - Schema the user now declares
+* @param expandPlans - Field changes confirmed for a migration pair
 * @returns {Promise<void>} Promise that resolves when diff is generated
 */
-async function generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migrationsDir, options) {
-	const diff = compareSnapshots(previousSnapshot, currentSnapshot);
+async function generateDiffFromSnapshot(previousSnapshot, diff, migrationsDir, options, currentSnapshot, expandPlans = []) {
 	if (!hasChanges(diff)) {
 		logger.info("No schema differences detected.");
 		return;
@@ -21400,18 +22850,30 @@ async function generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migra
 	logger.log(formatMigrationDiff(diff));
 	logger.newline();
 	logger.info(`Summary: ${formatDiffSummary(diff)}`);
-	const unsupportedChanges = diff.breakingChanges.filter((change) => change.unsupported);
+	const plannedKeys = new Set(expandPlans.map((plan) => fieldKey(plan.tableName, plan.fieldName)));
+	const unsupportedChanges = diff.breakingChanges.filter((change) => change.unsupported && !(change.fieldName && plannedKeys.has(fieldKey(change.tableName, change.fieldName))));
 	if (unsupportedChanges.length > 0) {
 		for (const change of unsupportedChanges) {
 			logger.newline();
-			logger.error(`Unsupported change: ${change.typeName}.${change.fieldName}`);
+			logger.error(`Unsupported change: ${change.tableName}.${change.fieldName}`);
 			logger.error(`  ${change.reason}`);
 		}
+		const convertible = unsupportedChanges.filter(({ tableName, fieldName }) => fieldName !== void 0 && canConvertField({
+			previous: previousSnapshot,
+			current: currentSnapshot,
+			tableName,
+			fieldName
+		}));
+		if (convertible.length > 0) {
+			logger.newline();
+			logger.info("Convert these fields through a temporary field with:");
+			for (const { tableName, fieldName } of convertible) logger.info(`  --expand-contract "${tableName}.${fieldName}"`);
+		}
 		if (unsupportedChanges.some((change) => change.showThreeStepHint)) {
 			logger.newline();
 			for (const line of getUnsupportedMigrationHintLines()) logger.info(line);
 		}
-		const details = unsupportedChanges.map((c) => `  - ${c.typeName}.${c.fieldName}: ${c.reason}`).join("\n");
+		const details = unsupportedChanges.map((c) => `  - ${c.tableName}.${c.fieldName}: ${c.reason}`).join("\n");
 		throw new Error(`Unsupported schema changes detected:\n${details}`);
 	}
 	if (diff.hasBreakingChanges) {
@@ -21432,6 +22894,17 @@ async function generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migra
 		logger.newline();
 		logger.warn(formatWarnings(diff.warnings));
 	}
+	if (expandPlans.length > 0) {
+		await generateExpandContractMigrations({
+			previousSnapshot,
+			currentSnapshot,
+			resolvedDiff: diff,
+			plans: expandPlans,
+			migrationsDir,
+			description: options.name
+		});
+		return;
+	}
 	const result = await generateDiffFiles(diff, migrationsDir, getNextMigrationNumber(migrationsDir), previousSnapshot, options.name);
 	logger.success(`Generated migration ${styles.bold(formatMigrationNumber(result.migrationNumber))}`);
 	logger.info(`  Diff file: ${result.diffFilePath}`);
@@ -21464,6 +22937,46 @@ async function generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migra
 	});
 }
 /**
+* Write the two migrations that carry a field type change: one that converts
+* values into a temporary field, and one that renames it back.
+* @param input - Snapshots, confirmed plans, and output location
+* @returns {Promise<void>} Promise that resolves when both migrations are written
+*/
+async function generateExpandContractMigrations(input) {
+	const { previousSnapshot, currentSnapshot, resolvedDiff, plans, migrationsDir, description } = input;
+	const intermediateSnapshot = buildIntermediateSnapshot(previousSnapshot, plans);
+	const expandDiff = buildExpandDiff(previousSnapshot, intermediateSnapshot, plans);
+	const confirmedFieldRenames = resolvedDiff.changes.filter((change) => change.kind === "field_renamed").map(({ tableName, previousFieldName, fieldName }) => ({
+		tableName,
+		previousFieldName,
+		fieldName
+	}));
+	const confirmedTypeRenames = resolvedDiff.changes.filter((change) => change.kind === "table_renamed").map(({ previousTableName, tableName }) => ({
+		previousTableName,
+		tableName
+	}));
+	const contractDiff = compareSnapshots(intermediateSnapshot, currentSnapshot, {
+		fieldRenames: [...confirmedFieldRenames, ...plans.map((plan) => ({
+			tableName: plan.tableName,
+			previousFieldName: plan.tempFieldName,
+			fieldName: plan.fieldName
+		}))],
+		typeRenames: confirmedTypeRenames
+	});
+	const expandNumber = getNextMigrationNumber(migrationsDir);
+	if (expandNumber + 1 > 9999) throw new Error(`Converting a field type needs two migration numbers, and ${formatMigrationNumber(MAX_MIGRATION_NUMBER)} is the last one available. Re-baseline the history first.`);
+	const expand = await generateDiffFiles(expandDiff, migrationsDir, expandNumber, previousSnapshot, description, plans);
+	const contract = await generateDiffFiles(contractDiff, migrationsDir, expandNumber + 1, intermediateSnapshot, description);
+	const fields = plans.map((plan) => `${plan.tableName}.${plan.fieldName}`).join(", ");
+	logger.success(`Generated migrations ${styles.bold(formatMigrationNumber(expand.migrationNumber))} and ${styles.bold(formatMigrationNumber(contract.migrationNumber))} to convert ${fields}`);
+	logger.info(`  Diff files: ${expand.diffFilePath}, ${contract.diffFilePath}`);
+	if (expand.migrateFilePath) logger.info(`  Conversion script: ${expand.migrateFilePath}`);
+	if (contract.migrateFilePath) logger.info(`  Copy script: ${contract.migrateFilePath}`);
+	logger.newline();
+	logger.info(`Edit the conversion in ${formatMigrationNumber(expand.migrationNumber)} before deploying. The copy script in ${formatMigrationNumber(contract.migrationNumber)} is complete, though that migration also carries any other change in this run.`, { mode: "plain" });
+	logger.info("Both migrations are applied by 'tailor deploy'.", { mode: "plain" });
+}
+/**
 * Offer to record a --no-script acknowledgment for a warning-only migration,
 * or print the follow-up commands when the session is non-interactive
 * @param {AcknowledgeWarningsOptions} options - Target migration and prompt behavior
@@ -21517,14 +23030,20 @@ const generateCommand = defineAppCommand({
 			alias: "n",
 			description: "Optional description for the migration"
 		}),
-		init: arg(z.boolean().default(false), { description: "Delete existing migrations and start fresh" })
+		init: arg(z.boolean().default(false), { description: "Delete existing migrations and start fresh" }),
+		rename: arg(z.array(z.string()).optional(), { description: "Record a field or type rename instead of remove + add (format: \"Type.oldField:newField\" or \"OldType:NewType\"; repeatable). Renames require a migration script that copies the data." }),
+		drop: arg(z.array(z.string()).optional(), { description: "Confirm that a removed field or type is a genuine removal, not a rename (format: \"Type.field\" or \"Type\"; repeatable). Required in non-interactive runs for a removal with rename candidates." }),
+		"expand-contract": arg(z.array(z.string()).optional(), { description: "Convert a field type through a temporary field (format: \"Type.field\"; repeatable). Generates two migrations." })
 	}),
 	run: async (args) => {
 		await generate({
 			configPath: args.config,
 			name: args.name,
 			yes: args.yes,
-			init: args.init
+			init: args.init,
+			renames: args.rename,
+			drops: args.drop,
+			expandContracts: args["expand-contract"]
 		});
 	}
 });
@@ -23942,11 +25461,15 @@ function errorToJson(error, options) {
 			...options?.includeStack && error.stack ? { stack: error.stack } : {}
 		} };
 	}
-	if (error instanceof Error) return { error: {
-		code: error.name === "CIPromptError" ? "INTERACTIVE_PROMPT_REQUIRED" : "UNEXPECTED_ERROR",
-		message: error.message,
-		...options?.includeStack && error.stack ? { stack: error.stack } : {}
-	} };
+	if (error instanceof Error) {
+		const suggestion = typeOnlyImportHint(error);
+		return { error: {
+			code: error.name === "CIPromptError" ? "INTERACTIVE_PROMPT_REQUIRED" : "UNEXPECTED_ERROR",
+			message: error.message,
+			...suggestion ? { suggestion } : {},
+			...options?.includeStack && error.stack ? { stack: error.stack } : {}
+		} };
+	}
 	return { error: {
 		code: "UNKNOWN_ERROR",
 		message: String(error)
@@ -24016,5 +25539,5 @@ async function registerTsHook(tsHookUrl) {
 }
 
 //#endregion
-export { treeCommand as $, formatDiffSummary as $n, listWorkspaces as $t, truncate as A, MIGRATION_NUMBER_PATTERN as An, removeLegacyUserAlias as Ar, triggerExecutor as At, MIGRATION_REVIEW_REQUIRED_MARKER as B, getMigrationDirPath as Bn, isVerbose as Br, getCommand$5 as Bt, healthCommand as C, captureFileState as Cn, loadConsoleBaseUrl as Cr, listCommand$7 as Ct, resumeWorkflow as D, INITIAL_SCHEMA_NUMBER as Dn, loadWorkspaceId as Dr, listWebhookExecutors as Dt, resumeCommand as E, DIFF_FILE_NAME as En, loadStoredUserTokens as Er, getFunctionRegistry as Et, chunkSeedData as F, compareLocalTypesWithSnapshot as Fn, defineAppCommand as Fr, jobsCommand as Ft, showCommand as G, loadSnapshot as Gn, toPageDirection as Gr, functionExecutionStatusToString as Gt, deployCommand as H, getMigrationFiles as Hn, pagedLogArgs as Hr, executionsCommand as Ht, bundleSeedScript as I, compareSnapshots as In, commonArgs as Ir, listExecutorJobs as It, remove as J, MIGRATION_HISTORY_LABEL_KEY as Jn, deploy as Jt, extractOwnedNamespaces as K, normalizeSchemaSnapshot as Kn, workspaceArgs as Kr, getCommand$6 as Kt, generate as L, createSnapshotFromLocalTypes as Ln, configArg as Lr, watchExecutorJob as Lt, loadSeedContext as M, UnsupportedMigrationFileVersionError as Mn, resolveUserTokenKey as Mr, listExecutors as Mt, loadApplicationNamespaces as N, assertMigrationNumberExists as Nn, saveUserTokens as Nr, getExecutorJob as Nt, listCommand$2 as O, MIGRATE_FILE_NAME as On, platformConfigFromProfile as Or, webhookCommand as Ot, loadTailorDBNamespaces as P, assertValidMigrationFiles as Pn, writePlatformConfig as Pr, getExecutorWaitFailureMessage as Pt, organizationTree as Q, sanitizeMigrationLabel as Qn, listCommand$9 as Qt, generateCommand as R, formatSchemaDrifts as Rn, confirmationArgs as Rr, startCommand as Rt, getAppHealth as S, protoGqlPermission as Sn, loadConfigPath as Sr, generate$1 as St, waitWorkflowExecution as T, DB_TYPES_FILE_NAME as Tn, loadPlatformClientConfig as Tr, getCommand$4 as Tt, deployStaticWebsite as U, getNextMigrationNumber as Un, paginationArgs as Ur, getWorkflowExecution as Ut, generateSchemaFile as V, getMigrationFilePath as Vn, multiConfigArg as Vr, getWorkflow as Vt, show as W, loadDiff as Wn, resolveMachineUserInputSource as Wr, listWorkflowExecutions as Wt, updateCommand$1 as X, createMigrationHistoryId as Xn, deployMigrationTestBaseline as Xt, removeCommand$1 as Y, MIGRATION_LABEL_KEY as Yn, deployFromCLI as Yt, updateOrganization as Z, handleOptionalToRequiredError as Zn, deployMigrationTestTarget as Zt, getWorkspace as _, verifyRemoteSchema as _n, deleteUserTokens as _r, getOAuth2Client as _t, queryCommand as a, ensureConfigId as an, sdkAppIdLabelKey as ar, updateFolder as at, listApps as b, compareSnapshotWithRemote as bn, hasUserTokenEntry as br, listCommand$6 as bt, removeCommand as c, executeScript as cn, writeMetadataLabels as cr, getCommand$2 as ct, listUsers as d, bundleMigrationScript as dn, formatMigrationNumber as dr, deleteFolder as dt, createCommand$1 as en, formatMigrationDiff as er, listCommand$3 as et, inviteCommand as f, checkMigrationDiffs as fn, parseMigrationNumberArg as fr, createCommand as ft, getCommand as g, toTailorDBDeployInput as gn, loadConfig as gr, getCommand$3 as gt, restoreWorkspace as h, logRemoteDriftGuidance as hn, assertWritable as hr, listOAuth2Clients as ht, query as i, workspaceNameSchema as in, resourceTrn as ir, updateCommand$2 as it, truncateCommand as j, SCHEMA_FILE_NAME as jn, resolveConfigUser as jr, listCommand$8 as jt, listWorkflows as k, MIGRATE_TEST_FILE_NAME as kn, readPlatformConfig as kr, triggerCommand as kt, removeUser as l, waitForExecution as ln, PluginManager as lr, getFolder as lt, restoreCommand as m, formatRemoteVerificationResults as mn, apiCall as mr, listCommand$5 as mt, errorToJson as n, createWorkspace$1 as nn, getNamespacesWithMigrations as nr, getCommand$1 as nt, updateCommand as o, getMigrationMachineUser as on, sdkNameLabelKey as or, listCommand$4 as ot, inviteUser as p, fetchRemoteSchemaSnapshot as pn, prompt as pr, createFolder as pt, logBetaWarning as q, reconstructSnapshotFromMigrations as qn, getExecutor as qt, serializeError as r, formatKeyValueTable as rn, selectTargetNamespace as rr, getOrganization as rt, updateUser as s, updateMigrationLabel as sn, sdkVersionLabelKey as sr, listFolders as st, registerTsHook as t, createValidatedWorkspaceWithClient as tn, hasChanges as tr, listOrganizations as tt, listCommand as u, formatMigrationScriptCommand as un, generateUserTypes as ur, deleteCommand$1 as ut, deleteCommand as v, fetchRemoteMigrationNumber as vn, fetchLatestToken as vr, getMachineUserToken as vt, waitCommand as w, captureMigrationFileState as wn, loadMachineUserName as wr, listFunctionRegistries as wt, listCommand$1 as x, generateAllTypeManifestsFromSnapshot as xn, loadAccessToken as xr, listMachineUsers as xt, deleteWorkspace as y, fetchRemoteMigrationState as yn, hasAnyUserTokenEntry as yr, tokenCommand as yt, scriptCommand as z, getLatestMigrationNumber as zn, deploymentArgs as zr, startWorkflow as zt };
-//# sourceMappingURL=register-ts-hook-CTth1eqj.mjs.map
+export { treeCommand as $, sanitizeMigrationLabel as $n, listWorkspaces as $t, truncate as A, MIGRATION_FILE_NAMES as An, readPlatformConfig as Ar, triggerExecutor as At, MIGRATION_REVIEW_REQUIRED_MARKER as B, getLatestMigrationNumber as Bn, deploymentArgs as Br, getCommand$5 as Bt, healthCommand as C, captureFileState as Cn, loadConfigPath as Cr, listCommand$7 as Ct, resumeWorkflow as D, INITIAL_SCHEMA_NUMBER as Dn, loadStoredUserTokens as Dr, listWebhookExecutors as Dt, resumeCommand as E, DIFF_FILE_NAME as En, loadPlatformClientConfig as Er, getFunctionRegistry as Et, chunkSeedData as F, assertValidMigrationFiles as Fn, writePlatformConfig as Fr, jobsCommand as Ft, showCommand as G, loadDiff as Gn, resolveMachineUserInputSource as Gr, functionExecutionStatusToString as Gt, deployCommand as H, getMigrationFilePath as Hn, multiConfigArg as Hr, executionsCommand as Ht, bundleSeedScript as I, compareLocalTypesWithSnapshot as In, defineAppCommand as Ir, listExecutorJobs as It, remove as J, reconstructSnapshotFromMigrations as Jn, deploy as Jt, extractOwnedNamespaces as K, loadSnapshot as Kn, toPageDirection as Kr, getCommand$6 as Kt, generate as L, compareSnapshots as Ln, commonArgs as Lr, watchExecutorJob as Lt, loadSeedContext as M, SCHEMA_FILE_NAME as Mn, resolveConfigUser as Mr, listExecutors as Mt, loadApplicationNamespaces as N, UnsupportedMigrationFileVersionError as Nn, resolveUserTokenKey as Nr, getExecutorJob as Nt, listCommand$2 as O, MIGRATE_FILE_NAME as On, loadWorkspaceId as Or, webhookCommand as Ot, loadTailorDBNamespaces as P, assertMigrationNumberExists as Pn, saveUserTokens as Pr, getExecutorWaitFailureMessage as Pt, organizationTree as Q, handleOptionalToRequiredError as Qn, listCommand$9 as Qt, generateCommand as R, createSnapshotFromLocalTypes as Rn, configArg as Rr, startCommand as Rt, getAppHealth as S, protoGqlPermission as Sn, loadAccessToken as Sr, generate$1 as St, waitWorkflowExecution as T, DB_TYPES_FILE_NAME as Tn, loadMachineUserName as Tr, getCommand$4 as Tt, deployStaticWebsite as U, getMigrationFiles as Un, pagedLogArgs as Ur, getWorkflowExecution as Ut, generateSchemaFile as V, getMigrationDirPath as Vn, isVerbose as Vr, getWorkflow as Vt, show as W, getNextMigrationNumber as Wn, paginationArgs as Wr, listWorkflowExecutions as Wt, updateCommand$1 as X, MIGRATION_LABEL_KEY as Xn, deployMigrationTestBaseline as Xt, removeCommand$1 as Y, MIGRATION_HISTORY_LABEL_KEY as Yn, deployFromCLI as Yt, updateOrganization as Z, createMigrationHistoryId as Zn, deployMigrationTestTarget as Zt, getWorkspace as _, verifyRemoteSchema as _n, loadConfig as _r, getOAuth2Client as _t, queryCommand as a, ensureConfigId as an, resourceTrn as ar, updateFolder as at, listApps as b, compareSnapshotWithRemote as bn, hasAnyUserTokenEntry as br, listCommand$6 as bt, removeCommand as c, executeScript as cn, sdkVersionLabelKey as cr, getCommand$2 as ct, listUsers as d, bundleMigrationScript as dn, generateUserTypes as dr, deleteFolder as dt, createCommand$1 as en, formatDiffSummary as er, listCommand$3 as et, inviteCommand as f, checkMigrationDiffs as fn, formatMigrationNumber as fr, createCommand as ft, getCommand as g, toTailorDBDeployInput as gn, assertWritable as gr, getCommand$3 as gt, restoreWorkspace as h, logRemoteDriftGuidance as hn, apiCall as hr, listOAuth2Clients as ht, query as i, workspaceNameSchema as in, selectTargetNamespace as ir, updateCommand$2 as it, truncateCommand as j, MIGRATION_NUMBER_PATTERN as jn, removeLegacyUserAlias as jr, listCommand$8 as jt, listWorkflows as k, MIGRATE_TEST_FILE_NAME as kn, platformConfigFromProfile as kr, triggerCommand as kt, removeUser as l, waitForExecution as ln, writeMetadataLabels as lr, getFolder as lt, restoreCommand as m, formatRemoteVerificationResults as mn, prompt as mr, listCommand$5 as mt, errorToJson as n, createWorkspace$1 as nn, hasChanges as nr, getCommand$1 as nt, updateCommand as o, getMigrationMachineUser as on, sdkAppIdLabelKey as or, listCommand$4 as ot, inviteUser as p, fetchRemoteSchemaSnapshot as pn, parseMigrationNumberArg as pr, createFolder as pt, logBetaWarning as q, normalizeSchemaSnapshot as qn, workspaceArgs as qr, getExecutor as qt, serializeError as r, formatKeyValueTable as rn, getNamespacesWithMigrations as rr, getOrganization as rt, updateUser as s, updateMigrationLabel as sn, sdkNameLabelKey as sr, listFolders as st, registerTsHook as t, createValidatedWorkspaceWithClient as tn, formatMigrationDiff as tr, listOrganizations as tt, listCommand as u, formatMigrationScriptCommand as un, PluginManager as ur, deleteCommand$1 as ut, deleteCommand as v, fetchRemoteMigrationNumber as vn, deleteUserTokens as vr, getMachineUserToken as vt, waitCommand as w, captureMigrationFileState as wn, loadConsoleBaseUrl as wr, listFunctionRegistries as wt, listCommand$1 as x, generateAllTypeManifestsFromSnapshot as xn, hasUserTokenEntry as xr, listMachineUsers as xt, deleteWorkspace as y, fetchRemoteMigrationState as yn, fetchLatestToken as yr, tokenCommand as yt, scriptCommand as z, formatSchemaDrifts as zn, confirmationArgs as zr, startWorkflow as zt };
+//# sourceMappingURL=register-ts-hook-ClI226n2.mjs.map