@tailor-platform/sdk 2.0.1 → 2.2.0

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

@@ -1,18 +1,20 @@
 import { t as db } from "./schema--xYWRGfe.mjs";
-import { $ as CreateAuthHookRequestSchema, B as IdPLang, Bt as Subgraph_ServiceType, C as CreateStaticWebsiteRequestSchema, Ct as AuthInvokerSchema, D as CreateSecretManagerSecretRequestSchema, Dt as AuthSCIMAttribute_Type, Et as AuthSCIMAttribute_Mutability, Ft as CreateApplicationRequestSchema, H as IdPPermissionPermit, Ht as UpdateAIGatewayRequestSchema, I as PipelineResolver_OperationType, It as GetApplicationSchemaHealthResponse_ApplicationSchemaHealthStatus, Jt as FilterSchema, K as CreateExecutorExecutorRequestSchema, Kt as ConditionSchema, L as CreateIdPServiceRequestSchema, Lt as UpdateApplicationRequestSchema, 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, S as AddCustomDomainRequestSchema, St as AuthIDPConfig_AuthType, Tt as AuthOAuth2Client_GrantType, U as FunctionExecution_Status, V as IdPPermissionOperator, Vt as CreateAIGatewayRequestSchema, X as ExecutorTargetType, Y as ExecutorJobStatus, Yt as PageDirection, 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 Condition_Operator, 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, zt as ApplicationSchemaUpdateAttemptStatus } from "./workspace_resource_pb-DXnO2AT-.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, t as CIPromptError } from "./logger-CXQq9YIp.mjs";
-import { $ as LOG_LEVELS, A as hashContent, B as getConsoleBaseUrl, D as hasGenerationHooks, E as getPluginGenerationDependencies, F as fetchAllTolerant, G as initOperatorClient, H as getOrNull, I as fetchMachineUserToken, J as normalizeBaseUrl, K as isDefaultPlatform, L as fetchPaged, N as defaultPlatformBaseUrl, O as createBundleCache, P as fetchAll, Q as createApplyLimiter, T as createBundleLog, U as getPlatformBaseUrl, V as getOAuth2ClientId, W as initOAuth2Client, X as resolveStaticWebsiteUrls, Y as rememberPlatformConfigForToken, Z as byName, _ as stringifyFunction, b as resolveTSConfigWithFallback, f as buildExecutorArgsExpr, g as assertUniqueTailorDBTypeNamesWithExternal, h as assertUniqueLocalTailorDBTypeNames, i as resolverBundleKey, j as hashFile, k as getDistDir, n as generatePluginFilesIfNeeded, o as getApplicationAuthNamespace, p as buildResolverOperationHookExpr, q as isNotFoundError, r as loadApplication, s as WorkflowJobFunctionExecutionPolicySchema, t as defineApplication, u as HTTP_METHODS, v as createGeneratedEntryResolverPlugin, x as platformBundleDefinePlugin, y as createTsconfigPathsPlugin, z as fetchUserInfo } from "./application-CM6hKnSK.mjs";
-import { c as stripTailorDBTypeBuilderHelpers, g as functionSchema, h as loadFilesWithIgnores, t as createExecutorService, u as TailorDBTypeSchema$1 } from "./service-k1xy_A5G.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 { 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 { n as isCLIError, t as createCLIError } from "./errors-D7583Zz7.mjs";
+import { i as isCLIError, n as formatCopyableCommand, t as createCLIError } from "./errors-CWj21238.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";
 import * as mod from "node:module";
 import * as path from "pathe";
 import { basename, dirname, join, resolve } from "pathe";
+import { resolveTSConfig } from "pkg-types";
 import { arg, createDefineCommand, defineCommand, runCommand } from "politty";
 import { z } from "zod";
 import { create, fromJson, toJson } from "@bufbuild/protobuf";
@@ -206,9 +208,26 @@ const workspaceArgs = {
 	})
 };
 /**
+* Default config file path used when --config is not passed
+*/
+const DEFAULT_CONFIG_PATH = "tailor.config.ts";
+/**
+* Format the --config argument for remediation command hints so they target
+* the same config the current run used. The `--config=<value>` form keeps a
+* leading-hyphen path bound as the option value.
+* @param {string} [configPath] - Config path the current run used, if any
+* @returns {string | undefined} `--config=<path>` argument, or undefined when the default config is in use
+*/
+function formatConfigArg(configPath) {
+	if (!configPath) return void 0;
+	const relativeConfigPath = path.relative(process.cwd(), configPath);
+	if (relativeConfigPath === "tailor.config.ts") return void 0;
+	return `--config=${relativeConfigPath}`;
+}
+/**
 * Shared config arg for commands that accept a config file path
 */
-const configArg = { config: arg(z.string().default("tailor.config.ts"), {
+const configArg = { config: arg(z.string().default(DEFAULT_CONFIG_PATH), {
 	alias: "c",
 	description: "Path to Tailor config file",
 	env: "TAILOR_CONFIG_PATH",
@@ -220,7 +239,7 @@ const configArg = { config: arg(z.string().default("tailor.config.ts"), {
 /**
 * Shared config arg for commands that accept one or more comma-separated config file paths
 */
-const multiConfigArg = { config: arg(z.string().default("tailor.config.ts"), {
+const multiConfigArg = { config: arg(z.string().default(DEFAULT_CONFIG_PATH), {
 	alias: "c",
 	description: "Path to SDK config file. Use comma-separated paths to deploy multiple apps together.",
 	env: "TAILOR_PLATFORM_SDK_CONFIG_PATH",
@@ -1675,6 +1694,35 @@ function createCacheManager(options) {
 	};
 }
 
+//#endregion
+//#region src/cli/commands/tailordb/migrate/migration-number.ts
+/**
+* Format migration number as 4-digit string.
+* @param num - Migration number
+* @returns 4-digit padded string
+*/
+function formatMigrationNumber(num) {
+	return num.toString().padStart(4, "0");
+}
+/**
+* Parse a migration number CLI argument.
+*
+* Accepts the canonical 4-digit form ("0001") or a bare integer without
+* leading zeros ("0"–"9999"). Commands that disallow the baseline reject
+* 0 themselves with a context-specific message.
+* @param numberStr - Raw CLI argument
+* @returns Parsed migration number
+*/
+function parseMigrationNumberArg(numberStr) {
+	if (/^\d{4}$/.test(numberStr)) return parseInt(numberStr, 10);
+	if (/^(0|[1-9]\d*)$/.test(numberStr)) {
+		const parsed = parseInt(numberStr, 10);
+		if (parsed > 9999) throw new Error(`Migration number ${numberStr} is out of range. Expected 0-9999.`);
+		return parsed;
+	}
+	throw new Error(`Invalid migration number format: ${numberStr}. Expected 4-digit format (e.g., 0001) or integer 0-9999 (e.g., 1).`);
+}
+
 //#endregion
 //#region src/cli/shared/publish-events.ts
 /**
@@ -4983,6 +5031,9 @@ async function applyAuth(client, result, phase = "create-update") {
 	const applyMachineUsers = async () => {
 		await Promise.all([...changeSet.machineUser.creates.map((create) => client.createAuthMachineUser(create.request)), ...changeSet.machineUser.updates.map((update) => client.updateAuthMachineUser(update.request))]);
 	};
+	const applyUserProfileDeletes = async () => {
+		await Promise.all(changeSet.userProfileConfig.deletes.map((del) => client.deleteUserProfileConfig(del.request)));
+	};
 	const applyCreateUpdateDependents = async () => {
 		await applyAuthConnections(client, {
 			changeSet: changeSet.connection,
@@ -5028,7 +5079,7 @@ async function applyAuth(client, result, phase = "create-update") {
 		await Promise.all(changeSet.authHook.deletes.map((del) => client.deleteAuthHook(del.request)));
 		await Promise.all(changeSet.machineUser.deletes.map((del) => client.deleteAuthMachineUser(del.request)));
 		await Promise.all(changeSet.tenantConfig.deletes.map((del) => client.deleteTenantConfig(del.request)));
-		await Promise.all(changeSet.userProfileConfig.deletes.map((del) => client.deleteUserProfileConfig(del.request)));
+		await applyUserProfileDeletes();
 		await Promise.all(changeSet.idpConfig.deletes.map((del) => client.deleteAuthIDPConfig(del.request)));
 		await applyAuthConnections(client, {
 			changeSet: changeSet.connection,
@@ -7476,7 +7527,8 @@ function formatDiffChange(change) {
 			return `  + ${change.fieldName}: ${typeStr}`;
 		}
 		case "field_removed": return `  - ${change.fieldName}: ${change.before.type}`;
-		case "field_modified": return `  ~ ${change.fieldName}: ${formatFieldModification(change.before, change.after)}`;
+		case "field_modified":
+		case "field_type_modified": return `  ~ ${change.fieldName}: ${formatFieldModification(change.before, change.after)}`;
 		case "index_added": return `  + [Index] ${change.indexName}`;
 		case "index_removed": return `  - [Index] ${change.indexName}`;
 		case "index_modified": return `  ~ [Index] ${change.indexName}: ${change.reason ?? "modified"}`;
@@ -7573,6 +7625,7 @@ const DIFF_CHANGE_LABELS = {
 	field_added: "field(s) added",
 	field_removed: "field(s) removed",
 	field_modified: "field(s) modified",
+	field_type_modified: "field type(s) modified",
 	index_added: "index(es) added",
 	index_removed: "index(es) removed",
 	index_modified: "index(es) modified",
@@ -7598,32 +7651,108 @@ function formatDiffSummary(diff) {
 }
 
 //#endregion
-//#region src/cli/commands/tailordb/migrate/migration-number.ts
+//#region src/cli/commands/tailordb/migrate/field-type-change.ts
 /**
-* Format migration number as 4-digit string.
-* @param num - Migration number
-* @returns 4-digit padded string
+* Scalar type changes whose complete source domain is accepted by the target
+* representation without relying on per-row index recreation.
+*
+* 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([
+	"decimal:string",
+	"enum:string",
+	"integer:float",
+	"uuid:string"
+]);
+/**
+* Determine whether a field type change can use a single phased migration.
+* @param before - Previous field configuration
+* @param after - Target field configuration
+* @returns Whether the migration can normalize data before applying the type
 */
-function formatMigrationNumber(num) {
-	return num.toString().padStart(4, "0");
+function supportsInPlaceFieldTypeChange(before, after) {
+	if (before.type === after.type) return false;
+	if (before.array || after.array) return false;
+	if (before.type === "nested" || after.type === "nested") return false;
+	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}`);
 }
+
+//#endregion
+//#region src/cli/commands/tailordb/migrate/types.ts
 /**
-* Parse a migration number CLI argument.
-*
-* Accepts the canonical 4-digit form ("0001") or a bare integer without
-* leading zeros ("0"–"9999"). Commands that disallow the baseline reject
-* 0 themselves with a context-specific message.
-* @param numberStr - Raw CLI argument
-* @returns Parsed migration number
+* Types for TailorDB migration execution
 */
-function parseMigrationNumberArg(numberStr) {
-	if (/^\d{4}$/.test(numberStr)) return parseInt(numberStr, 10);
-	if (/^(0|[1-9]\d*)$/.test(numberStr)) {
-		const parsed = parseInt(numberStr, 10);
-		if (parsed > 9999) throw new Error(`Migration number ${numberStr} is out of range. Expected 0-9999.`);
-		return parsed;
+/**
+* Maximum length for Kubernetes label values
+* Labels must match pattern: ^[a-z][a-z0-9_-]{0,62}
+*/
+const MAX_LABEL_LENGTH = 63;
+/**
+* Prefix added to migration numbers in labels (required because migration names start with numbers)
+*/
+const MIGRATION_LABEL_PREFIX = "m";
+/**
+* Label key for storing migration state in TailorDB Service metadata
+*/
+const MIGRATION_LABEL_KEY = "sdk-migration";
+/** Label key identifying which migration history ID is deployed. */
+const MIGRATION_HISTORY_LABEL_KEY = "sdk-migration-history";
+/** Valid migration history ID syntax for metadata label values. */
+const MIGRATION_HISTORY_ID_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/;
+/**
+* Sanitize migration number for use as label value
+* Label pattern: ^[a-z][a-z0-9_-]{0,62}
+* - Must start with lowercase letter (add prefix since migration numbers start with digits)
+* - Max 63 characters
+* @param {number} migrationNumber - Migration number to sanitize
+* @returns {string} Sanitized label value
+*/
+function sanitizeMigrationLabel(migrationNumber) {
+	return (MIGRATION_LABEL_PREFIX + formatMigrationNumber(migrationNumber)).slice(0, 63);
+}
+/**
+* Parse migration number from label value
+* @param {string} label - Label value (e.g., "m0001")
+* @returns {number | null} Parsed number or null if invalid
+*/
+function parseMigrationLabelNumber(label) {
+	if (!label.startsWith(MIGRATION_LABEL_PREFIX)) return null;
+	const numStr = label.slice(1);
+	if (!/^\d+$/.test(numStr)) return null;
+	const num = parseInt(numStr, 10);
+	return num > 9999 ? null : num;
+}
+/**
+* Parse and validate a migration history ID stored in metadata.
+* @param label - Metadata label value
+* @returns Valid history ID, or null for malformed input
+*/
+function parseMigrationHistoryId(label) {
+	return MIGRATION_HISTORY_ID_PATTERN.test(label) ? label : null;
+}
+/**
+* Create a migration history ID that is valid as a metadata label value.
+* @returns New migration history ID
+*/
+function createMigrationHistoryId() {
+	return `h${randomUUID().replaceAll("-", "")}`;
+}
+/**
+* Handle optional-to-required field change error with helpful message
+* @param {unknown} error - Error to handle
+* @param {string[]} messages - Additional messages to display
+*/
+function handleOptionalToRequiredError(error, messages) {
+	if (error instanceof ConnectError && error.code === Code.FailedPrecondition && error.message.includes("cannot be updated from non-required to required when records exist")) {
+		logger.error("Schema change failed: Cannot change field from optional to required when records exist.");
+		logger.newline();
+		for (const message of messages) logger.info(message);
 	}
-	throw new Error(`Invalid migration number format: ${numberStr}. Expected 4-digit format (e.g., 0001) or integer 0-9999 (e.g., 1).`);
+	throw error;
 }
 
 //#endregion
@@ -7781,11 +7910,17 @@ const tailorDBSnapshotTypeSchema = z.looseObject({
 		gql: snapshotGqlPermissionSchema.optional()
 	}).optional()
 });
+const rebaselineMarkerSchema = z.looseObject({
+	historyId: z.string().regex(MIGRATION_HISTORY_ID_PATTERN),
+	replacedHistoryId: z.string().regex(MIGRATION_HISTORY_ID_PATTERN).nullable(),
+	replacedLatestMigration: z.number().int().min(0).max(9999)
+});
 const schemaSnapshotSchema = z.looseObject({
 	version: z.number(),
 	namespace: z.string(),
 	createdAt: z.string(),
-	types: snapshotRecordSchema(tailorDBSnapshotTypeSchema)
+	types: snapshotRecordSchema(tailorDBSnapshotTypeSchema),
+	rebaseline: rebaselineMarkerSchema.optional()
 });
 const typeSettingsPatchSchema = z.looseObject({
 	indexes: snapshotRecordSchema(snapshotIndexConfigSchema).optional(),
@@ -7858,6 +7993,14 @@ const fieldModifiedChangeSchema = z.looseObject({
 	before: snapshotFieldConfigSchema,
 	after: snapshotFieldConfigSchema
 });
+const fieldTypeModifiedChangeSchema = z.looseObject({
+	kind: z.literal("field_type_modified"),
+	typeName: z.string(),
+	reason: z.string().optional(),
+	fieldName: z.string(),
+	before: snapshotFieldConfigSchema,
+	after: snapshotFieldConfigSchema
+});
 const indexAddedChangeSchema = z.looseObject({
 	kind: z.literal("index_added"),
 	typeName: z.string(),
@@ -7956,6 +8099,7 @@ const diffChangeSchema = z.discriminatedUnion("kind", [
 	fieldAddedChangeSchema,
 	fieldRemovedChangeSchema,
 	fieldModifiedChangeSchema,
+	fieldTypeModifiedChangeSchema,
 	indexAddedChangeSchema,
 	indexRemovedChangeSchema,
 	indexModifiedChangeSchema,
@@ -8026,6 +8170,8 @@ const SCHEMA_FILE_NAME = "schema.json";
 const DIFF_FILE_NAME = "diff.json";
 /** File name for migration script. */
 const MIGRATE_FILE_NAME = "migrate.ts";
+/** File name for migration script unit test. */
+const MIGRATE_TEST_FILE_NAME = "migrate.test.ts";
 /** File name for generated DB type definitions. */
 const DB_TYPES_FILE_NAME = "db.ts";
 /**
@@ -8038,6 +8184,19 @@ const MIGRATION_NUMBER_PATTERN = /^\d{4}$/;
 * Must stay in sync with the platform's default decimal scale.
 */
 const DEFAULT_DECIMAL_SCALE = 6;
+var UnsupportedMigrationFileVersionError = class extends Error {};
+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}`;
+	let guidance;
+	if (version > 2) 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}`);
+}
 function createSnapshotRecord() {
 	return Object.create(null);
 }
@@ -8113,6 +8272,7 @@ const MIGRATION_FILE_NAMES = {
 	schema: SCHEMA_FILE_NAME,
 	diff: DIFF_FILE_NAME,
 	migrate: MIGRATE_FILE_NAME,
+	test: MIGRATE_TEST_FILE_NAME,
 	db: DB_TYPES_FILE_NAME
 };
 /**
@@ -8278,7 +8438,7 @@ function createSnapshotFromLocalTypes(types, namespace) {
 	const snapshotTypes = createSnapshotRecord();
 	for (const [typeName, type] of Object.entries(types)) snapshotTypes[typeName] = createSnapshotType(type);
 	return normalizeSchemaSnapshot({
-		version: 1,
+		version: 2,
 		namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 		types: snapshotTypes
@@ -8297,6 +8457,7 @@ function loadSnapshot(filePath) {
 	} catch (error) {
 		throw new Error(`Invalid schema snapshot at ${filePath}: ${String(error)}`, { cause: error });
 	}
+	assertSupportedMigrationFileVersion(filePath, raw);
 	const result = schemaSnapshotSchema.safeParse(raw);
 	if (!result.success) throw new Error(`Invalid schema snapshot at ${filePath}: ${z.prettifyError(result.error)}`, { cause: result.error });
 	const snapshot = result.data;
@@ -8315,16 +8476,38 @@ function loadDiff(filePath) {
 	} catch (error) {
 		throw new Error(`Invalid migration diff at ${filePath}: ${String(error)}`, { cause: error });
 	}
+	assertSupportedMigrationFileVersion(filePath, raw);
 	const result = migrationDiffSchema.safeParse(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 ?? [];
+	const warnings = parsed.warnings ?? deriveWarningsFromChanges(parsed);
 	return {
 		...parsed,
 		warnings,
 		hasWarnings: warnings.length > 0
 	};
 }
+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)";
+/**
+* Reconstruct data-loss warnings from removal changes for diff.json files
+* written before the warning tier existed
+* @param {MigrationDiff} diff - Parsed legacy migration diff
+* @returns {WarningChangeInfo[]} Warnings equivalent to what diff generation would have recorded
+*/
+function deriveWarningsFromChanges(diff) {
+	const warnings = [];
+	for (const change of diff.changes) if (change.kind === "field_removed") warnings.push({
+		typeName: change.typeName,
+		fieldName: change.fieldName,
+		reason: FIELD_REMOVED_WARNING_REASON
+	});
+	else if (change.kind === "type_removed") warnings.push({
+		typeName: change.typeName,
+		reason: TYPE_REMOVED_WARNING_REASON
+	});
+	return warnings;
+}
 /**
 * Get all migration directories and their files, sorted by number
 * @param {string} migrationsDir - Migrations directory path
@@ -8415,7 +8598,8 @@ function applyDiffToSnapshot(snapshot, diff) {
 			break;
 		}
 		case "field_added":
-		case "field_modified": {
+		case "field_modified":
+		case "field_type_modified": {
 			const existing = types[change.typeName];
 			if (existing) {
 				const fields = copySnapshotRecord(existing.fields);
@@ -8688,13 +8872,18 @@ function getBreakingFieldChanges(typeName, fieldName, oldField, newField) {
 		fieldName,
 		reason: "Required field added"
 	});
-	if (oldField && newField && oldField.type !== newField.type) breakingChanges.push({
-		typeName,
-		fieldName,
-		reason: `Field type changed from ${oldField.type} to ${newField.type}`,
-		unsupported: true,
-		showThreeStepHint: true
-	});
+	if (oldField && newField && oldField.type !== newField.type) {
+		const supported = supportsInPlaceFieldTypeChange(oldField, newField);
+		breakingChanges.push({
+			typeName,
+			fieldName,
+			reason: `Field type changed from ${oldField.type} to ${newField.type}`,
+			...!supported && {
+				unsupported: true,
+				showThreeStepHint: true
+			}
+		});
+	}
 	if (oldField && newField && !oldField.required && newField.required) breakingChanges.push({
 		typeName,
 		fieldName,
@@ -8754,7 +8943,7 @@ function addChange(ctx, change, oldField, newField) {
 	if (change.kind === "field_removed") ctx.warnings.push({
 		typeName: change.typeName,
 		fieldName: change.fieldName,
-		reason: "Field removed (existing data will be dropped in the post-migration phase)"
+		reason: FIELD_REMOVED_WARNING_REASON
 	});
 }
 function compareTypeFields(ctx, typeName, prevType, currType) {
@@ -8783,7 +8972,7 @@ function compareTypeFields(ctx, typeName, prevType, currType) {
 		const prevField = assertDefined(prevType.fields[fieldName], `field "${fieldName}" missing from prevType`);
 		const currField = assertDefined(currType.fields[fieldName], `field "${fieldName}" missing from currType`);
 		if (areFieldsDifferent(prevField, currField)) addChange(ctx, {
-			kind: "field_modified",
+			kind: prevField.type === currField.type ? "field_modified" : "field_type_modified",
 			typeName,
 			fieldName,
 			before: prevField,
@@ -9105,7 +9294,7 @@ function compareNormalizedSnapshots(previous, current) {
 		});
 		ctx.warnings.push({
 			typeName,
-			reason: "Type removed (all records of this type will be dropped in the post-migration phase)"
+			reason: TYPE_REMOVED_WARNING_REASON
 		});
 	}
 	for (const typeName of currentTypeNames) {
@@ -9122,7 +9311,7 @@ function compareNormalizedSnapshots(previous, current) {
 		comparePermissions(ctx, typeName, prevType.permissions?.record, currType.permissions?.record, prevType.permissions?.gql, currType.permissions?.gql);
 	}
 	return {
-		version: 1,
+		version: 2,
 		namespace: current.namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 		changes: ctx.changes,
@@ -9146,7 +9335,7 @@ function compareNormalizedSnapshots(previous, current) {
 */
 function compareLocalTypesWithSnapshot(snapshot, localTypes, namespace) {
 	return compareSnapshots(snapshot, {
-		version: 1,
+		version: 2,
 		namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 		types: localTypes
@@ -9465,7 +9654,7 @@ function createSnapshotFromRemoteTypes(remoteTypes, namespace, remoteGqlPermissi
 		};
 	}
 	return normalizeSchemaSnapshot({
-		version: 1,
+		version: 2,
 		namespace,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 		types
@@ -9721,7 +9910,8 @@ function schemaDriftFromDiffChange(change) {
 			fieldName: change.fieldName,
 			details: `Field '${change.fieldName}' exists in remote but not in snapshot`
 		};
-		case "field_modified": return fieldDriftFromChange(change);
+		case "field_modified":
+		case "field_type_modified": return fieldDriftFromChange(change);
 		case "index_added": return {
 			typeName: change.typeName,
 			kind: "index_missing_remote",
@@ -9822,6 +10012,95 @@ function formatSchemaDrifts(drifts) {
 	return lines.join("\n");
 }
 
+//#endregion
+//#region src/cli/commands/tailordb/migrate/file-state.ts
+const MIGRATION_FILE_KINDS = [
+	"schema",
+	"diff",
+	"migrate",
+	"db"
+];
+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);
+}
+function updateHashWithDirectory(hash, directoryPath, prefix = "", activeDirectories = /* @__PURE__ */ new Set()) {
+	const realDirectoryPath = fs$2.realpathSync(directoryPath);
+	if (activeDirectories.has(realDirectoryPath)) {
+		hash.update(`directory-cycle\0${prefix}\0${realDirectoryPath}\0`);
+		return;
+	}
+	activeDirectories.add(realDirectoryPath);
+	const entries = fs$2.readdirSync(directoryPath, { withFileTypes: true }).toSorted((a, b) => a.name.localeCompare(b.name));
+	try {
+		for (const entry of entries) {
+			const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+			const entryPath = path.join(directoryPath, entry.name);
+			if (entry.isDirectory()) {
+				hash.update(`directory\0${relativePath}\0`);
+				updateHashWithDirectory(hash, entryPath, relativePath, activeDirectories);
+			} else if (entry.isFile()) {
+				hash.update(`file\0${relativePath}\0`);
+				hash.update(fs$2.readFileSync(entryPath));
+				hash.update("\0");
+			} else if (entry.isSymbolicLink()) {
+				hash.update(`symlink\0${relativePath}\0${fs$2.readlinkSync(entryPath)}\0`);
+				try {
+					const target = fs$2.statSync(entryPath);
+					if (target.isDirectory()) {
+						hash.update("target-directory\0");
+						updateHashWithDirectory(hash, entryPath, `${relativePath}@target`, activeDirectories);
+					} else if (target.isFile()) {
+						hash.update("target-file\0");
+						hash.update(fs$2.readFileSync(entryPath));
+						hash.update("\0");
+					} else hash.update("target-other\0");
+				} catch (error) {
+					if (error.code !== "ENOENT") throw error;
+					hash.update("target-missing\0");
+				}
+			} else hash.update(`other\0${relativePath}\0`);
+		}
+	} finally {
+		activeDirectories.delete(realDirectoryPath);
+	}
+}
+/**
+* Capture an exact set of input files.
+* @param filePaths - Files whose names and contents affect an operation
+* @returns SHA-256 digest of the sorted file set
+*/
+function captureFileState(filePaths) {
+	const hash = createHash("sha256");
+	for (const filePath of [...new Set(filePaths)].toSorted()) {
+		hash.update(filePath);
+		hash.update("\0");
+		if (fs$2.existsSync(filePath)) hash.update(fs$2.readFileSync(filePath));
+		else hash.update("<missing>");
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+/**
+* Capture the migration files that an operation depends on.
+* @param namespacesWithMigrations - Configured migration directories by namespace
+* @returns SHA-256 digest by namespace
+*/
+function captureMigrationFileState(namespacesWithMigrations) {
+	const state = Object.create(null);
+	for (const { namespace, migrationsDir } of namespacesWithMigrations.toSorted((a, b) => a.namespace.localeCompare(b.namespace))) {
+		const hash = createHash("sha256");
+		const migrationNumbers = getMigrationArtifactNumbers(migrationsDir);
+		for (const migrationNumber of migrationNumbers) {
+			const migrationDirectoryName = formatMigrationNumber(migrationNumber);
+			hash.update(`migration\0${migrationDirectoryName}\0`);
+			updateHashWithDirectory(hash, path.join(migrationsDir, migrationDirectoryName));
+		}
+		state[namespace] = hash.digest("hex");
+	}
+	return state;
+}
+
 //#endregion
 //#region src/cli/commands/tailordb/migrate/snapshot-manifest.ts
 /**
@@ -9859,11 +10138,7 @@ function generateTailorDBTypeManifestFromSnapshot(snapshotType, options = {}) {
 		delete: ops.delete === false,
 		read: ops.read === false
 	};
-	const fields = {};
-	for (const [fieldName, fieldConfig] of Object.entries(snapshotType.fields)) {
-		if (fieldName === "id") continue;
-		fields[fieldName] = convertFieldConfigToProto(fieldConfig);
-	}
+	const fields = Object.fromEntries(Object.entries(snapshotType.fields).filter(([fieldName]) => fieldName !== "id").map(([fieldName, fieldConfig]) => [fieldName, convertFieldConfigToProto(fieldConfig)]));
 	const relationships = {};
 	if (snapshotType.forwardRelationships) for (const [relationName, rel] of Object.entries(snapshotType.forwardRelationships)) relationships[relationName] = convertRelationshipToProto(rel, "forward");
 	if (snapshotType.backwardRelationships) for (const [relationName, rel] of Object.entries(snapshotType.backwardRelationships)) relationships[relationName] = convertRelationshipToProto(rel, "backward");
@@ -10256,6 +10531,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_type_modified`: keep the complete previous field config until
+*   Post-phase so migrate.ts runs against the previous type contract.
 *
 * and the type-level index adjustments:
 *
@@ -10275,6 +10552,7 @@ function protoGqlOperand(operand) {
 const PRE_MIGRATION_FIELD_KINDS = /* @__PURE__ */ new Set([
 	"field_added",
 	"field_modified",
+	"field_type_modified",
 	"field_removed"
 ]);
 /**
@@ -10287,6 +10565,38 @@ function isPreMigrationFieldChange(change) {
 	return PRE_MIGRATION_FIELD_KINDS.has(change.kind);
 }
 /**
+* Create the type snapshot used to build a Pre-phase manifest.
+*
+* This adjustment happens before manifest generation because field hooks and
+* validators are aggregated into type-level scripts by the manifest builder.
+* Replacing only the generated field proto would leave those scripts on the
+* target field contract while migrate.ts still runs against the previous one.
+* @param snapshotType - Final snapshot state for this migration
+* @param typeChanges - Field changes for this type, keyed by field name
+* @param typeScriptsChange - Type-level scripts changed by the same migration
+* @returns A snapshot with Pre-phase field contracts
+*/
+function createPreMigrationSnapshotType(snapshotType, typeChanges, typeScriptsChange) {
+	const fields = structuredClone(snapshotType.fields);
+	let hasFieldTypeChange = false;
+	for (const [fieldName, change] of typeChanges) {
+		if (change.kind !== "field_type_modified") continue;
+		hasFieldTypeChange = true;
+		fields[fieldName] = structuredClone(change.before);
+	}
+	const preSnapshotType = {
+		...snapshotType,
+		fields
+	};
+	if (!hasFieldTypeChange || !typeScriptsChange) return preSnapshotType;
+	const { typeHookExpr: _targetHook, typeValidateExpr: _targetValidate, ...withoutTypeScripts } = preSnapshotType;
+	return {
+		...withoutTypeScripts,
+		...typeScriptsChange.before.typeHookExpr && { typeHookExpr: structuredClone(typeScriptsChange.before.typeHookExpr) },
+		...typeScriptsChange.before.typeValidateExpr !== void 0 && { typeValidateExpr: typeScriptsChange.before.typeValidateExpr }
+	};
+}
+/**
 * 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
@@ -10327,6 +10637,10 @@ function applyPreMigrationFieldAdjustments(fields, typeChanges) {
 			if (change.after.required) field.required = false;
 			continue;
 		}
+		if (change.kind === "field_type_modified") {
+			fields[fieldName] = convertFieldConfigToProto(change.before);
+			continue;
+		}
 		const { before, after } = change;
 		if (!before.required && after.required) field.required = false;
 		if (!(before.unique ?? false) && (after.unique ?? false)) field.unique = false;
@@ -10385,83 +10699,72 @@ function applyPreMigrationIndexAdjustments(indexes, typeIndexChanges) {
 }
 
 //#endregion
-//#region src/cli/commands/tailordb/migrate/types.ts
-/**
-* Types for TailorDB migration execution
-*/
+//#region src/cli/commands/tailordb/migrate/remote-state.ts
 /**
-* Maximum length for Kubernetes label values
-* Labels must match pattern: ^[a-z][a-z0-9_-]{0,62}
+* Fetch the namespace's migration checkpoint and history ID.
+* @param client - Operator client
+* @param trn - Namespace TRN
+* @returns Parsed migration state with invalid history labels kept distinct from missing labels
 */
-const MAX_LABEL_LENGTH = 63;
+async function fetchRemoteMigrationState(client, trn) {
+	const metadata = await getOrNull(async () => {
+		const { metadata } = await client.getMetadata({ trn });
+		return metadata;
+	});
+	if (!metadata) return {
+		metadataExists: false,
+		number: null,
+		historyId: null,
+		historyIdInvalid: false
+	};
+	const migrationLabel = metadata.labels[MIGRATION_LABEL_KEY];
+	const historyLabel = metadata.labels[MIGRATION_HISTORY_LABEL_KEY];
+	const historyId = historyLabel ? parseMigrationHistoryId(historyLabel) : null;
+	return {
+		metadataExists: true,
+		number: migrationLabel ? parseMigrationLabelNumber(migrationLabel) : null,
+		historyId,
+		historyIdInvalid: historyLabel !== void 0 && historyId === null
+	};
+}
 /**
-* Prefix added to migration numbers in labels (required because migration names start with numbers)
+* Fetch the namespace's current migration number from its metadata labels.
+*
+* Only a namespace that has not been deployed yet reads as "no current
+* migration". Every other lookup failure must propagate: treating it as
+* unset would misreport a transient error as "no checkpoint", showing
+* every migration as pending to callers.
+* @param client - Operator client
+* @param trn - Namespace TRN
+* @returns Parsed current migration number, or null when unset or unparseable
 */
-const MIGRATION_LABEL_PREFIX = "m";
+async function fetchRemoteMigrationNumber(client, trn) {
+	return (await fetchRemoteMigrationState(client, trn)).number;
+}
+
+//#endregion
+//#region src/cli/commands/tailordb/migrate/schema-checks.ts
 /**
-* Label key for storing migration state in TailorDB Service metadata
+* Schema validation checks shared between `deploy` and
+* `tailordb migration validate`.
+*
+* These checks are read-only: they compare local type definitions, the
+* migration snapshot history, and the remote schema without mutating any
+* state.
 */
-const MIGRATION_LABEL_KEY = "sdk-migration";
 /**
-* Sanitize migration number for use as label value
-* Label pattern: ^[a-z][a-z0-9_-]{0,62}
-* - Must start with lowercase letter (add prefix since migration numbers start with digits)
-* - Max 63 characters
-* @param {number} migrationNumber - Migration number to sanitize
-* @returns {string} Sanitized label value
+* Convert a runtime TailorDBService to the snapshot-shaped deploy input.
+* @param service - Loaded TailorDB service (after `loadTypes()`)
+* @returns The canonical snapshot-shaped deploy input for downstream plan/apply phases.
 */
-function sanitizeMigrationLabel(migrationNumber) {
-	return (MIGRATION_LABEL_PREFIX + formatMigrationNumber(migrationNumber)).slice(0, 63);
-}
-/**
-* Parse migration number from label value
-* @param {string} label - Label value (e.g., "m0001")
-* @returns {number | null} Parsed number or null if invalid
-*/
-function parseMigrationLabelNumber(label) {
-	if (!label.startsWith(MIGRATION_LABEL_PREFIX)) return null;
-	const numStr = label.slice(1);
-	if (!/^\d+$/.test(numStr)) return null;
-	const num = parseInt(numStr, 10);
-	return num > 9999 ? null : num;
-}
-/**
-* Handle optional-to-required field change error with helpful message
-* @param {unknown} error - Error to handle
-* @param {string[]} messages - Additional messages to display
-*/
-function handleOptionalToRequiredError(error, messages) {
-	if (error instanceof ConnectError && error.code === Code.FailedPrecondition && error.message.includes("cannot be updated from non-required to required when records exist")) {
-		logger.error("Schema change failed: Cannot change field from optional to required when records exist.");
-		logger.newline();
-		for (const message of messages) logger.info(message);
-	}
-	throw error;
-}
-
-//#endregion
-//#region src/cli/commands/tailordb/migrate/schema-checks.ts
-/**
-* Schema validation checks shared between `deploy` and
-* `tailordb migration validate`.
-*
-* These checks are read-only: they compare local type definitions, the
-* migration snapshot history, and the remote schema without mutating any
-* state.
-*/
-/**
-* Convert a runtime TailorDBService to the snapshot-shaped deploy input.
-* @param service - Loaded TailorDB service (after `loadTypes()`)
-* @returns The canonical snapshot-shaped deploy input for downstream plan/apply phases.
-*/
-function toTailorDBDeployInput(service) {
-	const types = {};
-	for (const [typeName, type] of Object.entries(service.types)) types[typeName] = createSnapshotType(type);
-	return {
-		namespace: service.namespace,
-		config: service.config,
-		types
-	};
+function toTailorDBDeployInput(service) {
+	const types = {};
+	for (const [typeName, type] of Object.entries(service.types)) types[typeName] = createSnapshotType(type);
+	return {
+		namespace: service.namespace,
+		config: service.config,
+		types
+	};
 }
 /**
 * Fetch all TailorDB types from remote for a namespace
@@ -10492,6 +10795,17 @@ async function fetchRemoteGqlPermissions(client, workspaceId, namespace) {
 		return [permissions, nextPageToken];
 	});
 }
+/**
+* Fetch a namespace's deployed schema as a normalized snapshot.
+* @param client - Operator client instance
+* @param workspaceId - Workspace ID
+* @param namespace - TailorDB namespace
+* @returns The deployed schema snapshot
+*/
+async function fetchRemoteSchemaSnapshot(client, workspaceId, namespace) {
+	const [remoteTypes, remoteGqlPermissions] = await Promise.all([fetchRemoteTypes(client, workspaceId, namespace), fetchRemoteGqlPermissions(client, workspaceId, namespace)]);
+	return createSnapshotFromRemoteTypes(remoteTypes, namespace, remoteGqlPermissions);
+}
 function definedWhenNotEmpty(value) {
 	return Object.keys(value).length > 0 ? value : void 0;
 }
@@ -10547,36 +10861,6 @@ function deployComparableSnapshot(snapshot, remoteTypes, gqlOperations) {
 		types
 	};
 }
-async function getRemoteMigrationNumberState(client, workspaceId, namespace) {
-	const trn = resourceTrn(workspaceId, "tailordb", namespace);
-	const metadata = await getOrNull(async () => {
-		const { metadata } = await client.getMetadata({ trn });
-		return metadata;
-	});
-	if (!metadata) return {
-		metadataExists: false,
-		number: null
-	};
-	const label = metadata.labels[MIGRATION_LABEL_KEY];
-	if (!label) return {
-		metadataExists: true,
-		number: null
-	};
-	return {
-		metadataExists: true,
-		number: parseMigrationLabelNumber(label)
-	};
-}
-/**
-* Get the current migration number from remote metadata
-* @param {OperatorClient} client - Operator client instance
-* @param {string} workspaceId - Workspace ID
-* @param {string} namespace - TailorDB namespace
-* @returns {Promise<number | null>} Current migration number, or null if no migration label exists
-*/
-async function getRemoteMigrationNumber(client, workspaceId, namespace) {
-	return (await getRemoteMigrationNumberState(client, workspaceId, namespace)).number;
-}
 /**
 * Verify remote schema matches the expected snapshot state
 * @param {OperatorClient} client - Operator client instance
@@ -10589,7 +10873,18 @@ async function getRemoteMigrationNumber(client, workspaceId, namespace) {
 async function verifyRemoteSchema(client, workspaceId, namespacesWithMigrations, config, tailorDBInputs) {
 	const results = [];
 	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
-		const { metadataExists, number: remoteMigrationNumber } = await getRemoteMigrationNumberState(client, workspaceId, namespace);
+		const remoteState = await fetchRemoteMigrationState(client, resourceTrn(workspaceId, "tailordb", namespace));
+		const { metadataExists, number: remoteMigrationNumber } = remoteState;
+		if (remoteState.historyIdInvalid || remoteMigrationNumber === null && remoteState.historyId !== null) {
+			results.push({
+				namespace,
+				remoteMigrationNumber: remoteMigrationNumber ?? 0,
+				drifts: [],
+				hasDrift: false,
+				checkpointMissingLocal: true
+			});
+			continue;
+		}
 		if (remoteMigrationNumber === null) {
 			results.push({
 				namespace,
@@ -10600,7 +10895,17 @@ async function verifyRemoteSchema(client, workspaceId, namespacesWithMigrations,
 			});
 			continue;
 		}
-		if (remoteMigrationNumber > getLatestMigrationNumber(migrationsDir)) {
+		const latestMigrationNumber = getLatestMigrationNumber(migrationsDir);
+		const rebaseline = reconstructSnapshotFromMigrations(migrationsDir, 0)?.rebaseline;
+		const historyMatchesCurrent = rebaseline ? remoteState.historyId === rebaseline.historyId : remoteState.historyId === null;
+		const historyMatchesReplaced = rebaseline ? remoteState.historyId === rebaseline.replacedHistoryId : false;
+		const checkpointRepair = rebaseline && historyMatchesReplaced && remoteMigrationNumber === rebaseline.replacedLatestMigration ? {
+			from: remoteMigrationNumber,
+			to: 0,
+			fromHistoryId: remoteState.historyId,
+			toHistoryId: rebaseline.historyId
+		} : void 0;
+		if (!historyMatchesCurrent && !checkpointRepair || remoteMigrationNumber > latestMigrationNumber && !checkpointRepair) {
 			results.push({
 				namespace,
 				remoteMigrationNumber,
@@ -10610,7 +10915,7 @@ async function verifyRemoteSchema(client, workspaceId, namespacesWithMigrations,
 			});
 			continue;
 		}
-		const expectedSnapshot = reconstructSnapshotFromMigrations(migrationsDir, remoteMigrationNumber);
+		const expectedSnapshot = reconstructSnapshotFromMigrations(migrationsDir, checkpointRepair?.to ?? remoteMigrationNumber);
 		if (!expectedSnapshot) {
 			results.push({
 				namespace,
@@ -10627,7 +10932,8 @@ async function verifyRemoteSchema(client, workspaceId, namespacesWithMigrations,
 			namespace,
 			remoteMigrationNumber,
 			drifts,
-			hasDrift: drifts.length > 0
+			hasDrift: drifts.length > 0,
+			...checkpointRepair && drifts.length === 0 ? { checkpointRepair } : {}
 		});
 	}
 	return results;
@@ -10800,6 +11106,34 @@ async function bundleMigrationScript(sourceFile, namespace, migrationNumber, env
 	};
 }
 
+//#endregion
+//#region src/cli/commands/tailordb/migrate/hints.ts
+/**
+* Copyable command hints for migration remediation
+*/
+/**
+* Build the copyable `tailor tailordb migration script` command for
+* remediation hints, reproducing the current run's invocation context.
+* @param {MigrationScriptCommandOptions} options - Target migration and invocation context
+* @returns {string} Command line quoted for the current platform's shell
+*/
+function formatMigrationScriptCommand(options) {
+	const { migrationNumber, namespace, configPath, noScript } = options;
+	const argv = [
+		"tailor",
+		"tailordb",
+		"migration",
+		"script",
+		formatMigrationNumber(migrationNumber),
+		"--namespace",
+		namespace
+	];
+	const configArg = formatConfigArg(configPath);
+	if (configArg !== void 0) argv.push(configArg);
+	if (noScript) argv.push("--no-script", "--reason", "<reason>");
+	return formatCopyableCommand(argv);
+}
+
 //#endregion
 //#region src/cli/shared/script-executor.ts
 /**
@@ -11007,7 +11341,7 @@ var Spinner = class {
 		const frame = styles.info(FRAMES[this.#frame] ?? assertDefined(FRAMES[0], "spinner frames empty"));
 		this.#frame = (this.#frame + 1) % FRAMES.length;
 		const line = `${" ".repeat(this.#indent)}${frame} ${this.text}`;
-		this.#stream.write(line);
+		this.#stream.write(renderFor(this.#stream, line));
 		this.#stream.write(SYNC_END);
 		const cols = this.#stream.columns || 80;
 		this.#linesDrawn = Math.max(1, Math.ceil(visibleLength(line) / cols));
@@ -11024,7 +11358,7 @@ var Spinner = class {
 	}
 	#writeLine(content) {
 		const indent = " ".repeat(this.#indent);
-		this.#stream.write(`${indent}${content}\n`);
+		this.#stream.write(renderFor(this.#stream, `${indent}${content}\n`));
 	}
 };
 /**
@@ -11069,12 +11403,13 @@ async function getCurrentMigrationNumber(client, workspaceId, namespace) {
 * @param {string} workspaceId - Workspace ID
 * @param {NamespaceWithMigrations[]} namespacesWithMigrations - Namespaces with migrations config
 * @param {string} [configPath] - Config file path, included in remediation guidance when provided
+* @param {ReadonlyMap<string, number>} [currentMigrationOverrides] - Confirmed current migration numbers to use instead of remote metadata
 * @returns {Promise<PendingMigration[]>} List of pending migrations
 */
-async function detectPendingMigrations(client, workspaceId, namespacesWithMigrations, configPath) {
+async function detectPendingMigrations(client, workspaceId, namespacesWithMigrations, configPath, currentMigrationOverrides) {
 	const pendingMigrations = [];
 	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
-		const currentMigration = await getCurrentMigrationNumber(client, workspaceId, namespace);
+		const currentMigration = currentMigrationOverrides?.get(namespace) ?? await getCurrentMigrationNumber(client, workspaceId, namespace);
 		const migrationFiles = getMigrationFiles(migrationsDir);
 		for (const file of migrationFiles) {
 			if (file.number <= currentMigration) continue;
@@ -11084,9 +11419,15 @@ async function detectPendingMigrations(client, workspaceId, namespacesWithMigrat
 			const scriptPath = getMigrationFilePath(migrationsDir, file.number, "migrate");
 			const hasScript = fs$2.existsSync(scriptPath);
 			if (diff.requiresMigrationScript && !hasScript && !diff.scriptSkipped) {
-				const configArg = configPath ? ` --config "${path.relative(process.cwd(), configPath) || configPath}"` : "";
-				const scriptCmd = `tailor tailordb migration script ${file.number} --namespace ${namespace}${configArg}`;
-				throw new Error(`Migration ${namespace}/${formatMigrationNumber(file.number)} requires a migration script but migrate.ts was not found.\nTo resolve, either:\n  - Add a script: ${scriptCmd}\n  - Or record that no script is needed: ${scriptCmd} --no-script --reason "<why no data migration is needed>"`);
+				const commandOptions = {
+					migrationNumber: file.number,
+					namespace,
+					configPath
+				};
+				throw new Error(`Migration ${namespace}/${formatMigrationNumber(file.number)} requires a migration script but migrate.ts was not found.\nTo resolve, either:\n  - Add a script: ${formatMigrationScriptCommand(commandOptions)}\n  - Or record that no script is needed: ${formatMigrationScriptCommand({
+					...commandOptions,
+					noScript: true
+				})}`);
 			}
 			if (diff.scriptSkipped) {
 				const migrationLabel = `${namespace}/${formatMigrationNumber(file.number)}`;
@@ -11138,12 +11479,17 @@ async function executeSingleMigration(options, migration) {
 * @param {string} workspaceId - Workspace ID
 * @param {string} namespace - TailorDB namespace
 * @param {number} migrationNumber - Migration number to set
+* @param historyId - Optional migration history ID to set atomically with the checkpoint
 * @returns {Promise<void>}
 */
-async function updateMigrationLabel(client, workspaceId, namespace, migrationNumber) {
+async function updateMigrationLabel(client, workspaceId, namespace, migrationNumber, historyId) {
 	await writeMetadataLabels(client, {
 		trn: resourceTrn(workspaceId, "tailordb", namespace),
-		labels: { [MIGRATION_LABEL_KEY]: sanitizeMigrationLabel(migrationNumber) }
+		labels: {
+			[MIGRATION_LABEL_KEY]: sanitizeMigrationLabel(migrationNumber),
+			...historyId ? { [MIGRATION_HISTORY_LABEL_KEY]: historyId } : {}
+		},
+		remove: historyId ? void 0 : [MIGRATION_HISTORY_LABEL_KEY]
 	});
 }
 /**
@@ -11218,33 +11564,6 @@ function groupMigrationsByNamespace(migrations) {
 
 //#endregion
 //#region src/cli/commands/deploy/tailordb/index.ts
-const MIGRATION_FILE_KINDS = [
-	"schema",
-	"diff",
-	"migrate",
-	"db"
-];
-/**
-* Capture the migration files that a deployment plan depends on.
-* @param namespacesWithMigrations - Configured migration directories by namespace
-* @returns SHA-256 digest by namespace
-*/
-function captureMigrationFileState(namespacesWithMigrations) {
-	const state = {};
-	for (const { namespace, migrationsDir } of namespacesWithMigrations.toSorted((a, b) => a.namespace.localeCompare(b.namespace))) {
-		const hash = createHash("sha256");
-		const migrationNumbers = [...new Set(getMigrationFiles(migrationsDir).map(({ number }) => number))].toSorted((a, b) => a - b);
-		for (const migrationNumber of migrationNumbers) for (const kind of MIGRATION_FILE_KINDS) {
-			const filePath = getMigrationFilePath(migrationsDir, migrationNumber, kind);
-			hash.update(`${formatMigrationNumber(migrationNumber)}/${kind}\0`);
-			if (fs$2.existsSync(filePath)) hash.update(fs$2.readFileSync(filePath));
-			else hash.update("<missing>");
-			hash.update("\0");
-		}
-		state[namespace] = hash.digest("hex");
-	}
-	return state;
-}
 function migrationFileStatesEqual(planned, current) {
 	const plannedNamespaces = Object.keys(planned).toSorted();
 	const currentNamespaces = Object.keys(current).toSorted();
@@ -11263,8 +11582,13 @@ function migrationFileStatesEqual(planned, current) {
 async function validateAndDetectMigrations(client, workspaceId, typesByNamespace, config, noSchemaCheck, tailorDBInputs) {
 	const namespacesWithMigrations = getNamespacesWithMigrations(config, path.dirname(config.path));
 	let pendingMigrations = [];
+	let checkpointRepairs = [];
+	const migrationHistoryIds = Object.create(null);
 	if (namespacesWithMigrations.length > 0) {
-		for (const { namespace, migrationsDir } of namespacesWithMigrations) assertValidMigrationFiles(migrationsDir, namespace);
+		for (const { namespace, migrationsDir } of namespacesWithMigrations) {
+			assertValidMigrationFiles(migrationsDir, namespace);
+			migrationHistoryIds[namespace] = reconstructSnapshotFromMigrations(migrationsDir)?.rebaseline?.historyId ?? null;
+		}
 		if (!noSchemaCheck) {
 			const migrationResults = await checkMigrationDiffs(typesByNamespace, namespacesWithMigrations);
 			if (migrationResults.some((r) => r.hasDiff)) {
@@ -11276,6 +11600,10 @@ async function validateAndDetectMigrations(client, workspaceId, typesByNamespace
 				throw new Error("Schema migration check failed");
 			}
 			const remoteVerificationResults = await verifyRemoteSchema(client, workspaceId, namespacesWithMigrations, config, tailorDBInputs);
+			checkpointRepairs = remoteVerificationResults.flatMap((result) => result.checkpointRepair ? [{
+				namespace: result.namespace,
+				...result.checkpointRepair
+			}] : []);
 			const missingCheckpointResults = remoteVerificationResults.filter((result) => result.checkpointMissingLocal);
 			if (missingCheckpointResults.length > 0) {
 				logger.error("Remote migration checkpoint is not in the local migration history:");
@@ -11293,8 +11621,10 @@ async function validateAndDetectMigrations(client, workspaceId, typesByNamespace
 				logger.info("Use '--no-schema-check' to skip this check (not recommended).");
 				throw new Error("Remote schema verification failed");
 			}
+			for (const repair of checkpointRepairs) logger.warn(`Remote migration checkpoint for ${repair.namespace} will be reset to 0000 after confirmation (${formatMigrationNumber(repair.from)} → 0000); the remote schema already matches the local baseline.`);
 		}
-		pendingMigrations = await detectPendingMigrations(client, workspaceId, namespacesWithMigrations, config.path);
+		const currentMigrationOverrides = new Map(checkpointRepairs.map((repair) => [repair.namespace, repair.to]));
+		pendingMigrations = await detectPendingMigrations(client, workspaceId, namespacesWithMigrations, config.path, currentMigrationOverrides);
 		if (pendingMigrations.length > 0) {
 			logger.newline();
 			const withScripts = pendingMigrations.filter((m) => m.hasScript);
@@ -11306,13 +11636,15 @@ async function validateAndDetectMigrations(client, workspaceId, typesByNamespace
 	}
 	return {
 		pendingMigrations,
+		checkpointRepairs,
 		namespacesWithMigrations,
-		migrationFileState: captureMigrationFileState(namespacesWithMigrations)
+		migrationFileState: captureMigrationFileState(namespacesWithMigrations),
+		migrationHistoryIds
 	};
 }
 /**
-* Force each namespace's `sdk-migration` label to the working tree's latest
-* migration number after a create-update apply.
+* Reconcile each namespace's migration checkpoint and history ID to
+* the working tree after a create-update apply.
 *
 * This records the initial baseline (`0000`), which is deployed via the normal
 * flow and never bumps the label itself, and keeps the label `<= working_tree_max`
@@ -11321,16 +11653,21 @@ async function validateAndDetectMigrations(client, workspaceId, typesByNamespace
 * @param client - Operator client instance
 * @param workspaceId - Workspace ID
 * @param namespacesWithMigrations - Namespaces that have migration directories configured
+* @param migrationHistoryIds - Migration history ID captured during preflight for each namespace
 */
-async function reconcileMigrationLabels(client, workspaceId, namespacesWithMigrations) {
+async function reconcileMigrationLabels(client, workspaceId, namespacesWithMigrations, migrationHistoryIds) {
 	for (const { namespace, migrationsDir } of namespacesWithMigrations) {
 		if (getMigrationFiles(migrationsDir).length === 0) continue;
 		const targetVersion = getLatestMigrationNumber(migrationsDir);
-		const currentVersion = await getRemoteMigrationNumber(client, workspaceId, namespace).catch(() => null);
-		if (currentVersion === targetVersion) continue;
-		await updateMigrationLabel(client, workspaceId, namespace, targetVersion);
-		const from = currentVersion === null ? "<unset>" : formatMigrationNumber(currentVersion);
-		logger.info(`Migration label for namespace ${namespace} reconciled: ${from} → ${formatMigrationNumber(targetVersion)}.`);
+		const historyId = migrationHistoryIds[namespace] ?? null;
+		const remoteState = await fetchRemoteMigrationState(client, resourceTrn(workspaceId, "tailordb", namespace)).catch(() => null);
+		const currentVersion = remoteState?.number ?? null;
+		if (remoteState && currentVersion === targetVersion && remoteState.historyId === historyId) continue;
+		await updateMigrationLabel(client, workspaceId, namespace, targetVersion, historyId ?? void 0);
+		if (remoteState) {
+			const from = currentVersion === null ? "<unset>" : formatMigrationNumber(currentVersion);
+			logger.info(`Migration label for namespace ${namespace} reconciled: ${from} → ${formatMigrationNumber(targetVersion)}.`);
+		} else logger.info(`Migration label for namespace ${namespace} reconciled to ${formatMigrationNumber(targetVersion)}.`);
 	}
 }
 /**
@@ -11357,9 +11694,22 @@ function buildMigrationContextForScripts(client, migrationContext, migrationsReq
 }
 async function validateTailorDBMigrationState(client, result) {
 	const { context } = result;
+	if (context.migrationTestBaselines) {
+		const currentMigrationFileState = captureMigrationFileState(getNamespacesWithMigrations(context.config, path.dirname(context.config.path)));
+		if (!migrationFileStatesEqual(context.migrationFileState, currentMigrationFileState)) throw new Error("Migration files changed after deployment planning. Run the migration test again to create a fresh plan.");
+		return {
+			pendingMigrations: [],
+			checkpointRepairs: [],
+			namespacesWithMigrations: [],
+			migrationFileState: currentMigrationFileState,
+			migrationHistoryIds: {}
+		};
+	}
 	const typesByNamespace = /* @__PURE__ */ new Map();
 	for (const tailordb of context.tailorDBInputs) typesByNamespace.set(tailordb.namespace, tailordb.types);
 	const validation = await validateAndDetectMigrations(client, context.workspaceId, typesByNamespace, context.config, context.noSchemaCheck, context.tailorDBInputs);
+	const approvedRepairs = context.checkpointRepairs;
+	if (approvedRepairs.length !== validation.checkpointRepairs.length || validation.checkpointRepairs.some((repair) => !approvedRepairs.some((approved) => approved.namespace === repair.namespace && approved.from === repair.from && approved.fromHistoryId === repair.fromHistoryId && approved.toHistoryId === repair.toHistoryId))) throw new Error("Remote migration checkpoint repair changed after deployment planning. Run the deployment again to review the updated repair.");
 	if (!migrationFileStatesEqual(context.migrationFileState, validation.migrationFileState)) throw new Error("Migration files changed after deployment planning. Run the deployment again to create a fresh plan.");
 	return validation;
 }
@@ -11380,7 +11730,11 @@ async function preflightTailorDB(client, result) {
 async function applyTailorDB(client, result, phase = "create-update") {
 	const { changeSet, context: migrationContext } = result;
 	if (phase === "create-update") {
-		const { pendingMigrations, namespacesWithMigrations } = await validateTailorDBMigrationState(client, result);
+		const { pendingMigrations, checkpointRepairs, namespacesWithMigrations, migrationHistoryIds } = await validateTailorDBMigrationState(client, result);
+		for (const repair of checkpointRepairs) {
+			await updateMigrationLabel(client, migrationContext.workspaceId, repair.namespace, repair.to, repair.toHistoryId);
+			logger.info(`Migration checkpoint for namespace ${repair.namespace} reset: ${formatMigrationNumber(repair.from)} → 0000.`);
+		}
 		if (pendingMigrations.length > 0) {
 			processedTypes.reset();
 			deletedResources.reset();
@@ -11412,15 +11766,37 @@ async function applyTailorDB(client, result, phase = "create-update") {
 					await executeSingleMigrationPrePhase(client, changeSet, migration, migrationContext.tailorDBInputs, migrationContext.executorUsedTypes);
 					if (migration.hasScript && migrationCtx) await executeMigrations(migrationCtx, [migration]);
 				} catch (error) {
+					await rollbackSingleMigrationAfterFailure(client, changeSet, migration, migrationContext.workspaceId, migrationContext.tailorDBInputs, migrationContext.executorUsedTypes);
+					throw error;
+				}
+				try {
+					await executeSingleMigrationPostPhase(client, changeSet, migration, migrationContext.tailorDBInputs, migrationContext.executorUsedTypes);
+				} catch (error) {
+					await rollbackSingleMigrationAfterFailure(client, changeSet, migration, migrationContext.workspaceId, migrationContext.tailorDBInputs, migrationContext.executorUsedTypes);
+					throw error;
+				}
+				try {
+					await updateMigrationLabel(client, migrationContext.workspaceId, migration.namespace, migration.number, migrationHistoryIds[migration.namespace] ?? void 0);
+				} catch (error) {
+					let remoteMigrationNumber;
 					try {
-						await rollbackSingleMigrationPrePhase(client, changeSet, migration, migrationContext.workspaceId, migrationContext.tailorDBInputs, migrationContext.executorUsedTypes);
-					} catch (rollbackError) {
-						logger.warn(`Failed to roll back migration ${migration.namespace}/${formatMigrationNumber(migration.number)}: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+						remoteMigrationNumber = (await fetchRemoteMigrationState(client, resourceTrn(migrationContext.workspaceId, "tailordb", migration.namespace))).number ?? void 0;
+					} catch (readbackError) {
+						logger.warn(`Could not verify migration checkpoint ${migration.namespace}/${formatMigrationNumber(migration.number)} after its update failed: ${readbackError instanceof Error ? readbackError.message : String(readbackError)}. Leaving the post-migration schema unchanged to avoid rolling back a committed checkpoint.`);
+						throw error;
 					}
+					if (remoteMigrationNumber !== void 0 && remoteMigrationNumber > migration.number) throw new Error(`Migration checkpoint ${migration.namespace}/${formatMigrationNumber(migration.number)} advanced concurrently to ${formatMigrationNumber(remoteMigrationNumber)}. Leaving the post-migration schema unchanged and aborting this deployment.`, { cause: error });
+					if (remoteMigrationNumber !== migration.number) {
+						logger.warn(`Migration checkpoint ${migration.namespace}/${formatMigrationNumber(migration.number)} could not be confirmed after its update failed; remote remains at ${remoteMigrationNumber === void 0 ? "<unset>" : formatMigrationNumber(remoteMigrationNumber)}. Leaving the post-migration schema unchanged to avoid rolling back a concurrent deployment. Repair the checkpoint before retrying.`);
+						throw error;
+					}
+				}
+				try {
+					await executeSingleMigrationPostPhaseDeletions(client, changeSet, migration);
+				} catch (error) {
+					logger.warn(`Migration checkpoint ${migration.namespace}/${formatMigrationNumber(migration.number)} was committed, but post-checkpoint cleanup failed. Remove the leftover resources manually before the next deployment; remote schema verification will fail closed until then.`);
 					throw error;
 				}
-				await executeSingleMigrationPostPhase(client, changeSet, migration, migrationContext.tailorDBInputs, migrationContext.executorUsedTypes);
-				await updateMigrationLabel(client, migrationContext.workspaceId, migration.namespace, migration.number);
 			}
 			if (migrationsRequiringScripts.length > 0) {
 				logger.newline();
@@ -11459,7 +11835,7 @@ async function applyTailorDB(client, result, phase = "create-update") {
 			await Promise.all(changeSet.gqlPermission.deletes.map((del) => client.deleteTailorDBGQLPermission(del.request)));
 			await Promise.all(changeSet.type.deletes.map((del) => client.deleteTailorDBType(del.request)));
 		}
-		if (namespacesWithMigrations.length > 0 && (migrationContext.noSchemaCheck || pendingMigrations.length === 0)) await reconcileMigrationLabels(client, migrationContext.workspaceId, namespacesWithMigrations);
+		if (namespacesWithMigrations.length > 0 && (migrationContext.noSchemaCheck || pendingMigrations.length === 0)) await reconcileMigrationLabels(client, migrationContext.workspaceId, namespacesWithMigrations, migrationHistoryIds);
 	} else if (phase === "delete-resources") {
 		await Promise.all(changeSet.gqlPermission.deletes.map((del) => client.deleteTailorDBGQLPermission(del.request)));
 		await Promise.all(changeSet.type.deletes.map((del) => client.deleteTailorDBType(del.request)));
@@ -11535,11 +11911,12 @@ const migrationSnapshotCache = {
 		return snapshot;
 	}
 };
-function buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes) {
+function buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges) {
 	const snapshotType = migrationSnapshotCache.load(migration).types[typeName];
 	if (!snapshotType) return void 0;
 	const input = tailorDBInputs.find((i) => i.namespace === migration.namespace);
-	return generateTailorDBTypeManifestFromSnapshot(snapshotType, {
+	const typeScriptsChange = migration.diff.changes.find((change) => change.kind === "type_scripts_modified" && change.typeName === typeName);
+	return generateTailorDBTypeManifestFromSnapshot(typeChanges ? createPreMigrationSnapshotType(snapshotType, typeChanges, typeScriptsChange) : snapshotType, {
 		subscribed: executorUsedTypes.has(snapshotType.name),
 		namespaceGqlOperations: input?.config.gqlOperations
 	});
@@ -11572,11 +11949,11 @@ async function executeSingleMigrationPrePhase(client, changeSet, migration, tail
 	for (const create of changeSet.type.creates) {
 		const typeName = create.request.tailordbType?.name;
 		if (!typeName || !affectedTypes.has(typeName) || createdBeforeMigration.has(typeName)) continue;
-		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes);
+		const typeChanges = preMigrationChanges.get(typeName);
+		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges);
 		if (!snapshotType) continue;
 		const clonedRequest = structuredClone(create.request);
 		clonedRequest.tailordbType = snapshotType;
-		const typeChanges = preMigrationChanges.get(typeName);
 		if (typeChanges && typeChanges.size > 0 && clonedRequest.tailordbType.schema?.fields) applyPreMigrationFieldAdjustments(clonedRequest.tailordbType.schema.fields, typeChanges);
 		const indexChanges = preMigrationIndexChanges.get(typeName);
 		if (indexChanges && indexChanges.size > 0 && clonedRequest.tailordbType.schema?.indexes) applyPreMigrationIndexAdjustments(clonedRequest.tailordbType.schema.indexes, indexChanges);
@@ -11586,10 +11963,10 @@ async function executeSingleMigrationPrePhase(client, changeSet, migration, tail
 	for (const create of changeSet.type.creates) {
 		const typeName = create.request.tailordbType?.name;
 		if (!typeName || !affectedTypes.has(typeName) || !createdBeforeMigration.has(typeName)) continue;
-		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes);
+		const typeChanges = preMigrationChanges.get(typeName);
+		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges);
 		if (!snapshotType) continue;
 		const clonedTypeRequest = structuredClone(snapshotType);
-		const typeChanges = preMigrationChanges.get(typeName);
 		if (typeChanges && typeChanges.size > 0 && clonedTypeRequest.schema?.fields) applyPreMigrationFieldAdjustments(clonedTypeRequest.schema.fields, typeChanges);
 		const indexChanges = preMigrationIndexChanges.get(typeName);
 		if (indexChanges && indexChanges.size > 0 && clonedTypeRequest.schema?.indexes) applyPreMigrationIndexAdjustments(clonedTypeRequest.schema.indexes, indexChanges);
@@ -11603,11 +11980,11 @@ 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 snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes);
+		const typeChanges = preMigrationChanges.get(typeName);
+		const snapshotType = buildSnapshotTypeManifest(migration, typeName, tailorDBInputs, executorUsedTypes, typeChanges);
 		if (!snapshotType) continue;
 		const clonedRequest = structuredClone(update.request);
 		clonedRequest.tailordbType = snapshotType;
-		const typeChanges = preMigrationChanges.get(typeName);
 		if (typeChanges && typeChanges.size > 0 && clonedRequest.tailordbType.schema?.fields) applyPreMigrationFieldAdjustments(clonedRequest.tailordbType.schema.fields, typeChanges);
 		const indexChanges = preMigrationIndexChanges.get(typeName);
 		if (indexChanges && indexChanges.size > 0 && clonedRequest.tailordbType.schema?.indexes) applyPreMigrationIndexAdjustments(clonedRequest.tailordbType.schema.indexes, indexChanges);
@@ -11642,8 +12019,15 @@ const deletedResources = {
 		this.gqlPermissions.clear();
 	}
 };
+async function rollbackSingleMigrationAfterFailure(client, changeSet, migration, workspaceId, tailorDBInputs, executorUsedTypes) {
+	try {
+		await rollbackSingleMigrationPrePhase(client, changeSet, migration, workspaceId, tailorDBInputs, executorUsedTypes);
+	} catch (rollbackError) {
+		logger.warn(`Failed to roll back migration ${migration.namespace}/${formatMigrationNumber(migration.number)}: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+	}
+}
 /**
-* Execute post-migration phase for a single migration: Apply final types (with required: true) and deletions
+* Execute post-migration phase for a single migration: Apply final types (with required: true)
 * @param {OperatorClient} client - Operator client instance
 * @param {TailorDBChangeSet} changeSet - TailorDB change set
 * @param {PendingMigration} migration - Single pending migration
@@ -11656,7 +12040,6 @@ async function executeSingleMigrationPostPhase(client, changeSet, migration, tai
 	const preMigrationIndexChanges = buildPreMigrationIndexChangesMap([migration]);
 	const adjustedTypes = /* @__PURE__ */ new Set([...preMigrationChanges.keys(), ...preMigrationIndexChanges.keys()]);
 	const affectedTypes = getAffectedTypeNames(migration);
-	const deletedTypeNames = getDeletedTypeNames(migration);
 	try {
 		for (const create of changeSet.type.creates) {
 			const typeName = create.request.tailordbType?.name;
@@ -11683,28 +12066,29 @@ async function executeSingleMigrationPostPhase(client, changeSet, migration, tai
 	} catch (error) {
 		handleOptionalToRequiredError(error, ["This error occurred during post-migration phase. Please check your migration script.", "Ensure all existing records have values for fields being changed to required."]);
 	}
+}
+async function executeSingleMigrationPostPhaseDeletions(client, changeSet, migration) {
+	const deletedTypeNames = getDeletedTypeNames(migration);
 	if (deletedTypeNames.size > 0) {
 		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;
-			if (typeName && deletedTypeNames.has(typeName)) {
-				deletedResources.gqlPermissions.add(permKey);
-				return true;
-			}
-			return false;
+			return deletedTypeNames.has(typeName);
 		});
-		await Promise.all(gqlPermissionsToDelete.map((del) => client.deleteTailorDBGQLPermission(del.request)));
+		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;
-			if (deletedTypeNames.has(typeName)) {
-				deletedResources.types.add(typeName);
-				return true;
-			}
-			return false;
+			return deletedTypeNames.has(typeName);
 		});
-		await Promise.all(typesToDelete.map((del) => client.deleteTailorDBType(del.request)));
+		for (const del of typesToDelete) {
+			await client.deleteTailorDBType(del.request);
+			deletedResources.types.add(del.name);
+		}
 	}
 }
 /**
@@ -11776,18 +12160,40 @@ async function rollbackSingleMigrationPrePhase(client, changeSet, migration, wor
 async function planTailorDB(context) {
 	const { client, workspaceId, application, forRemoval, config, noSchemaCheck, forceApplyAll = false } = context;
 	const tailordbs = [];
+	const migrationTestSnapshots = context.migrationTestSnapshots ?? (context.migrationTestBaselines ? new Map([...context.migrationTestBaselines].map(([namespace, baseline]) => [namespace, baseline.snapshot])) : void 0);
 	if (!forRemoval) for (const tailordb of application.tailorDBServices) {
 		await tailordb.loadTypes();
-		tailordbs.push(toTailorDBDeployInput(tailordb));
+		const input = toTailorDBDeployInput(tailordb);
+		const snapshot = migrationTestSnapshots?.get(tailordb.namespace);
+		tailordbs.push(snapshot ? {
+			...input,
+			types: snapshot.types
+		} : input);
 	}
 	const executors = forRemoval ? [] : Object.values(await application.executorService?.loadExecutors() ?? {});
 	const executorUsedTypes = new Set(context.executorUsedTailorDBTypes ?? []);
 	for (const executor of executors) if (executor.trigger.kind === "tailordb") executorUsedTypes.add(executor.trigger.typeName);
 	const typesByNamespace = /* @__PURE__ */ new Map();
 	for (const tailordb of tailordbs) typesByNamespace.set(tailordb.namespace, tailordb.types);
-	const { namespacesWithMigrations, migrationFileState } = forRemoval ? {
+	const migrationTestBaselines = context.migrationTestBaselines;
+	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);
+		}
+	}
+	const migrationConfig = getNamespacesWithMigrations(config, path.dirname(config.path));
+	const { namespacesWithMigrations, migrationFileState, checkpointRepairs } = forRemoval ? {
 		namespacesWithMigrations: [],
-		migrationFileState: {}
+		migrationFileState: {},
+		checkpointRepairs: []
+	} : migrationTestBaselines ? {
+		namespacesWithMigrations: migrationConfig,
+		migrationFileState: captureMigrationFileState(migrationConfig),
+		checkpointRepairs: []
 	} : await validateAndDetectMigrations(client, workspaceId, typesByNamespace, config, noSchemaCheck ?? false, tailordbs);
 	const { changeSet: serviceChangeSet, conflicts, unmanaged, resourceOwners } = await planServices(client, workspaceId, application.name, application.id, tailordbs);
 	const deletedServices = serviceChangeSet.deletes.map((del) => del.name);
@@ -11816,8 +12222,10 @@ async function planTailorDB(context) {
 			executorUsedTypes,
 			config,
 			noSchemaCheck: noSchemaCheck ?? false,
+			...migrationTestBaselines ? { migrationTestBaselines } : {},
 			namespacesWithMigrations,
-			migrationFileState
+			migrationFileState,
+			checkpointRepairs
 		}
 	};
 }
@@ -13139,6 +13547,22 @@ function insertIdProperty(source, configObj, id) {
 
 //#endregion
 //#region src/cli/commands/deploy/confirm.ts
+async function confirmMigrationCheckpointRepairs(repairs, yes) {
+	if (repairs.length === 0) return;
+	logger.warn("TailorDB migration checkpoints and history IDs need to be updated before this deployment:");
+	for (const repair of repairs.toSorted((a, b) => a.namespace.localeCompare(b.namespace))) {
+		logger.log(`  ${repair.namespace}:`);
+		logger.log(`    Checkpoint: ${formatMigrationNumber(repair.from)} → ${formatMigrationNumber(repair.to)}`);
+		logger.log(`    Migration history ID: ${repair.fromHistoryId ?? "<unset>"} → ${repair.toHistoryId}`);
+	}
+	logger.log("  The checkpoint reset itself changes only metadata.");
+	logger.log("  This deployment may still apply pending schema or data migrations afterward.");
+	if (yes) return;
+	if (!await prompt.confirm({
+		message: "Reset these migration checkpoints, align their history IDs, and continue with the deployment?",
+		default: false
+	})) throw new Error("Apply cancelled: migration checkpoint reset was not confirmed.");
+}
 /**
 * Confirm reassignment of resources when owner conflicts are detected.
 * Splits into three scenarios, each with its own prompt because the
@@ -14798,7 +15222,15 @@ function buildPlanReport(results) {
 	const workflowEntries = formatWorkflowChangeEntries(results.workflow.changeSet, results.functionRegistry.workflowJobChanges);
 	const workflowExecutionPolicyEntries = formatChangeSetEntries(results.workflowExecutionPolicy.changeSet, ["executionPolicy"]);
 	const authHookEntries = formatAuthHookChangeEntries(results.auth.changeSet.authHook, results.functionRegistry.authHookFunctionChanges);
-	const tailorDBEntries = [...formatTailorDBResourceChangeEntries(results.tailorDB.changeSet.type, results.tailorDB.changeSet.gqlPermission)];
+	const tailorDBResourceEntries = formatTailorDBResourceChangeEntries(results.tailorDB.changeSet.type, results.tailorDB.changeSet.gqlPermission);
+	const checkpointRepairEntries = results.tailorDB.context.checkpointRepairs.map((repair) => ({
+		action: "update",
+		symbol: ACTION_SYMBOLS.update,
+		name: `migration checkpoint ${formatMigrationNumber(repair.from)} → ${formatMigrationNumber(repair.to)}`,
+		labels: ["migrationCheckpoint"],
+		namespace: repair.namespace
+	}));
+	const tailorDBEntries = [...tailorDBResourceEntries, ...checkpointRepairEntries];
 	const pipelineEntries = [...resolverEntries];
 	const namespaceOf = (item) => {
 		if ("request" in item && item.request && typeof item.request === "object" && "namespaceName" in item.request) return item.request.namespaceName;
@@ -15388,13 +15820,21 @@ function collectDeployRunPlanInputs(targets, writes) {
 	};
 }
 async function planDeploymentTarget(params) {
-	const { target, targets, runInputs, client, workspaceId, noSchemaCheck } = params;
+	const { target, targets, runInputs, client, workspaceId, noSchemaCheck, migrationTestBaselines, migrationTestSnapshots } = params;
 	const { config, application, workflowBuildResult, httpAdapterBuildResult, bundledScripts } = target;
 	const owned = ownedSubscriptions(runInputs.eventSubscriptions, target);
+	const migrationTestServices = application.tailorDBServices.map((service) => {
+		const snapshot = migrationTestSnapshots?.get(service.namespace);
+		return snapshot ? {
+			...service,
+			types: snapshot.types,
+			typeSourceInfo: {}
+		} : service;
+	});
 	await withSpan("plan.validateTailorDBTypeNames", () => assertUniqueTailorDBTypeNamesWithExternal({
 		client,
 		workspaceId,
-		tailorDBServices: application.tailorDBServices,
+		tailorDBServices: migrationTestServices,
 		externalTailorDBNamespaces: application.externalTailorDBNamespaces,
 		plannedExternalTailorDBServices: collectPlannedExternalTailorDBServices(target, targets)
 	}));
@@ -15413,6 +15853,8 @@ async function planDeploymentTarget(params) {
 			forRemoval: false,
 			config,
 			noSchemaCheck,
+			migrationTestBaselines,
+			migrationTestSnapshots,
 			forceApplyAll,
 			...runInputs,
 			idpUserTriggerTargets: subscribedIdps(owned),
@@ -15819,7 +16261,8 @@ function collectDeploymentResourceOwners(deployments) {
 	return owners;
 }
 async function confirmDeploymentPlans(params) {
-	const { deployments, yes, missingDependentApps = [] } = params;
+	const { deployments, yes, dryRun = false, missingDependentApps = [] } = params;
+	if (!dryRun) await confirmMigrationCheckpointRepairs(deployments.flatMap((deployment) => deployment.tailorDB.context.checkpointRepairs), yes);
 	await confirmMissingDependentApps(missingDependentApps, yes);
 	const targetAppNames = new Set(deployments.map((deployment) => deployment.application.name));
 	const resourceOwners = collectDeploymentResourceOwners(deployments);
@@ -15881,12 +16324,44 @@ async function validateDeploymentPlans(deployments) {
 	for (const deployment of deployments) await validatePlan(deploymentPlanResults(deployment));
 }
 /**
+* Strip the services a migration test deploy must not manage, so plan modules
+* see an application that already reflects the deploy's scope. Baseline deploys
+* omit executors and Auth user profiles (data loading must not trigger current
+* event handlers or reference the final schema); every migration test deploy
+* omits workspace-bound static website custom domains.
+* @param application - Application built from the user's config
+* @param internalContext - Internal deployment behavior used by composed CLI workflows
+* @returns The application as the migration test deploy manages it
+*/
+function adjustApplicationForMigrationTest(application, internalContext) {
+	if (!internalContext?.migrationTestSnapshots) return application;
+	const forBaseline = internalContext.migrationTestBaselines !== void 0;
+	const authService = forBaseline && application.authService ? {
+		...application.authService,
+		userProfile: void 0
+	} : application.authService;
+	const adjusted = {
+		...application,
+		executorService: forBaseline ? void 0 : application.executorService,
+		authService,
+		staticWebsiteServices: application.staticWebsiteServices.map((website) => ({
+			...website,
+			customDomains: void 0
+		})),
+		get applications() {
+			return [adjusted];
+		}
+	};
+	return adjusted;
+}
+/**
 * Deploy the configured application to the Tailor platform.
 * @param options - Deploy execution options
 * @param cliContext - Global CLI arguments to preserve in recovery actions
+* @param internalContext - Internal deployment behavior used by composed CLI workflows
 * @returns Promise that resolves to `{ bundledScripts }` when `buildOnly` is true, otherwise void
 */
-async function deployInternal(options, cliContext) {
+async function deployInternal(options, cliContext, internalContext) {
 	return withSpan("deploy", async (rootSpan) => {
 		rootSpan.setAttribute("deploy.dry_run", options?.dryRun ?? false);
 		const configPaths = parseDeployConfigPaths(options?.configPath);
@@ -15943,17 +16418,23 @@ async function deployInternal(options, cliContext) {
 		const { client, workspaceId } = workspace;
 		rootSpan.setAttribute("app.name", targets.map((target) => target.application.name).join(","));
 		rootSpan.setAttribute("workspace.id", workspaceId);
-		const runInputs = collectDeployRunPlanInputs(targets, !options?.dryRun);
+		const planTargets = targets.map((target) => ({
+			...target,
+			application: adjustApplicationForMigrationTest(target.application, internalContext)
+		}));
+		const runInputs = collectDeployRunPlanInputs(planTargets, !options?.dryRun);
 		const deployments = await planDeploymentTargets({
-			targets,
+			targets: planTargets,
 			runInputs,
 			client,
 			workspaceId,
-			noSchemaCheck: options?.noSchemaCheck
+			noSchemaCheck: options?.noSchemaCheck,
+			migrationTestBaselines: internalContext?.migrationTestBaselines,
+			migrationTestSnapshots: internalContext?.migrationTestSnapshots
 		});
 		const yes = options?.yes ?? false;
 		dropCrossDeploymentManagedDeletes(deployments);
-		const missingDependentApps = (await Promise.all(targets.map((target) => fetchMissingDependentApps({
+		const missingDependentApps = (await Promise.all(planTargets.map((target) => fetchMissingDependentApps({
 			client,
 			workspaceId,
 			application: target.application,
@@ -15965,6 +16446,7 @@ async function deployInternal(options, cliContext) {
 			await confirmDeploymentPlans({
 				deployments,
 				yes,
+				dryRun,
 				missingDependentApps
 			});
 		});
@@ -15976,7 +16458,7 @@ async function deployInternal(options, cliContext) {
 			return;
 		}
 		await applyDeploymentPlans(client, workspaceId, deployments);
-		if (logger.jsonMode) logger.out({
+		if (!internalContext?.suppressResultOutput) if (logger.jsonMode) logger.out({
 			summary: planSummary,
 			status: "applied"
 		});
@@ -15992,6 +16474,32 @@ function deploy(options) {
 	return deployInternal(options);
 }
 /**
+* Deploy TailorDB baseline snapshots for an isolated migration test.
+* @param options - Deploy execution options
+* @param baselines - Baseline snapshots keyed by TailorDB namespace
+* @param baselineSnapshots - All schema snapshots that must match the source before data loading
+* @returns Deploy result
+*/
+function deployMigrationTestBaseline(options, baselines, baselineSnapshots) {
+	return deployInternal(options, void 0, {
+		migrationTestBaselines: baselines,
+		migrationTestSnapshots: baselineSnapshots,
+		suppressResultOutput: true
+	});
+}
+/**
+* Deploy pending migrations without emitting deploy's standalone result payload.
+* @param options - Deploy execution options
+* @param snapshots - Final committed snapshots keyed by TailorDB namespace
+* @returns Deploy result
+*/
+function deployMigrationTestTarget(options, snapshots) {
+	return deployInternal(options, void 0, {
+		migrationTestSnapshots: snapshots,
+		suppressResultOutput: true
+	});
+}
+/**
 * Deploy from the command adapter while preserving global CLI arguments in recovery actions.
 * @param options - Deploy execution options
 * @param cliContext - Global CLI arguments already applied by the command runner
@@ -19926,7 +20434,7 @@ function extractBreakingChangeFields(diff) {
 	const optionalToRequired = /* @__PURE__ */ new Map();
 	const addedRequiredFields = /* @__PURE__ */ new Map();
 	const enumValueChanges = /* @__PURE__ */ new Map();
-	for (const change of diff.changes) if (change.kind === "field_modified") {
+	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());
@@ -19997,7 +20505,7 @@ function generateDbTypesFromSnapshot(snapshot, diff) {
 		"",
 		...utilityTypeDeclarations,
 		"",
-		"interface Database {",
+		"export interface Database {",
 		...typeDefinitions,
 		"}",
 		"",
@@ -20027,7 +20535,7 @@ function generateEmptyDbTypes(namespace) {
 		"import type { Env } from \"@tailor-platform/sdk\";",
 		"",
 		"// eslint-disable-next-line @typescript-eslint/no-empty-object-type",
-		"interface Database {}",
+		"export interface Database {}",
 		"",
 		"export type Transaction = KyselyTransaction<Database>;",
 		"",
@@ -20194,6 +20702,8 @@ async function writeDbTypesFile(snapshot, migrationsDir, migrationNumber, diff)
 * - XXXX/migrate.ts - Data migration script (when breaking changes exist)
 * - XXXX/db.ts - Generated types for migration script
 */
+/** Marker left in generated migration scripts until their normalization logic is reviewed. */
+const MIGRATION_REVIEW_REQUIRED_MARKER = "TODO(tailor-migration-review)";
 /**
 * Check if a file exists
 * @param {string} filePath - Path to check
@@ -20310,6 +20820,46 @@ ${updates.join("\n\n")}
 `;
 }
 /**
+* Generate migration test file content
+* @param {MigrationDiff} diff - Migration diff
+* @returns {string} Migration test file content
+*/
+function generateMigrationTestScript(diff) {
+	return `/**
+ * Unit test for the ${diff.namespace} migration script.
+ *
+ * The mock compiles queries to the same SQL as the deployed migration, so the
+ * test verifies the exact statements migrate.ts issues. Stage the rows each
+ * query returns, run main() inside a transaction, then assert the executed
+ * statements.
+ */
+
+import { createKyselyMock } from "@tailor-platform/sdk/vitest";
+import { describe, expect, test } from "vitest";
+import type { Database } from "./db";
+import { main } from "./migrate";
+
+describe(${JSON.stringify(`${diff.namespace} migration`)}, () => {
+  test("issues the intended statements", async () => {
+    const mock = createKyselyMock<Database>();
+
+    // Stage the rows each query returns, in execution order:
+    // mock.enqueueResult([{ id: "record-1" }]);
+
+    // Pass a MigrationContext when your main uses env: main(trx, { env: { ... } })
+    await mock.withTx((trx) => main(trx));
+
+    // Replace with assertions on the statements the script must issue:
+    // expect(mock.updates).toHaveLength(1);
+    // expect(mock.updates[0]?.updateValues()).toEqual({ field: "value" });
+    expect(
+      mock.executedQueries.map((query) => ({ sql: query.sql, parameters: query.parameters })),
+    ).toMatchSnapshot();
+  });
+});
+`;
+}
+/**
 * 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
@@ -20357,9 +20907,10 @@ function generateChangeScripts(change, deferUniqueConstraint = false) {
     .execute();`];
 		return [];
 	}
-	if (change.kind !== "field_modified") return [];
+	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
   await trx
     .updateTable("${change.typeName}")
@@ -20406,10 +20957,56 @@ function generateChangeScripts(change, deferUniqueConstraint = false) {
   }`);
 	return scripts;
 }
+function generateFieldTypeChangeScript(change) {
+	return `  // Normalize ${change.typeName}.${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}")
+        .select(["id", "${change.fieldName}"])
+        .where("${change.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 normalization.
+        // Keep the value accepted by the active ${change.before.type} type and castable to ${change.after.type}.
+        const sourceValue = row.${change.fieldName};
+        if (sourceValue === null) continue;
+        const normalizedValue: never = sourceValue;
+        if (Object.is(normalizedValue, sourceValue)) continue;
+        await trx
+          .updateTable("${change.typeName}")
+          .set({ [${JSON.stringify(change.fieldName)}]: normalizedValue })
+          .where("id", "=", row.id)
+          .execute();
+      }
+      lastId = rows[rows.length - 1]!.id;
+    }
+  }`;
+}
 function generateUniqueConstraintScript(change) {
-	if (change.kind !== "field_modified") return null;
+	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
   {
     const duplicates = await trx
@@ -20419,19 +21016,13 @@ function generateUniqueConstraintScript(change) {
       .having((eb) => eb.fn.count("id"), ">", 1)
       .execute();
     for (const dup of duplicates) {
-      // Keep first record, add suffix to others
+      // 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})
         .execute();
-      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();
-      }
+${duplicateResolution}
     }
   }`;
 }
@@ -20476,6 +21067,202 @@ function generateDecimalScaleChangeScript(change) {
   }`;
 }
 
+//#endregion
+//#region src/cli/commands/tailordb/migrate/script.ts
+/**
+* Script command for TailorDB migrations
+*
+* Adds a `migrate.ts` (and supporting `db.ts`) template to an existing
+* migration directory, optionally with a `migrate.test.ts` unit-test
+* scaffold. Useful for warning-tier changes where users may want to
+* write a custom data migration even though the change does not
+* automatically require one.
+*/
+/**
+* Record in diff.json that a migration requiring a script, or one with
+* data-loss warnings, intentionally has none.
+* @param {MarkScriptSkippedOptions} options - Target migration and skip reason
+* @returns {ScriptSkippedInfo} The recorded acknowledgment
+*/
+function markMigrationScriptSkipped(options) {
+	const { migrationsDir, migrationNumber, reason } = options;
+	const label = formatMigrationNumber(migrationNumber);
+	const normalizedReason = reason.trim();
+	if (!normalizedReason) throw new Error("Migration script skip reason must not be empty.");
+	const diffPath = getMigrationFilePath(migrationsDir, migrationNumber, "diff");
+	if (!fs$2.existsSync(diffPath)) throw new Error(`Migration ${label} not found in ${migrationsDir}. Expected ${diffPath}.`);
+	const diff = loadDiff(diffPath);
+	if (!diff.requiresMigrationScript && !diff.hasWarnings) throw new Error(`Migration ${label} does not require a migration script and has no data-loss warnings; nothing to skip.`);
+	if (diff.scriptSkipped) throw new Error(`Migration ${label} already has a script skip recorded (${diff.scriptSkipped.acknowledgedAt}: ${diff.scriptSkipped.reason}).`);
+	const migratePath = getMigrationFilePath(migrationsDir, migrationNumber, "migrate");
+	if (fs$2.existsSync(migratePath)) throw new Error(`Migration script exists at ${migratePath}. Delete migrate.ts first if this migration should run without a script.`);
+	const scriptSkipped = {
+		reason: normalizedReason,
+		acknowledgedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	const raw = JSON.parse(fs$2.readFileSync(diffPath, "utf-8"));
+	raw.scriptSkipped = scriptSkipped;
+	fs$2.writeFileSync(diffPath, JSON.stringify(raw, null, 2));
+	return scriptSkipped;
+}
+/**
+* Remove a script skip acknowledgment after a real migration script is created.
+* @param diffPath - Migration diff file to update
+*/
+function clearMigrationScriptSkipped(diffPath) {
+	const raw = JSON.parse(fs$2.readFileSync(diffPath, "utf-8"));
+	if (!Object.hasOwn(raw, "scriptSkipped")) return;
+	delete raw.scriptSkipped;
+	fs$2.writeFileSync(diffPath, JSON.stringify(raw, null, 2));
+}
+/**
+* Create migration script files (migrate.ts, db.ts, and optionally migrate.test.ts)
+* in an existing migration directory. When migrate.ts already exists and withTest
+* is set, only the test file is added. An existing migrate.ts clears a stale
+* --no-script acknowledgment instead of failing.
+* @param {AddMigrationScriptFilesOptions} options - Target migration and file selection
+* @returns {Promise<AddMigrationScriptFilesResult>} Paths of the created files
+*/
+async function addMigrationScriptFiles(options) {
+	const { migrationsDir, migrationNumber, withTest = false } = options;
+	const label = formatMigrationNumber(migrationNumber);
+	const diffPath = getMigrationFilePath(migrationsDir, migrationNumber, "diff");
+	if (!fs$2.existsSync(diffPath)) throw new Error(`Migration ${label} not found in ${migrationsDir}. Expected ${diffPath}.`);
+	const diff = loadDiff(diffPath);
+	const migratePath = getMigrationFilePath(migrationsDir, migrationNumber, "migrate");
+	const migrateExists = fs$2.existsSync(migratePath);
+	const result = {};
+	if (migrateExists && diff.scriptSkipped) {
+		clearMigrationScriptSkipped(diffPath);
+		result.clearedScriptSkip = true;
+		if (!withTest) return result;
+	} else if (migrateExists && !withTest) throw new Error(`Migration script already exists at ${migratePath}.`);
+	const testPath = getMigrationFilePath(migrationsDir, migrationNumber, "test");
+	if (withTest && fs$2.existsSync(testPath)) throw new Error(`Migration test already exists at ${testPath}.`);
+	if (migrateExists && withTest) {
+		const dbTypesPath = getMigrationFilePath(migrationsDir, migrationNumber, "db");
+		if (!fs$2.existsSync(dbTypesPath)) throw new Error(`Generated types not found at ${dbTypesPath}. The test scaffold imports Database from ./db; restore db.ts before adding a test.`);
+	}
+	if (!migrateExists) {
+		const previousSnapshot = reconstructSnapshotFromMigrations(migrationsDir, migrationNumber - 1);
+		if (!previousSnapshot) throw new Error(`Could not reconstruct previous schema for migration ${label}. Make sure migration ${0} exists.`);
+		await fs.writeFile(migratePath, generateMigrationScript(diff));
+		result.migratePath = migratePath;
+		result.dbTypesPath = await writeDbTypesFile(previousSnapshot, migrationsDir, migrationNumber, diff);
+		clearMigrationScriptSkipped(diffPath);
+	}
+	if (withTest) {
+		await fs.writeFile(testPath, generateMigrationTestScript(diff));
+		result.testPath = testPath;
+	}
+	return result;
+}
+/**
+* Add a migrate.ts template to an existing migration directory.
+* @param {ScriptOptions} options - Command options
+*/
+async function script(options) {
+	logBetaWarning("tailordb migration");
+	const migrationNumber = parseMigrationNumberArg(options.number);
+	if (migrationNumber === 0) throw new Error(`Migration ${options.number} is the initial schema snapshot and cannot have a migration script.`);
+	const { config } = await loadConfig(options.configPath);
+	const namespacesWithMigrations = getNamespacesWithMigrations(config, path.dirname(config.path));
+	if (namespacesWithMigrations.length === 0) throw new Error("No TailorDB services with migrations configuration found");
+	const targetNamespace = resolveTargetNamespace(namespacesWithMigrations, options.namespace);
+	const { migrationsDir } = assertDefined(namespacesWithMigrations.find((ns) => ns.namespace === targetNamespace), "namespace with migrations not found");
+	if (options.noScript) {
+		if (options.withTest) throw new Error("--with-test cannot be used together with --no-script.");
+		const reason = options.reason?.trim();
+		if (!reason) throw new Error("--reason is required with --no-script.");
+		const scriptSkipped = markMigrationScriptSkipped({
+			migrationsDir,
+			migrationNumber,
+			reason
+		});
+		logger.success(`Recorded that migration ${styles.bold(options.number)} in namespace ${styles.bold(targetNamespace)} intentionally has no migration script`);
+		logger.info(`  Reason: ${scriptSkipped.reason}`);
+		logger.info(`  Diff file: ${getMigrationFilePath(migrationsDir, migrationNumber, "diff")}`);
+		return;
+	}
+	if (options.reason !== void 0) throw new Error("--reason can only be used together with --no-script.");
+	const result = await addMigrationScriptFiles({
+		migrationsDir,
+		migrationNumber,
+		withTest: options.withTest
+	});
+	if (result.clearedScriptSkip) {
+		logger.success(`Cleared the stale script skip record for migration ${styles.bold(options.number)} in namespace ${styles.bold(targetNamespace)}`);
+		if (!result.testPath) {
+			logger.info(`  Migration script: ${getMigrationFilePath(migrationsDir, migrationNumber, "migrate")}`);
+			return;
+		}
+	}
+	const added = [result.migratePath && "migration script", result.testPath && "migration test"].filter(Boolean).join(" and ");
+	logger.success(`Added ${added} for migration ${styles.bold(options.number)} in namespace ${styles.bold(targetNamespace)}`);
+	if (result.migratePath) {
+		logger.info(`  Migration script: ${result.migratePath}`);
+		logger.info(`  DB types: ${result.dbTypesPath}`);
+	}
+	if (result.testPath) logger.info(`  Migration test: ${result.testPath}`);
+	logger.newline();
+	if (result.migratePath) {
+		logger.log("Edit the script to implement your data migration logic.");
+		logger.log("It will be executed by 'tailor deploy' between Pre and Post phases.");
+	}
+	if (result.testPath) logger.log("Fill in the test with the rows to stage and the statements to assert.");
+	const fileToOpen = result.migratePath ?? result.testPath;
+	if (!fileToOpen) return;
+	const editor = getConfiguredEditorCommand();
+	if (!editor) return;
+	logger.newline();
+	logger.info(`Opening ${path.basename(fileToOpen)} in ${editor}...`);
+	try {
+		await openInConfiguredEditor(fileToOpen);
+	} catch {
+		return;
+	}
+}
+function resolveTargetNamespace(namespacesWithMigrations, requested) {
+	if (requested) {
+		if (!namespacesWithMigrations.some((ns) => ns.namespace === requested)) throw new Error(`Namespace "${requested}" not found or does not have migrations configured`);
+		return requested;
+	}
+	if (namespacesWithMigrations.length === 1) {
+		const [ns] = namespacesWithMigrations;
+		return assertDefined(ns, "namespace with migrations missing").namespace;
+	}
+	throw new Error(`Multiple TailorDB services found. Please specify namespace with --namespace flag: ${namespacesWithMigrations.map((ns) => ns.namespace).join(", ")}`);
+}
+const scriptCommand = defineAppCommand({
+	name: "script",
+	description: "Add a migration script (migrate.ts) template to an existing migration directory, or record with --no-script that a migration intentionally has none.",
+	notes: `When \`migrate.ts\` already exists, running the command clears a previously recorded \`--no-script\` acknowledgment.`,
+	args: z.strictObject({
+		...configArg,
+		number: arg(z.string(), {
+			positional: true,
+			description: "Migration number to add a script to (e.g., 0001 or 1)"
+		}),
+		namespace: arg(z.string().optional(), {
+			alias: "n",
+			description: "Target TailorDB namespace (required if multiple namespaces exist)"
+		}),
+		"no-script": arg(z.boolean().optional(), { description: "Record that this migration intentionally runs without a migration script (requires --reason)" }),
+		reason: arg(z.string().optional(), { description: "Reason why no migration script is needed (used with --no-script)" }),
+		"with-test": arg(z.boolean().optional(), { description: "Also add a migrate.test.ts unit-test scaffold; when migrate.ts already exists, only the test is added" })
+	}),
+	run: async (args) => {
+		await script({
+			configPath: args.config,
+			number: args.number,
+			namespace: args.namespace,
+			noScript: args["no-script"],
+			reason: args.reason,
+			withTest: args["with-test"]
+		});
+	}
+});
+
 //#endregion
 //#region src/cli/commands/tailordb/migrate/generate.ts
 /**
@@ -20486,6 +21273,24 @@ function generateDecimalScaleChangeScript(change) {
 * - Subsequent runs: Creates diff from previous snapshot (0001/diff.json, etc.)
 */
 /**
+* Build the safety-critical manual migration guidance for unsupported changes.
+* @returns Lines to write through the CLI logger
+*/
+function getUnsupportedMigrationHintLines() {
+	return [
+		"These changes require a manual 3-step migration process:",
+		"  Migration 1: Add an optional temporary field with the desired structure",
+		"               If the old field is required, make the old field optional",
+		"               For each non-null old value, copy and convert it to the temporary field",
+		"               and set the old field to null in the same update",
+		"               Verify every old value is null before continuing",
+		"  Migration 2: Remove the old field",
+		"  Migration 3: Add the field with the original name and new structure,",
+		"               migrate data from the temporary field, then remove it",
+		"  Important: Reusing the name while stored old values remain can make subsequent reads fail"
+	];
+}
+/**
 * Handle --init option: delete existing migrations directories
 * @param {NamespaceWithMigrations[]} namespaces - Namespaces with migrations
 * @param {boolean} skipConfirmation - Whether to skip confirmation prompt
@@ -20542,7 +21347,7 @@ async function generate(options) {
 	if (options.init) await handleInitOption(namespacesWithMigrations, options.yes);
 	let pluginManager;
 	if (plugins.length > 0) pluginManager = new PluginManager(plugins);
-	const { defineApplication } = await import("./application-CXNaUNhv.mjs");
+	const { defineApplication } = await import("./application-BxLLiLsr.mjs");
 	const application = defineApplication({
 		config,
 		pluginManager
@@ -20604,12 +21409,7 @@ async function generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migra
 		}
 		if (unsupportedChanges.some((change) => change.showThreeStepHint)) {
 			logger.newline();
-			logger.info("These changes require a manual 3-step migration process:");
-			logger.info("  Migration 1: Add a new field with the desired structure");
-			logger.info("               and migrate data from old field to new field");
-			logger.info("  Migration 2: Remove the old field");
-			logger.info("  Migration 3: Add the field with the original name and new structure,");
-			logger.info("               migrate data from temporary field, then remove temporary field");
+			for (const line of getUnsupportedMigrationHintLines()) logger.info(line);
 		}
 		const details = unsupportedChanges.map((c) => `  - ${c.typeName}.${c.fieldName}: ${c.reason}`).join("\n");
 		throw new Error(`Unsupported schema changes detected:\n${details}`);
@@ -20633,7 +21433,7 @@ async function generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migra
 		logger.warn(formatWarnings(diff.warnings));
 	}
 	const result = await generateDiffFiles(diff, migrationsDir, getNextMigrationNumber(migrationsDir), previousSnapshot, options.name);
-	logger.success(`Generated migration ${styles.bold(result.migrationNumber.toString().padStart(4, "0"))}`);
+	logger.success(`Generated migration ${styles.bold(formatMigrationNumber(result.migrationNumber))}`);
 	logger.info(`  Diff file: ${result.diffFilePath}`);
 	if (result.migrateFilePath) {
 		logger.info(`  Migration script: ${result.migrateFilePath}`);
@@ -20655,11 +21455,54 @@ async function generateDiffFromSnapshot(previousSnapshot, currentSnapshot, migra
 		} catch {
 			return;
 		}
-	} else if (diff.hasWarnings) {
-		logger.newline();
-		logger.log(`Data loss is possible for this migration but no script was generated. To add a custom migrate.ts, run:`);
-		logger.log(`  ${styles.bold(`tailor tailordb migration script ${result.migrationNumber.toString().padStart(4, "0")} --namespace ${diff.namespace}`)}`);
+	} else if (diff.hasWarnings) await acknowledgeWarnings({
+		namespace: diff.namespace,
+		migrationsDir,
+		migrationNumber: result.migrationNumber,
+		skipPrompt: options.yes,
+		configPath: options.configPath
+	});
+}
+/**
+* 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
+*/
+async function acknowledgeWarnings(options) {
+	const { namespace, migrationsDir, migrationNumber, skipPrompt, configPath } = options;
+	const label = formatMigrationNumber(migrationNumber);
+	logger.newline();
+	logger.log("Data loss is possible for this migration but no script was generated.");
+	if (!skipPrompt && canPrompt()) {
+		if (await prompt.confirm({
+			message: "Record a reason acknowledging that this migration intentionally has no script?",
+			default: true
+		})) {
+			const scriptSkipped = markMigrationScriptSkipped({
+				migrationsDir,
+				migrationNumber,
+				reason: await prompt.text({
+					message: "Reason:",
+					validate: (value) => value.trim() !== "" || "Reason must not be empty."
+				})
+			});
+			logger.success(`Recorded that migration ${styles.bold(label)} intentionally has no migration script`);
+			logger.info(`  Reason: ${scriptSkipped.reason}`);
+			return;
+		}
 	}
+	const commandOptions = {
+		migrationNumber,
+		namespace,
+		configPath
+	};
+	logger.log("To add a custom migrate.ts, run:");
+	logger.log(`  ${styles.bold(formatMigrationScriptCommand(commandOptions))}`);
+	logger.log("To record that this migration intentionally has no script, run:");
+	logger.log(`  ${styles.bold(formatMigrationScriptCommand({
+		...commandOptions,
+		noScript: true
+	}))}`);
 }
 /**
 * CLI command definition for generate
@@ -20686,6 +21529,478 @@ const generateCommand = defineAppCommand({
 	}
 });
 
+//#endregion
+//#region src/cli/commands/generate/seed/bundler.ts
+/**
+* Seed script bundler for TailorDB seed data
+*
+* Bundles seed scripts to be executed via TestExecScript API
+*/
+const BATCH_SIZE = 100;
+/**
+* Generate seed script content for server-side execution
+* @param namespace - TailorDB namespace
+* @returns Generated seed script content
+*/
+function generateSeedScriptContent(namespace) {
+	return multiline`
+    import { Kysely, TailordbDialect } from "@tailor-platform/sdk/kysely";
+
+    type SeedInput = {
+      data: Record<string, Record<string, unknown>[]>;
+      order: string[];
+      selfRefTypes: string[];
+      upsert?: boolean;
+    };
+
+    type SeedResult = {
+      success: boolean;
+      processed: Record<string, { inserted: number; updated: number; skipped: number }>;
+      errors: string[];
+    };
+
+    function getDB(namespace: string) {
+      const client = new tailordb.Client({ namespace });
+      return new Kysely<Record<string, Record<string, unknown>>>({
+        dialect: new TailordbDialect(client),
+      });
+    }
+
+    export async function main(input: SeedInput): Promise<SeedResult> {
+      const db = getDB("${namespace}");
+      const processed: Record<
+        string,
+        { inserted: number; updated: number; skipped: number }
+      > = {};
+      const errors: string[] = [];
+      const BATCH_SIZE = ${String(BATCH_SIZE)};
+      const upsert = input.upsert === true;
+
+      for (const typeName of input.order) {
+        const records = input.data[typeName];
+        if (!records || records.length === 0) {
+          console.log(\`[${namespace}] \${typeName}: skipped (no data)\`);
+          continue;
+        }
+
+        processed[typeName] = { inserted: 0, updated: 0, skipped: 0 };
+        const hasSelfRef = (input.selfRefTypes || []).includes(typeName);
+
+        try {
+          let recordsToInsert = records;
+          let recordsToUpdate: Record<string, unknown>[] = [];
+          if (upsert) {
+            const existing = await db
+              .selectFrom(typeName)
+              .select("id")
+              .where(
+                "id",
+                "in",
+                records.map((record) => record.id),
+              )
+              .execute();
+            const existingIds = new Set(existing.map((record) => record.id));
+            recordsToInsert = records.filter((record) => !existingIds.has(record.id));
+            recordsToUpdate = records.filter((record) => existingIds.has(record.id));
+          }
+
+          if (hasSelfRef) {
+            // Insert one-by-one to respect self-referencing foreign key order
+            for (const record of recordsToInsert) {
+              await db.insertInto(typeName).values(record).execute();
+              processed[typeName].inserted += 1;
+            }
+            if (!upsert) {
+              console.log(
+                \`[${namespace}] \${typeName}: \${processed[typeName].inserted}/\${records.length} (one-by-one)\`,
+              );
+            }
+          } else {
+            for (let i = 0; i < recordsToInsert.length; i += BATCH_SIZE) {
+              const batch = recordsToInsert.slice(i, i + BATCH_SIZE);
+              await db.insertInto(typeName).values(batch).execute();
+              processed[typeName].inserted += batch.length;
+              if (!upsert) {
+                console.log(
+                  \`[${namespace}] \${typeName}: \${processed[typeName].inserted}/\${records.length}\`,
+                );
+              }
+            }
+          }
+
+          for (const record of recordsToUpdate) {
+            const { id, ...values } = record;
+            if (Object.keys(values).length === 0) {
+              processed[typeName].skipped += 1;
+              continue;
+            }
+            await db.updateTable(typeName).set(values).where("id", "=", id).execute();
+            processed[typeName].updated += 1;
+          }
+
+          const counts = processed[typeName];
+          if (upsert) {
+            const skipped = counts.skipped > 0 ? \`, \${counts.skipped} skipped\` : "";
+            console.log(
+              \`[${namespace}] \${typeName}: \${counts.inserted} inserted, \${counts.updated} updated\${skipped}\`,
+            );
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          errors.push(\`\${typeName}: \${message}\`);
+          console.error(\`[${namespace}] \${typeName}: failed - \${message}\`);
+        }
+      }
+
+      return {
+        success: errors.length === 0,
+        processed,
+        errors,
+      };
+    }
+  `;
+}
+/**
+* Bundle a seed script for server-side execution
+*
+* Creates an entry that:
+* 1. Defines getDB() function inline
+* 2. Processes data in batches using Kysely
+* 3. Reports progress via console.log
+* 4. Exports as main() for TestExecScript
+* @param namespace - TailorDB namespace
+* @param typeNames - List of type names to include in the seed
+* @param baseDir - Directory whose dependencies and tsconfig the generated entry uses
+* @returns Bundled seed script result
+*/
+async function bundleSeedScript(namespace, typeNames, baseDir = process.cwd()) {
+	const outputDir = path.resolve(getDistDir(), "seed");
+	fs$2.mkdirSync(outputDir, { recursive: true });
+	const entryPath = path.join(outputDir, `seed_${namespace}.entry.ts`);
+	const entryContent = generateSeedScriptContent(namespace);
+	fs$2.writeFileSync(entryPath, entryContent);
+	let tsconfig;
+	try {
+		tsconfig = await resolveTSConfig(baseDir);
+	} catch {
+		tsconfig = void 0;
+	}
+	const bundleLog = createBundleLog({ tsconfig });
+	const result = await rolldown.build({
+		plugins: [
+			createGeneratedEntryResolverPlugin(entryPath, baseDir),
+			createTsconfigPathsPlugin(),
+			platformBundleDefinePlugin
+		],
+		input: entryPath,
+		write: false,
+		output: {
+			format: "esm",
+			sourcemap: false,
+			minify: false,
+			codeSplitting: false,
+			globals: { tailordb: "tailordb" }
+		},
+		external: ["tailordb"],
+		resolve: { conditionNames: ["node", "import"] },
+		tsconfig,
+		treeshake: {
+			moduleSideEffects: false,
+			annotations: true,
+			unknownGlobalSideEffects: false
+		},
+		...bundleLog.options
+	});
+	bundleLog.assertAllResolved();
+	return {
+		namespace,
+		bundledCode: result.output[0].code,
+		typesIncluded: typeNames
+	};
+}
+
+//#endregion
+//#region src/cli/shared/seed-chunker.ts
+/**
+* Seed data chunker for splitting large seed data into manageable message sizes.
+*
+* When seed data exceeds the gRPC message size limit, this module splits the data
+* into multiple chunks at type boundaries (or record boundaries for large types).
+*/
+/** Default maximum message size: 3.5MB (conservative limit for gRPC) */
+const DEFAULT_MAX_MESSAGE_SIZE = 3.5 * 1024 * 1024;
+/** Reserved bytes for message metadata overhead */
+const METADATA_OVERHEAD = 1024;
+/**
+* Split seed data into chunks that fit within the gRPC message size limit.
+*
+* Algorithm:
+* 1. Calculate the available budget for the arg field (maxMessageSize - codeByteSize - overhead)
+* 2. If all data fits in one message, return a single chunk
+* 3. Otherwise, iterate through types in dependency order:
+*    - If a type fits in the current chunk, add it
+*    - If adding a type would exceed the budget, finalize the current chunk and start a new one
+*    - If a single type exceeds the budget, split its records across multiple chunks
+*    - If a single record exceeds the budget, throw an error
+* @param options - Chunking options
+* @returns Array of seed chunks
+*/
+function chunkSeedData(options) {
+	const { data, order, codeByteSize, maxMessageSize = DEFAULT_MAX_MESSAGE_SIZE } = options;
+	const argBudget = maxMessageSize - codeByteSize - METADATA_OVERHEAD;
+	if (argBudget <= 0) throw new Error(`Code size (${codeByteSize} bytes) exceeds the message size limit (${maxMessageSize} bytes). No space left for seed data.`);
+	const typesWithData = order.filter((type) => (data[type]?.length ?? 0) > 0);
+	if (typesWithData.length === 0) return [];
+	if (byteSize(JSON.stringify({
+		data,
+		order
+	})) <= argBudget) return [{
+		data,
+		order,
+		index: 0,
+		total: 1
+	}];
+	const chunks = [];
+	let currentData = {};
+	let currentOrder = [];
+	for (const type of typesWithData) {
+		const typeRecords = assertDefined(data[type], `seed data missing for type: ${type}`);
+		if (currentOrder.length > 0) {
+			const testData = {
+				...currentData,
+				[type]: typeRecords
+			};
+			const testOrder = [...currentOrder, type];
+			if (byteSize(JSON.stringify({
+				data: testData,
+				order: testOrder
+			})) > argBudget) {
+				chunks.push({
+					data: currentData,
+					order: currentOrder,
+					index: chunks.length
+				});
+				currentData = {};
+				currentOrder = [];
+			}
+		}
+		if (byteSize(JSON.stringify({
+			data: { [type]: typeRecords },
+			order: [type]
+		})) <= argBudget) {
+			currentData[type] = typeRecords;
+			currentOrder.push(type);
+			continue;
+		}
+		if (currentOrder.length > 0) {
+			chunks.push({
+				data: currentData,
+				order: currentOrder,
+				index: chunks.length
+			});
+			currentData = {};
+			currentOrder = [];
+		}
+		let recordBatch = [];
+		for (const record of typeRecords) {
+			if (byteSize(JSON.stringify({
+				data: { [type]: [record] },
+				order: [type]
+			})) > argBudget) {
+				const singleRecordSize = byteSize(JSON.stringify(record));
+				throw new Error(`A single record in type "${type}" (${singleRecordSize} bytes) exceeds the message size budget (${argBudget} bytes). Consider increasing maxMessageSize or reducing the record size.`);
+			}
+			const testBatch = [...recordBatch, record];
+			const testData = {
+				...currentData,
+				[type]: testBatch
+			};
+			const testOrder = currentOrder.includes(type) ? currentOrder : [...currentOrder, type];
+			if (byteSize(JSON.stringify({
+				data: testData,
+				order: testOrder
+			})) > argBudget && recordBatch.length > 0) {
+				currentData[type] = recordBatch;
+				if (!currentOrder.includes(type)) currentOrder.push(type);
+				chunks.push({
+					data: currentData,
+					order: currentOrder,
+					index: chunks.length
+				});
+				currentData = {};
+				currentOrder = [];
+				recordBatch = [record];
+			} else recordBatch = testBatch;
+		}
+		if (recordBatch.length > 0) {
+			currentData[type] = recordBatch;
+			if (!currentOrder.includes(type)) currentOrder.push(type);
+		}
+	}
+	if (currentOrder.length > 0) chunks.push({
+		data: currentData,
+		order: currentOrder,
+		index: chunks.length
+	});
+	const total = chunks.length;
+	return chunks.map((chunk) => ({
+		...chunk,
+		total
+	}));
+}
+function byteSize(str) {
+	return new TextEncoder().encode(str).length;
+}
+
+//#endregion
+//#region src/plugin/builtin/seed/seed-type-processor.ts
+/**
+* Processes TailorDB types to extract seed type information
+* @param type - Parsed TailorDB type
+* @param namespace - Namespace of the type
+* @returns Seed type information
+*/
+function processSeedTypeInfo(type, namespace) {
+	const dependencies = /* @__PURE__ */ new Set();
+	const selfRefFields = [];
+	for (const [fieldName, field] of Object.entries(type.fields)) {
+		const targetType = field.relation?.targetType ?? field.config.foreignKeyType;
+		if (!targetType) continue;
+		if (targetType === type.name) selfRefFields.push(fieldName);
+		else dependencies.add(targetType);
+	}
+	return {
+		name: type.name,
+		namespace,
+		dependencies: Array.from(dependencies),
+		selfRefFields,
+		dataFile: `data/${type.name}.jsonl`
+	};
+}
+/**
+* Build per-namespace seed ordering information from TailorDB namespace data.
+* @param tailordb - TailorDB namespaces with their types
+* @returns Seed namespace configs, in namespace order
+*/
+function buildSeedNamespaceConfigs(tailordb) {
+	return tailordb.map((ns) => {
+		const types = [];
+		const dependencies = {};
+		const selfRefTypes = [];
+		const requiredFields = {};
+		for (const [typeName, type] of Object.entries(ns.types)) {
+			const typeInfo = processSeedTypeInfo(type, ns.namespace);
+			types.push(typeInfo.name);
+			dependencies[typeInfo.name] = typeInfo.dependencies;
+			if (typeInfo.selfRefFields.length > 0) selfRefTypes.push(typeInfo.name);
+			const linesDb = processLinesDb(type, assertDefined(ns.sourceInfo.get(typeName), `source info missing for type: ${typeName}`));
+			requiredFields[typeInfo.name] = Object.entries(type.fields).filter(([fieldName, field]) => field.config.required !== false && !linesDb.optionalFields.includes(fieldName) && !linesDb.omitFields.includes(fieldName)).map(([fieldName]) => fieldName);
+		}
+		return {
+			namespace: ns.namespace,
+			types,
+			dependencies,
+			selfRefTypes,
+			requiredFields
+		};
+	});
+}
+
+//#endregion
+//#region src/cli/shared/tailordb-namespaces.ts
+/**
+* Load local TailorDB namespaces along with the config plugins and the
+* defined application. Internal superset of {@link loadTailorDBNamespaces}.
+* @param options - Namespace loading options.
+* @returns The loaded config, plugins, application, and TailorDB namespace data.
+*/
+async function loadApplicationNamespaces(options = {}) {
+	const { config, plugins } = await loadConfig(options.configPath);
+	await generateUserTypes({
+		config,
+		configPath: config.path
+	});
+	const application = defineApplication({
+		config,
+		pluginManager: plugins.length > 0 ? new PluginManager(plugins) : void 0
+	});
+	const namespaceNames = typeof options.namespaces === "function" ? options.namespaces(config, plugins) : options.namespaces;
+	const namespaceFilter = namespaceNames ? new Set(namespaceNames) : void 0;
+	const services = namespaceFilter ? application.tailorDBServices.filter((db) => namespaceFilter.has(db.namespace)) : application.tailorDBServices;
+	if (namespaceFilter && services.length !== namespaceFilter.size) {
+		const found = new Set(services.map((db) => db.namespace));
+		const missing = [...namespaceFilter].filter((ns) => !found.has(ns)).join(", ");
+		const available = application.tailorDBServices.map((db) => db.namespace).join(", ");
+		throw new Error(`TailorDB namespace "${missing}" not found in local config.db.` + (available ? ` Available owned namespaces: ${available}` : ""));
+	}
+	const namespaces = [];
+	for (const db of services) {
+		await db.loadTypes();
+		await db.processNamespacePlugins();
+		namespaces.push({
+			namespace: db.namespace,
+			types: { ...db.types },
+			sourceInfo: new Map(Object.entries(db.typeSourceInfo)),
+			pluginAttachments: db.pluginAttachments
+		});
+	}
+	return {
+		config,
+		plugins,
+		application,
+		namespaces
+	};
+}
+/**
+* Load local TailorDB namespaces exactly as SDK generation/deploy sees them:
+* the config is loaded, user types are generated, and each selected
+* namespace's types are loaded with namespace plugins applied.
+* @param options - Namespace loading options.
+* @returns The loaded config and TailorDB namespace data.
+*/
+async function loadTailorDBNamespaces(options = {}) {
+	const { config, plugins, namespaces } = await loadApplicationNamespaces(options);
+	return {
+		config,
+		plugins,
+		namespaces
+	};
+}
+
+//#endregion
+//#region src/cli/shared/seed-context.ts
+/**
+* Load the seed context from the local config. Requires `seedPlugin` to be
+* configured in the config's plugins. A relative `distPath` in the seedPlugin
+* options is resolved against the current working directory — the same base
+* `tailor generate` writes it to.
+* @param options - Seed context loading options.
+* @returns The seed context computed from the local config.
+*/
+async function loadSeedContext(options = {}) {
+	const { config, plugins, application, namespaces } = await loadApplicationNamespaces({ configPath: options.configPath });
+	assertUniqueLocalTailorDBTypeNames({ tailorDBServices: application.tailorDBServices });
+	const seedPlugin = plugins.find((plugin) => plugin.id === SeedGeneratorID);
+	if (!seedPlugin) throw new Error(`seedPlugin is not configured in ${config.path}. Add seedPlugin({ distPath: "./seed" }) from "@tailor-platform/sdk/plugin/seed" to definePlugins().`);
+	const pluginOptions = seedPlugin.pluginConfig;
+	if (typeof pluginOptions?.distPath !== "string" || pluginOptions.distPath === "") throw new Error(`seedPlugin in ${config.path} has no distPath option. Pass seedPlugin({ distPath: "./seed" }) so seed data has a location.`);
+	await application.authService?.resolveNamespaces();
+	const authInput = getAuthInput(application);
+	const idpUserMeta = authInput ? processIdpUser(authInput) : void 0;
+	const idpUser = idpUserMeta ? {
+		idpNamespace: idpUserMeta.idpNamespace,
+		seedScriptCode: generateIdpSeedScriptCode(idpUserMeta.idpNamespace),
+		truncateScriptCode: generateIdpTruncateScriptCode(idpUserMeta.idpNamespace)
+	} : null;
+	return {
+		config,
+		distPath: path.resolve(pluginOptions.distPath),
+		machineUserName: pluginOptions.machineUserName,
+		namespaces: buildSeedNamespaceConfigs(namespaces),
+		idpUser
+	};
+}
+
 //#endregion
 //#region src/cli/shared/tailordb-namespace.ts
 /**
@@ -22701,5 +24016,5 @@ async function registerTsHook(tsHookUrl) {
 }
 
 //#endregion
-export { getOrganization as $, hasUserTokenEntry as $n, ensureConfigId as $t, truncate as A, loadDiff as An, getExecutorJob as At, show as B, sdkAppIdLabelKey as Bn, getWorkflowExecution as Bt, healthCommand as C, createSnapshotFromLocalTypes as Cn, resolveMachineUserInputSource as Cr, getFunctionRegistry as Ct, resumeWorkflow as D, getMigrationFilePath as Dn, triggerExecutor as Dt, resumeCommand as E, getMigrationDirPath as En, triggerCommand as Et, writeDbTypesFile as F, formatMigrationDiff as Fn, startCommand as Ft, removeCommand$1 as G, generateUserTypes as Gn, deploy as Gt, extractOwnedNamespaces as H, sdkVersionLabelKey as Hn, functionExecutionStatusToString as Ht, getConfiguredEditorCommand as I, hasChanges as In, startWorkflow as It, organizationTree as J, assertWritable as Jn, listWorkspaces as Jt, updateCommand$1 as K, prompt as Kn, deployFromCLI as Kt, openInConfiguredEditor as L, getNamespacesWithMigrations as Ln, getCommand$5 as Lt, generate as M, formatMigrationNumber as Mn, jobsCommand as Mt, generateCommand as N, parseMigrationNumberArg as Nn, listExecutorJobs as Nt, listCommand$2 as O, getMigrationFiles as On, listCommand$8 as Ot, generateMigrationScript as P, formatDiffSummary as Pn, watchExecutorJob as Pt, getCommand$1 as Q, hasAnyUserTokenEntry as Qn, workspaceNameSchema as Qt, deployCommand as R, selectTargetNamespace as Rn, getWorkflow as Rt, getAppHealth as S, compareSnapshots as Sn, paginationArgs as Sr, getCommand$4 as St, waitWorkflowExecution as T, getLatestMigrationNumber as Tn, workspaceArgs as Tr, webhookCommand as Tt, logBetaWarning as U, writeMetadataLabels as Un, getCommand$6 as Ut, showCommand as V, sdkNameLabelKey as Vn, listWorkflowExecutions as Vt, remove as W, PluginManager as Wn, getExecutor as Wt, listCommand$3 as X, deleteUserTokens as Xn, createWorkspace$1 as Xt, treeCommand as Y, loadConfig as Yn, createCommand$1 as Yt, listOrganizations as Z, fetchLatestToken as Zn, formatKeyValueTable as Zt, getWorkspace as _, MIGRATE_FILE_NAME as _n, confirmationArgs as _r, listMachineUsers as _t, queryCommand as a, toTailorDBDeployInput as an, loadStoredUserTokens as ar, getFolder as at, listApps as b, assertValidMigrationFiles as bn, multiConfigArg as br, listCommand$7 as bt, removeCommand as c, handleOptionalToRequiredError as cn, readPlatformConfig as cr, createCommand as ct, listUsers as d, compareSnapshotWithRemote as dn, resolveUserTokenKey as dr, listOAuth2Clients as dt, executeScript as en, loadAccessToken as er, updateCommand$2 as et, inviteCommand as f, generateAllTypeManifestsFromSnapshot as fn, saveUserTokens as fr, getCommand$3 as ft, getCommand as g, INITIAL_SCHEMA_NUMBER as gn, configArg as gr, listCommand$6 as gt, restoreWorkspace as h, DIFF_FILE_NAME as hn, commonArgs as hr, tokenCommand as ht, query as i, logRemoteDriftGuidance as in, loadPlatformClientConfig as ir, getCommand$2 as it, truncateCommand as j, reconstructSnapshotFromMigrations as jn, getExecutorWaitFailureMessage as jt, listWorkflows as k, getNextMigrationNumber as kn, listExecutors as kt, removeUser as l, parseMigrationLabelNumber as ln, removeLegacyUserAlias as lr, createFolder as lt, restoreCommand as m, DB_TYPES_FILE_NAME as mn, defineAppCommand as mr, getMachineUserToken as mt, errorToJson as n, bundleMigrationScript as nn, loadConsoleBaseUrl as nr, listCommand$4 as nt, updateCommand as o, verifyRemoteSchema as on, loadWorkspaceId as or, deleteCommand$1 as ot, inviteUser as p, protoGqlPermission as pn, writePlatformConfig as pr, getOAuth2Client as pt, updateOrganization as q, apiCall as qn, listCommand$9 as qt, serializeError as r, checkMigrationDiffs as rn, loadMachineUserName as rr, listFolders as rt, updateUser as s, MIGRATION_LABEL_KEY as sn, platformConfigFromProfile as sr, deleteFolder as st, registerTsHook as t, waitForExecution as tn, loadConfigPath as tr, updateFolder as tt, listCommand as u, sanitizeMigrationLabel as un, resolveConfigUser as ur, listCommand$5 as ut, deleteCommand as v, SCHEMA_FILE_NAME as vn, deploymentArgs as vr, generate$1 as vt, waitCommand as w, formatSchemaDrifts as wn, toPageDirection as wr, listWebhookExecutors as wt, listCommand$1 as x, compareLocalTypesWithSnapshot as xn, pagedLogArgs as xr, listFunctionRegistries as xt, deleteWorkspace as y, assertMigrationNumberExists as yn, isVerbose as yr, getAuthInput as yt, deployStaticWebsite as z, resourceTrn as zn, executionsCommand as zt };
-//# sourceMappingURL=register-ts-hook-LYV7zH-e.mjs.map
+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