wp-typia 0.24.4 → 0.24.6

package/dist-bunli/cli-tj7ajdvf.js

@@ -1,2612 +0,0 @@
-// @bun
-import {
-  MIGRATION_TODO_PREFIX,
-  ROOT_PHP_MIGRATION_REGISTRY,
-  SNAPSHOT_DIR,
-  assertMigrationVersionLabel,
-  assertNoLegacySemverMigrationWorkspace,
-  assertRuleHasNoTodos,
-  compareMigrationVersionLabels,
-  copyFile,
-  createFixtureScalarValue,
-  createMissingBlockSnapshotMessage,
-  createTransformFixtureValue,
-  deleteValueAtPath,
-  detectPackageManagerId,
-  discoverMigrationEntries,
-  discoverMigrationInitLayout,
-  ensureAdvancedMigrationProject,
-  ensureMigrationDirectories,
-  escapeForCode,
-  formatLegacyMigrationWorkspaceResetGuidance,
-  getAvailableSnapshotVersionsForBlock,
-  getFixtureFilePath,
-  getGeneratedDirForBlock,
-  getLocalTsxBinary,
-  getProjectPaths,
-  getRuleFilePath,
-  getSnapshotBlockJsonPath,
-  getSnapshotManifestPath,
-  getSnapshotRoot,
-  getSnapshotSavePath,
-  getValueAtPath,
-  isInteractiveTerminal,
-  isNumber,
-  loadMigrationProject,
-  readJson,
-  readRuleMetadata,
-  renderObjectKey,
-  renderPhpValue,
-  resolveTargetMigrationVersion,
-  runProjectScriptIfPresent,
-  sanitizeSaveSnapshotSource,
-  sanitizeSnapshotBlockJson,
-  setValueAtPath,
-  writeInitialMigrationScaffold,
-  writeMigrationConfig
-} from "./cli-e4bwd81c.js";
-import {
-  readWorkspaceInventory
-} from "./cli-fv4h3ydt.js";
-import {
-  getInvalidWorkspaceProjectReason,
-  tryResolveWorkspaceProject
-} from "./cli-1170yyve.js";
-import {
-  formatRunScript
-} from "./cli-am5x7tb4.js";
-import {
-  cloneJsonValue
-} from "./cli-ccax7s0s.js";
-import {
-  createReadlinePrompt
-} from "./cli-rdcga1bd.js";
-
-// ../wp-typia-project-tools/src/runtime/migrations.ts
-import fs8 from "fs";
-import path8 from "path";
-
-// ../wp-typia-project-tools/src/runtime/migration-command-surface.ts
-function formatMigrationHelpText() {
-  return `Usage:
-  wp-typia migrate init --current-migration-version <label>
-  wp-typia migrate snapshot --migration-version <label>
-  wp-typia migrate plan --from-migration-version <label> [--to-migration-version current]
-  wp-typia migrate wizard
-  wp-typia migrate diff --from-migration-version <label> [--to-migration-version current]
-  wp-typia migrate scaffold --from-migration-version <label> [--to-migration-version current]
-  wp-typia migrate verify [--from-migration-version <label>|--all]
-  wp-typia migrate doctor [--from-migration-version <label>|--all]
-  wp-typia migrate fixtures [--from-migration-version <label>|--all] [--to-migration-version current] [--force]
-  wp-typia migrate fuzz [--from-migration-version <label>|--all] [--iterations <n>] [--seed <n>]
-
-Notes:
-  \`migrate init\` auto-detects supported single-block and \`src/blocks/*\` multi-block layouts.
-  \`migrate init\` only retrofits migration support into projects that already match those layouts.
-  A broader project-level \`wp-typia init\` path remains future work.
-  Migration versions use strict schema labels like \`v1\`, \`v2\`, and \`v3\`.
-  \`migrate wizard\` is TTY-only and helps you choose one legacy migration version to preview.
-  \`migrate plan\` and \`migrate wizard\` are read-only previews; they do not scaffold rules or fixtures.
-  --all runs across every configured legacy migration version and every configured block target.
-  Existing fixture files are preserved and reported as skipped unless you pass \`--force\`.
-  Use \`migrate fixtures --force\` as the explicit refresh path for generated fixture files.
-  In TTY usage, \`migrate fixtures --force\` asks before overwriting existing fixture files.
-  In non-interactive usage, \`migrate fixtures --force\` overwrites immediately for script compatibility.`;
-}
-function parseMigrationArgs(argv) {
-  const parsed = {
-    command: undefined,
-    flags: {
-      all: false,
-      currentMigrationVersion: undefined,
-      force: false,
-      fromMigrationVersion: undefined,
-      iterations: undefined,
-      migrationVersion: undefined,
-      seed: undefined,
-      toMigrationVersion: "current"
-    }
-  };
-  if (argv.length === 0) {
-    throw new Error(formatMigrationHelpText());
-  }
-  parsed.command = argv[0];
-  for (let index = 1;index < argv.length; index += 1) {
-    const arg = argv[index];
-    const next = argv[index + 1];
-    if (arg === "--")
-      continue;
-    if (arg === "--all") {
-      parsed.flags.all = true;
-      continue;
-    }
-    if (arg === "--force") {
-      parsed.flags.force = true;
-      continue;
-    }
-    if (arg === "--current-migration-version") {
-      parsed.flags.currentMigrationVersion = next;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--current-migration-version=")) {
-      parsed.flags.currentMigrationVersion = arg.split("=", 2)[1];
-      continue;
-    }
-    if (arg === "--from-migration-version") {
-      parsed.flags.fromMigrationVersion = next;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--from-migration-version=")) {
-      parsed.flags.fromMigrationVersion = arg.split("=", 2)[1];
-      continue;
-    }
-    if (arg === "--iterations") {
-      parsed.flags.iterations = next;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--iterations=")) {
-      parsed.flags.iterations = arg.split("=", 2)[1];
-      continue;
-    }
-    if (arg === "--seed") {
-      parsed.flags.seed = next;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--seed=")) {
-      parsed.flags.seed = arg.split("=", 2)[1];
-      continue;
-    }
-    if (arg === "--to-migration-version") {
-      parsed.flags.toMigrationVersion = next;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--to-migration-version=")) {
-      parsed.flags.toMigrationVersion = arg.split("=", 2)[1];
-      continue;
-    }
-    if (arg === "--migration-version") {
-      parsed.flags.migrationVersion = next;
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--migration-version=")) {
-      parsed.flags.migrationVersion = arg.split("=", 2)[1];
-      continue;
-    }
-    if (arg === "--current-version" || arg.startsWith("--current-version=") || arg === "--version" || arg.startsWith("--version=") || arg === "--from" || arg.startsWith("--from=") || arg === "--to" || arg.startsWith("--to=")) {
-      throwLegacyMigrationFlagError(arg);
-    }
-    throw new Error(`Unknown migration flag: ${arg}`);
-  }
-  return parsed;
-}
-function parsePositiveInteger(value, label) {
-  if (!value) {
-    return;
-  }
-  if (!/^\d+$/.test(value)) {
-    throw new Error(`Invalid ${label}: ${value}. Expected a positive integer.`);
-  }
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error(`Invalid ${label}: ${value}. Expected a positive integer.`);
-  }
-  return parsed;
-}
-function parseNonNegativeInteger(value, label) {
-  if (!value) {
-    return;
-  }
-  if (!/^\d+$/.test(value)) {
-    throw new Error(`Invalid ${label}: ${value}. Expected a non-negative integer.`);
-  }
-  const parsed = Number.parseInt(value, 10);
-  if (!Number.isInteger(parsed) || parsed < 0) {
-    throw new Error(`Invalid ${label}: ${value}. Expected a non-negative integer.`);
-  }
-  return parsed;
-}
-function throwLegacyMigrationFlagError(flag) {
-  const replacement = flag.startsWith("--current-version") ? "--current-migration-version" : flag.startsWith("--version") ? "--migration-version" : flag.startsWith("--from") ? "--from-migration-version" : "--to-migration-version";
-  throw new Error(`Legacy migration flag \`${flag}\` is no longer supported. Use \`${replacement}\` with schema labels like \`v1\` and \`v2\` instead. ` + formatLegacyMigrationWorkspaceResetGuidance());
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-diff.ts
-import fs from "fs";
-
-// ../wp-typia-project-tools/src/runtime/migration-manifest.ts
-function flattenManifestLeafAttributes(attributes) {
-  return Object.entries(attributes).flatMap(([key, attribute]) => flattenManifestAttribute(attribute, key, key, {
-    rootPath: key,
-    unionBranch: null,
-    unionDiscriminator: null,
-    unionRoot: null
-  }));
-}
-function flattenManifestAttribute(attribute, currentPath, sourcePath, context) {
-  if (!attribute) {
-    return [];
-  }
-  if (attribute.ts.kind === "object") {
-    const properties = Object.entries(attribute.ts.properties ?? {});
-    if (properties.length === 0) {
-      return [{ ...context, attribute, currentPath, sourcePath }];
-    }
-    return properties.flatMap(([key, property]) => flattenManifestAttribute(property, `${currentPath}.${key}`, `${sourcePath}.${key}`, {
-      ...context
-    }));
-  }
-  if (attribute.ts.kind === "union" && attribute.ts.union) {
-    const unionMetadata = attribute.ts.union;
-    return Object.entries(attribute.ts.union.branches ?? {}).flatMap(([branchKey, branchAttribute]) => Object.entries(branchAttribute.ts.properties ?? {}).filter(([key]) => key !== unionMetadata.discriminator).flatMap(([key, property]) => flattenManifestAttribute(property, `${currentPath}.${branchKey}.${key}`, `${sourcePath}.${key}`, {
-      rootPath: context.rootPath,
-      unionBranch: branchKey,
-      unionDiscriminator: unionMetadata.discriminator,
-      unionRoot: currentPath
-    })));
-  }
-  return [{ ...context, attribute, currentPath, sourcePath }];
-}
-function getAttributeByCurrentPath(attributes, currentPath) {
-  const segments = String(currentPath).split(".");
-  const rootKey = segments.shift();
-  if (!rootKey) {
-    return null;
-  }
-  let attribute = attributes[rootKey] ?? null;
-  while (attribute && segments.length > 0) {
-    if (attribute.ts.kind === "union" && attribute.ts.union) {
-      const branchKey = segments.shift();
-      if (!branchKey || !(branchKey in attribute.ts.union.branches)) {
-        return null;
-      }
-      attribute = attribute.ts.union.branches[branchKey];
-      continue;
-    }
-    if (attribute.ts.kind === "object" && attribute.ts.properties) {
-      const propertyKey = segments.shift();
-      if (!propertyKey || !(propertyKey in attribute.ts.properties)) {
-        return null;
-      }
-      attribute = attribute.ts.properties[propertyKey];
-      continue;
-    }
-    return null;
-  }
-  return attribute;
-}
-function hasManifestDefault(attribute) {
-  return attribute?.typia?.hasDefault === true;
-}
-function getManifestDefaultValue(attribute) {
-  return attribute?.typia?.defaultValue ?? null;
-}
-function summarizeManifest(manifest) {
-  return {
-    attributes: Object.fromEntries(Object.entries(manifest.attributes ?? {}).map(([name, attribute]) => [
-      name,
-      {
-        constraints: attribute.typia?.constraints ?? {},
-        defaultValue: attribute.typia?.defaultValue ?? null,
-        hasDefault: attribute.typia?.hasDefault ?? false,
-        enum: attribute.wp?.enum ?? null,
-        kind: attribute.ts?.kind ?? null,
-        required: attribute.ts?.required ?? false,
-        union: attribute.ts?.union ?? null
-      }
-    ])),
-    manifestVersion: manifest.manifestVersion ?? null,
-    sourceType: manifest.sourceType ?? null
-  };
-}
-function summarizeUnionBranches(manifestSummary) {
-  if (!manifestSummary?.attributes) {
-    return [];
-  }
-  return Object.entries(manifestSummary.attributes).filter(([, attribute]) => attribute.kind === "union" && attribute.union).map(([field, attribute]) => ({
-    branches: Object.keys(attribute.union?.branches ?? {}),
-    discriminator: attribute.union?.discriminator ?? null,
-    field
-  }));
-}
-function defaultValueForManifestAttribute(attribute) {
-  if (attribute.typia?.hasDefault) {
-    return attribute.typia.defaultValue;
-  }
-  if (attribute.wp?.enum && attribute.wp.enum.length > 0) {
-    return attribute.wp.enum[0] ?? null;
-  }
-  switch (attribute.ts.kind) {
-    case "string":
-      return "";
-    case "number":
-      return 0;
-    case "boolean":
-      return false;
-    case "array":
-      return [];
-    case "object": {
-      const result = {};
-      for (const [key, property] of Object.entries(attribute.ts.properties ?? {})) {
-        result[key] = defaultValueForManifestAttribute(property);
-      }
-      return result;
-    }
-    case "union": {
-      const firstBranch = Object.values(attribute.ts.union?.branches ?? {})[0];
-      return firstBranch ? defaultValueForManifestAttribute(firstBranch) : null;
-    }
-    default:
-      return null;
-  }
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-diff-rename.ts
-function createRenameCandidates({
-  addedKeys,
-  isUnionRenameCompatible,
-  newAttributes,
-  newLeafAttributes,
-  oldAttributes,
-  oldLeafAttributes,
-  removedKeys
-}) {
-  const assessments = [];
-  for (const currentPath of addedKeys) {
-    const nextAttribute = newAttributes[currentPath];
-    if (!nextAttribute)
-      continue;
-    for (const legacyPath of removedKeys) {
-      const previous = oldAttributes[legacyPath];
-      if (!previous)
-        continue;
-      const candidate = assessRenameCandidate(previous, nextAttribute, legacyPath, currentPath, isUnionRenameCompatible);
-      if (candidate) {
-        assessments.push(candidate);
-      }
-    }
-  }
-  const oldLeafMap = new Map(oldLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-  const newLeafMap = new Map(newLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-  const removedLeafDescriptors = oldLeafAttributes.filter((descriptor) => !newLeafMap.has(descriptor.currentPath));
-  const addedLeafDescriptors = newLeafAttributes.filter((descriptor) => !oldLeafMap.has(descriptor.currentPath));
-  for (const nextDescriptor of addedLeafDescriptors) {
-    if (!nextDescriptor.currentPath.includes(".")) {
-      continue;
-    }
-    for (const previousDescriptor of removedLeafDescriptors) {
-      if (!previousDescriptor.currentPath.includes(".")) {
-        continue;
-      }
-      const candidate = assessRenameCandidate(previousDescriptor.attribute, nextDescriptor.attribute, previousDescriptor.currentPath, nextDescriptor.currentPath, isUnionRenameCompatible);
-      if (candidate) {
-        assessments.push(candidate);
-      }
-    }
-  }
-  return assessments.map((candidate) => {
-    const currentMatches = assessments.filter((item) => item.currentPath === candidate.currentPath).sort((left, right) => right.score - left.score);
-    const legacyMatches = assessments.filter((item) => item.legacyPath === candidate.legacyPath).sort((left, right) => right.score - left.score);
-    const currentLeader = currentMatches[0];
-    const legacyLeader = legacyMatches[0];
-    const currentHasTie = currentMatches.length > 1 && Math.abs((currentMatches[1]?.score ?? 0) - currentLeader.score) < 0.05;
-    const legacyHasTie = legacyMatches.length > 1 && Math.abs((legacyMatches[1]?.score ?? 0) - legacyLeader.score) < 0.05;
-    return {
-      ...candidate,
-      autoApply: currentLeader.legacyPath === candidate.legacyPath && legacyLeader.currentPath === candidate.currentPath && !currentHasTie && !legacyHasTie && candidate.score >= 0.6
-    };
-  }).filter((candidate, index, list) => {
-    const firstMatch = list.findIndex((item) => item.currentPath === candidate.currentPath && item.legacyPath === candidate.legacyPath);
-    return firstMatch === index;
-  }).sort((left, right) => right.score - left.score);
-}
-function passesNameSimilarityRule(legacyPath, currentPath) {
-  return scoreRenameSimilarity(legacyPath, currentPath) >= 0.6;
-}
-function isRenameCandidateShapeCompatible(oldAttribute, newAttribute, isUnionRenameCompatible) {
-  if (!oldAttribute || !newAttribute || oldAttribute.ts.kind !== newAttribute.ts.kind) {
-    return false;
-  }
-  if (["string", "number", "boolean"].includes(oldAttribute.ts.kind)) {
-    return hasRenameCompatibleConstraints(oldAttribute, newAttribute);
-  }
-  if (oldAttribute.ts.kind === "union") {
-    return isUnionRenameCompatible(oldAttribute, newAttribute);
-  }
-  return false;
-}
-function assessRenameCandidate(oldAttribute, newAttribute, legacyPath, currentPath, isUnionRenameCompatible) {
-  if (!isRenameCandidateShapeCompatible(oldAttribute, newAttribute, isUnionRenameCompatible)) {
-    return null;
-  }
-  const baseScore = scoreRenameSimilarity(legacyPath, currentPath);
-  const score = getParentPath(legacyPath) === getParentPath(currentPath) ? Math.max(baseScore, 0.75) : baseScore;
-  return {
-    autoApply: false,
-    currentPath,
-    legacyPath,
-    reason: describeRenameReason(oldAttribute, legacyPath, currentPath, score),
-    score
-  };
-}
-function hasRenameCompatibleConstraints(oldAttribute, newAttribute) {
-  const oldEnum = oldAttribute.wp.enum ?? null;
-  const nextEnum = newAttribute.wp.enum ?? null;
-  if (oldEnum && nextEnum) {
-    const oldIsSubset = oldEnum.every((value) => nextEnum.includes(value));
-    if (!oldIsSubset) {
-      return false;
-    }
-  } else if (oldEnum && !nextEnum) {
-    return false;
-  }
-  const oldConstraints = oldAttribute.typia.constraints ?? {};
-  const nextConstraints = newAttribute.typia.constraints ?? {};
-  return [
-    compareMinimumBound(oldConstraints.minLength, nextConstraints.minLength),
-    compareMaximumBound(oldConstraints.maxLength, nextConstraints.maxLength),
-    compareMinimumBound(oldConstraints.minimum, nextConstraints.minimum),
-    compareMaximumBound(oldConstraints.maximum, nextConstraints.maximum),
-    comparePatternBound(oldConstraints.pattern, nextConstraints.pattern),
-    comparePatternBound(oldConstraints.format, nextConstraints.format),
-    comparePatternBound(oldConstraints.typeTag, nextConstraints.typeTag)
-  ].every(Boolean);
-}
-function compareMinimumBound(oldValue, nextValue) {
-  if (nextValue === null || nextValue === undefined)
-    return true;
-  if (oldValue === null || oldValue === undefined)
-    return true;
-  return Number(oldValue) <= Number(nextValue);
-}
-function compareMaximumBound(oldValue, nextValue) {
-  if (nextValue === null || nextValue === undefined)
-    return true;
-  if (oldValue === null || oldValue === undefined)
-    return true;
-  return Number(oldValue) >= Number(nextValue);
-}
-function comparePatternBound(oldValue, nextValue) {
-  return oldValue === nextValue || oldValue === null || oldValue === undefined;
-}
-function scoreRenameSimilarity(legacyPath, currentPath) {
-  const legacy = normalizeFieldName(legacyPath);
-  const current = normalizeFieldName(currentPath);
-  if (legacy === current)
-    return 1;
-  if (shareAliasGroup(legacy, current))
-    return 0.9;
-  const legacyTokens = tokenizeFieldName(legacy);
-  const currentTokens = tokenizeFieldName(current);
-  const overlap = legacyTokens.filter((token) => currentTokens.includes(token));
-  const jaccard = overlap.length / new Set([...legacyTokens, ...currentTokens]).size;
-  if (legacy.includes(current) || current.includes(legacy)) {
-    return Math.max(jaccard, 0.7);
-  }
-  if (legacyTokens.length > 0 && currentTokens.length > 0 && legacyTokens[legacyTokens.length - 1] === currentTokens[currentTokens.length - 1]) {
-    return Math.max(jaccard, 0.6);
-  }
-  return jaccard;
-}
-function normalizeFieldName(name) {
-  return String(name).replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^a-zA-Z0-9]+/g, " ").trim().toLowerCase().replace(/\s+/g, "");
-}
-function tokenizeFieldName(name) {
-  return String(name).replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
-}
-function getParentPath(pathLabel) {
-  const segments = String(pathLabel).split(".");
-  return segments.length <= 1 ? "" : segments.slice(0, -1).join(".");
-}
-function shareAliasGroup(left, right) {
-  const aliasGroups = [
-    ["content", "headline", "body", "text", "copy", "message"],
-    ["id", "uniqueid", "uuid"],
-    ["visible", "isvisible", "show", "shown", "enabled"],
-    ["align", "alignment", "textalign"],
-    ["count", "clickcount", "counter"],
-    ["url", "href", "link"]
-  ];
-  return aliasGroups.some((group) => group.includes(left) && group.includes(right));
-}
-function describeRenameReason(attribute, legacyPath, currentPath, score) {
-  if (attribute.ts.kind === "union") {
-    return `compatible discriminated union (${legacyPath} \u2192 ${currentPath})`;
-  }
-  if (score >= 0.9)
-    return "high-confidence compatible field";
-  if (score >= 0.6)
-    return "name-similar compatible field";
-  return "compatible field requiring review";
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-diff-transform.ts
-function createTransformSuggestions({
-  oldAttributes,
-  newAttributes,
-  addedKeys,
-  removedKeys,
-  manualItems,
-  renameCandidates,
-  oldLeafAttributes,
-  newLeafAttributes
-}) {
-  const suggestions = [];
-  const activeRenameTargets = new Set(renameCandidates.filter((candidate) => candidate.autoApply).map((candidate) => candidate.currentPath));
-  const oldLeafMap = new Map(oldLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-  const newLeafMap = new Map(newLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-  for (const currentPath of [
-    ...new Set([
-      ...Object.keys(newAttributes),
-      ...manualItems.map((item) => item.path),
-      ...newLeafAttributes.map((item) => item.currentPath)
-    ])
-  ]) {
-    if (activeRenameTargets.has(currentPath)) {
-      continue;
-    }
-    const manualItem = manualItems.find((item) => item.path === currentPath || item.path.startsWith(`${currentPath}.`));
-    const currentAttribute = newLeafMap.get(currentPath)?.attribute ?? getAttributeByCurrentPath(newAttributes, currentPath) ?? null;
-    if (!manualItem || !currentAttribute) {
-      continue;
-    }
-    const exactLegacy = oldLeafMap.get(currentPath)?.attribute ?? getAttributeByCurrentPath(oldAttributes, currentPath) ?? null;
-    if (exactLegacy && exactLegacy.ts.kind !== currentAttribute.ts.kind) {
-      suggestions.push({
-        bodyLines: buildTransformBodyLines(currentAttribute, currentPath),
-        attribute: currentAttribute,
-        currentPath,
-        legacyPath: currentPath,
-        reason: `semantic coercion suggested for ${manualItem.kind}`
-      });
-      continue;
-    }
-    const bestRenameCandidate = renameCandidates.find((candidate) => candidate.currentPath === currentPath);
-    if (bestRenameCandidate && !bestRenameCandidate.autoApply) {
-      suggestions.push({
-        bodyLines: buildTransformBodyLines(currentAttribute, bestRenameCandidate.legacyPath),
-        attribute: currentAttribute,
-        currentPath,
-        legacyPath: bestRenameCandidate.legacyPath,
-        reason: `review coercion from ${bestRenameCandidate.legacyPath}`
-      });
-      continue;
-    }
-    const addedCurrent = addedKeys.includes(currentPath) || newLeafMap.has(currentPath) && !oldLeafMap.has(currentPath);
-    if (!addedCurrent) {
-      continue;
-    }
-    const compatibleLegacyPath = [
-      ...removedKeys,
-      ...oldLeafAttributes.filter((descriptor) => !newLeafMap.has(descriptor.currentPath)).map((descriptor) => descriptor.currentPath)
-    ].find((legacyPath) => passesNameSimilarityRule(legacyPath, currentPath));
-    if (compatibleLegacyPath) {
-      suggestions.push({
-        bodyLines: buildTransformBodyLines(currentAttribute, compatibleLegacyPath),
-        attribute: currentAttribute,
-        currentPath,
-        legacyPath: compatibleLegacyPath,
-        reason: `review coercion from ${compatibleLegacyPath}`
-      });
-    }
-  }
-  return suggestions;
-}
-function describeConstraintChange(oldAttribute, newAttribute) {
-  const details = [];
-  const oldConstraints = oldAttribute.typia.constraints;
-  const nextConstraints = newAttribute.typia.constraints;
-  if (newAttribute.wp.enum && JSON.stringify(newAttribute.wp.enum) !== JSON.stringify(oldAttribute.wp.enum)) {
-    details.push("enum changed");
-  }
-  for (const key of ["minLength", "maxLength", "minimum", "maximum", "pattern", "format", "typeTag"]) {
-    if (oldConstraints[key] !== nextConstraints[key]) {
-      details.push(`${key}: ${oldConstraints[key]} -> ${nextConstraints[key]}`);
-    }
-  }
-  return details.join(", ");
-}
-function buildTransformBodyLines(attribute, legacyPath) {
-  switch (attribute.ts.kind) {
-    case "string":
-      return [`// return typeof legacyValue === "string" ? legacyValue : String(legacyValue ?? "");`];
-    case "number":
-      return [
-        `// const numericValue = typeof legacyValue === "number" ? legacyValue : Number(legacyValue ?? 0);`,
-        `// return Number.isNaN(numericValue) ? undefined : numericValue;`
-      ];
-    case "boolean":
-      return [`// return typeof legacyValue === "boolean" ? legacyValue : Boolean(legacyValue);`];
-    case "union":
-      return [
-        `// const legacyObject = typeof legacyValue === "object" && legacyValue !== null ? legacyValue : {};`,
-        `// return legacyObject; // adjust discriminator / branch fields before verify`
-      ];
-    default:
-      return [`// return legacyValue; // customize migration from ${legacyPath}`];
-  }
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-diff.ts
-function createMigrationDiff(state, blockOrFromVersion, fromVersionOrToVersion, maybeToVersion) {
-  if (typeof blockOrFromVersion === "string" && state.blocks.length > 1) {
-    throw new Error("A block key is required when diffing a multi-block migration project.");
-  }
-  const block = typeof blockOrFromVersion === "string" ? state.blocks[0] : state.blocks.find((entry) => entry.key === blockOrFromVersion.key) ?? null;
-  const fromVersion = typeof blockOrFromVersion === "string" ? blockOrFromVersion : fromVersionOrToVersion;
-  const toVersion = typeof blockOrFromVersion === "string" ? fromVersionOrToVersion : maybeToVersion ?? state.config.currentMigrationVersion;
-  if (!block) {
-    throw new Error(typeof blockOrFromVersion === "string" ? "No migration block targets are configured for this project." : `Unknown migration block key: ${blockOrFromVersion.key}`);
-  }
-  const snapshotManifestPath = getSnapshotManifestPath(state.projectDir, block, fromVersion);
-  if (!fs.existsSync(snapshotManifestPath)) {
-    throw new Error(createMissingBlockSnapshotMessage(block.blockName, fromVersion, getAvailableSnapshotVersionsForBlock(state.projectDir, state.config.supportedMigrationVersions, block)));
-  }
-  const targetManifest = toVersion === state.config.currentMigrationVersion ? block.currentManifest : readJson(getSnapshotManifestPath(state.projectDir, block, toVersion));
-  const oldManifest = readJson(snapshotManifestPath);
-  const oldAttributes = oldManifest.attributes ?? {};
-  const newAttributes = targetManifest.attributes ?? {};
-  const oldLeafAttributes = flattenManifestLeafAttributes(oldAttributes);
-  const newLeafAttributes = flattenManifestLeafAttributes(newAttributes);
-  const autoItems = [];
-  const manualItems = [];
-  const addedKeys = [];
-  const removedKeys = [];
-  for (const [key, newAttribute] of Object.entries(newAttributes)) {
-    const oldAttribute = oldAttributes[key];
-    if (!oldAttribute) {
-      addedKeys.push(key);
-      if (newAttribute.ts.required && !hasManifestDefault(newAttribute)) {
-        manualItems.push({
-          detail: "required field has no default in current schema",
-          kind: "required-addition",
-          path: key,
-          status: "manual"
-        });
-      } else {
-        autoItems.push({
-          detail: hasManifestDefault(newAttribute) ? `default ${JSON.stringify(getManifestDefaultValue(newAttribute))}` : "optional addition",
-          kind: hasManifestDefault(newAttribute) ? "add-default" : "add-optional",
-          path: key,
-          status: "auto"
-        });
-      }
-      continue;
-    }
-    const outcome = compareManifestAttribute(oldAttribute, newAttribute, key);
-    if (outcome.status === "manual") {
-      manualItems.push(outcome);
-    } else {
-      autoItems.push(outcome);
-    }
-  }
-  for (const key of Object.keys(oldAttributes)) {
-    if (!(key in newAttributes)) {
-      removedKeys.push(key);
-      autoItems.push({
-        detail: "field removed from current schema",
-        kind: "drop",
-        path: key,
-        status: "auto"
-      });
-    }
-  }
-  const renameCandidates = createRenameCandidates({
-    addedKeys,
-    isUnionRenameCompatible: (oldAttribute, newAttribute) => compareUnionAttribute(oldAttribute, newAttribute, "$rename").status === "auto",
-    newAttributes,
-    newLeafAttributes,
-    oldAttributes,
-    oldLeafAttributes,
-    removedKeys
-  });
-  const activeRenameCandidates = renameCandidates.filter((candidate) => candidate.autoApply);
-  for (const candidate of activeRenameCandidates) {
-    removeOutcomeByPath(autoItems, candidate.legacyPath, "drop");
-    removeOutcomeByPath(autoItems, candidate.currentPath, "add-default");
-    removeOutcomeByPath(autoItems, candidate.currentPath, "add-optional");
-    removeOutcomeByPath(manualItems, candidate.currentPath, "required-addition");
-    removeOutcomesByPath(manualItems, candidate.currentPath);
-    autoItems.push({
-      detail: `legacy field ${candidate.legacyPath}`,
-      kind: "rename",
-      path: candidate.currentPath,
-      status: "auto"
-    });
-  }
-  const transformSuggestions = createTransformSuggestions({
-    addedKeys,
-    manualItems,
-    newAttributes,
-    newLeafAttributes,
-    oldAttributes,
-    oldLeafAttributes,
-    renameCandidates,
-    removedKeys
-  });
-  return {
-    currentTypeName: targetManifest.sourceType ?? block.currentManifest.sourceType,
-    fromVersion,
-    summary: {
-      auto: autoItems.length,
-      autoItems,
-      manual: manualItems.length,
-      manualItems,
-      renameCandidates,
-      transformSuggestions
-    },
-    toVersion
-  };
-}
-function removeOutcomeByPath(items, pathLabel, kind) {
-  const index = items.findIndex((item) => item.path === pathLabel && item.kind === kind);
-  if (index >= 0) {
-    items.splice(index, 1);
-  }
-}
-function removeOutcomesByPath(items, pathLabel) {
-  for (let index = items.length - 1;index >= 0; index -= 1) {
-    if (items[index]?.path === pathLabel) {
-      items.splice(index, 1);
-    }
-  }
-}
-function compareManifestAttribute(oldAttribute, newAttribute, attributePath) {
-  if (oldAttribute.ts.kind !== newAttribute.ts.kind) {
-    return manualOutcome(attributePath, "type-change", `${oldAttribute.ts.kind} -> ${newAttribute.ts.kind}`);
-  }
-  if (oldAttribute.ts.kind === "union") {
-    return compareUnionAttribute(oldAttribute, newAttribute, attributePath);
-  }
-  if (oldAttribute.ts.kind === "object") {
-    return compareObjectAttribute(oldAttribute, newAttribute, attributePath);
-  }
-  if (oldAttribute.ts.kind === "array") {
-    if (!oldAttribute.ts.items || !newAttribute.ts.items) {
-      return autoOutcome(attributePath, "copy", "array shape unchanged");
-    }
-    const nested = compareManifestAttribute(oldAttribute.ts.items, newAttribute.ts.items, `${attributePath}[]`);
-    return nested.status === "manual" ? nested : autoOutcome(attributePath, "hydrate", "array items can be normalized");
-  }
-  if (hasStricterConstraints(oldAttribute, newAttribute)) {
-    return manualOutcome(attributePath, "stricter-constraints", describeConstraintChange(oldAttribute, newAttribute));
-  }
-  return autoOutcome(attributePath, "copy", "compatible primitive field");
-}
-function compareObjectAttribute(oldAttribute, newAttribute, attributePath) {
-  const oldProperties = oldAttribute.ts.properties ?? {};
-  const newProperties = newAttribute.ts.properties ?? {};
-  for (const [key, nextProperty] of Object.entries(newProperties)) {
-    const previousProperty = oldProperties[key];
-    if (!previousProperty) {
-      if (nextProperty.ts.required && !hasManifestDefault(nextProperty)) {
-        return manualOutcome(`${attributePath}.${key}`, "object-change", "required field has no default in current schema");
-      }
-      continue;
-    }
-    const nested = compareManifestAttribute(previousProperty, nextProperty, `${attributePath}.${key}`);
-    if (nested.status === "manual") {
-      return nested;
-    }
-  }
-  return autoOutcome(attributePath, "hydrate", "object can be normalized with current manifest defaults");
-}
-function compareUnionAttribute(oldAttribute, newAttribute, attributePath) {
-  const oldUnion = oldAttribute.ts.union;
-  const newUnion = newAttribute.ts.union;
-  if (!oldUnion || !newUnion) {
-    return manualOutcome(attributePath, "union-change", "missing union metadata");
-  }
-  if (oldUnion.discriminator !== newUnion.discriminator) {
-    return manualOutcome(attributePath, "union-discriminator-change", `${oldUnion.discriminator} -> ${newUnion.discriminator}`);
-  }
-  const oldBranchKeys = Object.keys(oldUnion.branches);
-  const newBranchKeys = Object.keys(newUnion.branches);
-  for (const branchKey of oldBranchKeys) {
-    if (!(branchKey in newUnion.branches)) {
-      return manualOutcome(attributePath, "union-branch-removal", `branch ${branchKey} was removed`);
-    }
-    const nested = compareManifestAttribute(oldUnion.branches[branchKey], newUnion.branches[branchKey], `${attributePath}.${branchKey}`);
-    if (nested.status === "manual") {
-      return manualOutcome(nested.path, nested.kind.startsWith("union-") ? nested.kind : "union-manual", nested.detail ?? `branch ${branchKey} requires manual review`);
-    }
-  }
-  const addedBranches = newBranchKeys.filter((branchKey) => !(branchKey in oldUnion.branches));
-  if (addedBranches.length > 0) {
-    return autoOutcome(attributePath, "union-branch-addition", `branches added: ${addedBranches.join(", ")}`);
-  }
-  return autoOutcome(attributePath, "copy", "compatible discriminated union");
-}
-function hasStricterConstraints(oldAttribute, newAttribute) {
-  const oldConstraints = oldAttribute.typia.constraints;
-  const nextConstraints = newAttribute.typia.constraints;
-  const oldEnum = oldAttribute.wp.enum ?? null;
-  const nextEnum = newAttribute.wp.enum ?? null;
-  if (nextEnum && (!oldEnum || !oldEnum.every((value) => nextEnum.includes(value)))) {
-    return true;
-  }
-  if (isNumber(nextConstraints.minLength) && (!isNumber(oldConstraints.minLength) || nextConstraints.minLength > oldConstraints.minLength)) {
-    return true;
-  }
-  if (isNumber(nextConstraints.maxLength) && (!isNumber(oldConstraints.maxLength) || nextConstraints.maxLength < oldConstraints.maxLength)) {
-    return true;
-  }
-  if (isNumber(nextConstraints.minimum) && (!isNumber(oldConstraints.minimum) || nextConstraints.minimum > oldConstraints.minimum)) {
-    return true;
-  }
-  if (isNumber(nextConstraints.maximum) && (!isNumber(oldConstraints.maximum) || nextConstraints.maximum < oldConstraints.maximum)) {
-    return true;
-  }
-  if (nextConstraints.pattern && nextConstraints.pattern !== oldConstraints.pattern) {
-    return true;
-  }
-  if (nextConstraints.format && nextConstraints.format !== oldConstraints.format) {
-    return true;
-  }
-  if (nextConstraints.typeTag && nextConstraints.typeTag !== oldConstraints.typeTag) {
-    return true;
-  }
-  return false;
-}
-function autoOutcome(pathLabel, kind, detail) {
-  return { detail, kind, path: pathLabel, status: "auto" };
-}
-function manualOutcome(pathLabel, kind, detail) {
-  return { detail, kind, path: pathLabel, status: "manual" };
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-fixtures.ts
-import fs2 from "fs";
-import path from "path";
-function ensureEdgeFixtureFile(projectDir, block, fromVersion, toVersion, diff, { force = false } = {}) {
-  const fixturePath = getFixtureFilePath(getProjectPaths(projectDir), block, fromVersion, toVersion);
-  fs2.mkdirSync(path.dirname(fixturePath), { recursive: true });
-  if (!force && fs2.existsSync(fixturePath)) {
-    return { fixturePath, written: false };
-  }
-  const fixtureDocument = createEdgeFixtureDocument(projectDir, block, fromVersion, toVersion, diff);
-  fs2.writeFileSync(fixturePath, `${JSON.stringify(fixtureDocument, null, "\t")}
-`, "utf8");
-  return { fixturePath, written: true };
-}
-function createEdgeFixtureDocument(projectDir, block, fromVersion, toVersion, diff) {
-  const manifest = readJson(getSnapshotManifestPath(projectDir, block, fromVersion));
-  const attributes = {};
-  for (const [key, attribute] of Object.entries(manifest.attributes ?? {})) {
-    attributes[key] = defaultValueForManifestAttribute(attribute) ?? null;
-  }
-  const cases = [
-    {
-      input: attributes,
-      name: "default"
-    },
-    ...createRenameFixtureCases(attributes, diff.summary.renameCandidates),
-    ...createTransformFixtureCases(attributes, diff.summary.transformSuggestions),
-    ...createUnionFixtureCases(attributes, manifest.attributes ?? {}, diff.summary.renameCandidates)
-  ];
-  return {
-    cases,
-    fromVersion,
-    toVersion
-  };
-}
-function createRenameFixtureCases(baseAttributes, renameCandidates) {
-  return renameCandidates.filter((candidate) => candidate.autoApply).map((candidate) => {
-    const nextInput = cloneJsonValue(baseAttributes);
-    const legacyValue = getValueAtPath(nextInput, candidate.legacyPath);
-    deleteValueAtPath(nextInput, candidate.currentPath);
-    if (legacyValue === undefined) {
-      setValueAtPath(nextInput, candidate.legacyPath, createFixtureScalarValue(candidate.currentPath));
-    }
-    return {
-      input: nextInput,
-      name: `rename:${candidate.legacyPath}->${candidate.currentPath}`
-    };
-  });
-}
-function createTransformFixtureCases(baseAttributes, transformSuggestions) {
-  return transformSuggestions.map((suggestion) => {
-    const nextInput = cloneJsonValue(baseAttributes);
-    const legacyPath = suggestion.legacyPath ?? suggestion.currentPath;
-    setValueAtPath(nextInput, legacyPath, createTransformFixtureValue(suggestion.attribute, suggestion.currentPath));
-    return {
-      input: nextInput,
-      name: `transform:${legacyPath}->${suggestion.currentPath}`
-    };
-  });
-}
-function createUnionFixtureCases(baseAttributes, manifestAttributes, renameCandidates) {
-  const cases = [];
-  for (const [key, attribute] of Object.entries(manifestAttributes)) {
-    if (attribute.ts.kind !== "union" || !attribute.ts.union) {
-      continue;
-    }
-    for (const [branchKey, branch] of Object.entries(attribute.ts.union.branches ?? {})) {
-      const nextInput = cloneJsonValue(baseAttributes);
-      const legacyPath = renameCandidates.find((candidate) => candidate.autoApply && candidate.currentPath === key)?.legacyPath ?? key;
-      setValueAtPath(nextInput, legacyPath, createUnionBranchFixtureValue(attribute.ts.union.discriminator, branchKey, branch));
-      cases.push({
-        input: nextInput,
-        name: `union:${key}:${branchKey}`
-      });
-    }
-  }
-  return cases;
-}
-function createUnionBranchFixtureValue(discriminator, branchKey, branchAttribute) {
-  const branchValue = defaultValueForManifestAttribute(branchAttribute);
-  if (typeof branchValue === "object" && branchValue !== null && !Array.isArray(branchValue)) {
-    return {
-      ...branchValue,
-      [discriminator]: branchKey
-    };
-  }
-  return {
-    [discriminator]: branchKey
-  };
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-generated-artifacts.ts
-import fs4 from "fs";
-import path5 from "path";
-
-// ../wp-typia-project-tools/src/runtime/migration-fuzz-plan.ts
-function isBlockedPath(pathLabel, blockedPaths) {
-  return blockedPaths.some((blockedPath) => pathLabel === blockedPath || pathLabel.startsWith(`${blockedPath}.`));
-}
-function unique(items) {
-  return [...new Set(items)];
-}
-function createMigrationFuzzPlan(legacyManifest, currentManifest, diff) {
-  const legacyLeafMap = new Map(flattenManifestLeafAttributes(legacyManifest.attributes ?? {}).map((descriptor) => [
-    descriptor.currentPath,
-    descriptor
-  ]));
-  const currentLeafDescriptors = flattenManifestLeafAttributes(currentManifest.attributes ?? {});
-  const autoRenameMap = new Map(diff.summary.renameCandidates.filter((candidate) => candidate.autoApply).map((candidate) => [candidate.currentPath, candidate.legacyPath]));
-  const blockedPaths = unique([
-    ...diff.summary.manualItems.map((item) => item.path),
-    ...diff.summary.transformSuggestions.map((item) => item.currentPath),
-    ...diff.summary.renameCandidates.filter((candidate) => !candidate.autoApply).map((candidate) => candidate.currentPath)
-  ]);
-  const compatibleMappings = [];
-  for (const descriptor of currentLeafDescriptors) {
-    const currentPath = descriptor.currentPath;
-    if (isBlockedPath(currentPath, blockedPaths)) {
-      continue;
-    }
-    const legacyPath = autoRenameMap.get(currentPath) ?? currentPath;
-    const legacyDescriptor = legacyLeafMap.get(legacyPath);
-    if (!legacyDescriptor) {
-      continue;
-    }
-    if (legacyDescriptor.attribute.ts.kind !== descriptor.attribute.ts.kind) {
-      continue;
-    }
-    if (!["string", "number", "boolean"].includes(descriptor.attribute.ts.kind)) {
-      continue;
-    }
-    compatibleMappings.push({
-      currentPath,
-      legacyPath
-    });
-  }
-  return {
-    blockedPaths,
-    compatibleMappings
-  };
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-render-diff-rule.ts
-import path3 from "path";
-
-// ../wp-typia-project-tools/src/runtime/migration-risk.ts
-function createRiskBucket(items) {
-  return {
-    count: items.length,
-    items
-  };
-}
-function formatDiffOutcome(item) {
-  return `${item.path}: ${item.kind}${item.detail ? ` (${item.detail})` : ""}`;
-}
-function formatRenameCandidate(candidate) {
-  return `${candidate.currentPath} <- ${candidate.legacyPath} (${candidate.autoApply ? "auto" : "review"}, ${candidate.reason})`;
-}
-function formatTransformSuggestion(suggestion) {
-  return `${suggestion.currentPath}${suggestion.legacyPath ? ` <- ${suggestion.legacyPath}` : ""} (${suggestion.reason})`;
-}
-function unique2(items) {
-  return [...new Set(items)];
-}
-function formatMigrationRiskSummary(summary) {
-  return `additive=${summary.additive.count}, rename=${summary.rename.count}, semanticTransform=${summary.semanticTransform.count}, unionBreaking=${summary.unionBreaking.count}`;
-}
-function createMigrationRiskSummary(diff) {
-  const additiveKinds = new Set([
-    "add-default",
-    "add-optional",
-    "drop",
-    "hydrate",
-    "union-branch-addition"
-  ]);
-  const additiveItems = unique2(diff.summary.autoItems.filter((item) => additiveKinds.has(item.kind)).map(formatDiffOutcome));
-  const renameItems = unique2(diff.summary.renameCandidates.map(formatRenameCandidate));
-  const semanticTransformItems = unique2(diff.summary.transformSuggestions.map(formatTransformSuggestion));
-  const unionBreakingItems = unique2(diff.summary.manualItems.filter((item) => item.kind.startsWith("union-")).map(formatDiffOutcome));
-  return {
-    additive: createRiskBucket(additiveItems),
-    rename: createRiskBucket(renameItems),
-    semanticTransform: createRiskBucket(semanticTransformItems),
-    unionBreaking: createRiskBucket(unionBreakingItems)
-  };
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-render-support.ts
-import path2 from "path";
-function normalizeImportPath(relativePath, stripExtension = false) {
-  let nextPath = relativePath.replace(/\\/g, "/");
-  if (!nextPath.startsWith(".")) {
-    nextPath = `./${nextPath}`;
-  }
-  if (stripExtension) {
-    nextPath = nextPath.replace(/\.[^.]+$/u, "");
-  }
-  return nextPath;
-}
-function getGeneratedDir(block, state) {
-  return block.layout === "legacy" ? state.paths.generatedDir : path2.join(state.paths.generatedDir, block.key);
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-render-diff-rule.ts
-function formatDiffReport(diff, { includeRiskSummary = true } = {}) {
-  const lines = [
-    `Migration diff: ${diff.fromVersion} -> ${diff.toVersion}`,
-    `Current type: ${diff.currentTypeName}`,
-    `Safe changes: ${diff.summary.auto}`,
-    `Manual changes: ${diff.summary.manual}`
-  ];
-  if (diff.summary.autoItems.length > 0) {
-    lines.push("", "Safe changes:");
-    for (const item of diff.summary.autoItems) {
-      lines.push(`  - ${item.path}: ${item.kind}${item.detail ? ` (${item.detail})` : ""}`);
-    }
-  }
-  if (diff.summary.manualItems.length > 0) {
-    lines.push("", "Manual review required:");
-    for (const item of diff.summary.manualItems) {
-      lines.push(`  - ${item.path}: ${item.kind}${item.detail ? ` (${item.detail})` : ""}`);
-    }
-  }
-  if (diff.summary.renameCandidates.length > 0) {
-    const autoApplied = diff.summary.renameCandidates.filter((item) => item.autoApply);
-    const suggested = diff.summary.renameCandidates.filter((item) => !item.autoApply);
-    if (autoApplied.length > 0) {
-      lines.push("", "Auto-applied renames:");
-      for (const item of autoApplied) {
-        lines.push(`  - ${item.currentPath} <- ${item.legacyPath} (${item.reason}, score ${item.score.toFixed(2)})`);
-      }
-    }
-    if (suggested.length > 0) {
-      lines.push("", "Suggested renames:");
-      for (const item of suggested) {
-        lines.push(`  - ${item.currentPath} <- ${item.legacyPath} (${item.reason}, score ${item.score.toFixed(2)})`);
-      }
-    }
-  }
-  if (diff.summary.transformSuggestions.length > 0) {
-    lines.push("", "Suggested transforms:");
-    for (const item of diff.summary.transformSuggestions) {
-      lines.push(`  - ${item.currentPath}${item.legacyPath ? ` <- ${item.legacyPath}` : ""} (${item.reason})`);
-    }
-  }
-  if (includeRiskSummary) {
-    lines.push("", `Risk summary: ${formatMigrationRiskSummary(createMigrationRiskSummary(diff))}`);
-  }
-  return lines.join(`
-`);
-}
-function renderMigrationRuleFile({
-  block,
-  currentAttributes,
-  currentTypeName,
-  diff,
-  fromVersion,
-  projectDir,
-  rulePath,
-  targetVersion
-}) {
-  const activeRenameCandidates = diff.summary.renameCandidates.filter((candidate) => candidate.autoApply);
-  const suggestedRenameCandidates = diff.summary.renameCandidates.filter((candidate) => !candidate.autoApply);
-  const lines = [];
-  const ruleDir = path3.dirname(rulePath);
-  const typesImport = normalizeImportPath(path3.relative(ruleDir, path3.join(projectDir, block.typesFile)));
-  const currentManifestImport = normalizeImportPath(path3.relative(ruleDir, path3.join(projectDir, block.manifestFile)));
-  const helpersImport = normalizeImportPath(path3.relative(ruleDir, path3.join(projectDir, "src", "migrations", "helpers.ts")), true);
-  lines.push(`import type { ${currentTypeName} } from "${typesImport}";`);
-  lines.push(`import currentManifest from "${currentManifestImport}";`);
-  lines.push(`import {`);
-  lines.push(`	type RenameMap,`);
-  lines.push(`	type TransformMap,`);
-  lines.push(`	resolveMigrationAttribute,`);
-  lines.push(`} from "${helpersImport}";`);
-  lines.push("");
-  lines.push(`export const fromVersion = "${fromVersion}" as const;`);
-  lines.push(`export const toVersion = "${targetVersion}" as const;`);
-  lines.push("");
-  lines.push("export const renameMap: RenameMap = {");
-  for (const candidate of activeRenameCandidates) {
-    lines.push(`	${renderObjectKey(candidate.currentPath)}: "${escapeForCode(candidate.legacyPath)}",`);
-  }
-  for (const candidate of suggestedRenameCandidates) {
-    lines.push(`	// ${renderObjectKey(candidate.currentPath)}: "${escapeForCode(candidate.legacyPath)}",`);
-  }
-  lines.push("};");
-  lines.push("");
-  lines.push("export const transforms: TransformMap = {");
-  for (const suggestion of diff.summary.transformSuggestions) {
-    lines.push(`	// ${renderObjectKey(suggestion.currentPath)}: (legacyValue, legacyInput) => {`);
-    for (const bodyLine of suggestion.bodyLines) {
-      lines.push(`	${bodyLine}`);
-    }
-    lines.push(`	// },`);
-  }
-  lines.push("};");
-  lines.push("");
-  lines.push("export const unresolved = [");
-  for (const item of diff.summary.manualItems) {
-    lines.push(`	"${item.path}: ${item.kind}${item.detail ? ` (${escapeForCode(item.detail)})` : ""}",`);
-  }
-  for (const candidate of suggestedRenameCandidates) {
-    lines.push(`	"${candidate.currentPath}: rename candidate from ${candidate.legacyPath}",`);
-  }
-  for (const suggestion of diff.summary.transformSuggestions) {
-    lines.push(`	"${suggestion.currentPath}: transform suggested from ${suggestion.legacyPath ?? suggestion.currentPath}",`);
-  }
-  lines.push("] as const;");
-  lines.push("");
-  lines.push(`export function migrate(input: Record<string, unknown>): ${currentTypeName} {`);
-  lines.push(`	return {`);
-  for (const key of Object.keys(currentAttributes)) {
-    for (const manualItem of diff.summary.manualItems.filter((item) => item.path === key || item.path.startsWith(`${key}.`))) {
-      lines.push(`		// ${MIGRATION_TODO_PREFIX} ${manualItem.path}: ${manualItem.kind}${manualItem.detail ? ` (${manualItem.detail})` : ""}`);
-    }
-    for (const renameCandidate of suggestedRenameCandidates.filter((item) => item.currentPath === key || item.currentPath.startsWith(`${key}.`))) {
-      lines.push(`		// ${MIGRATION_TODO_PREFIX} consider renameMap[${JSON.stringify(renameCandidate.currentPath)}] = "${renameCandidate.legacyPath}"`);
-    }
-    for (const suggestion of diff.summary.transformSuggestions.filter((item) => item.currentPath === key || item.currentPath.startsWith(`${key}.`))) {
-      lines.push(`		// ${MIGRATION_TODO_PREFIX} review transforms[${JSON.stringify(suggestion.currentPath)}]`);
-    }
-    lines.push(`		${key}: resolveMigrationAttribute(currentManifest.attributes.${key}, "${key}", "${key}", input, renameMap, transforms),`);
-  }
-  lines.push(`	} as ${currentTypeName};`);
-  lines.push("}");
-  lines.push("");
-  return `${lines.join(`
-`)}
-`;
-}
-// ../wp-typia-project-tools/src/runtime/migration-render-generated.ts
-import fs3 from "fs";
-import path4 from "path";
-function renderMigrationRegistryFile(state, blockKey, entries) {
-  const block = state.blocks.find((entry) => entry.key === blockKey);
-  if (!block) {
-    throw new Error(`Unknown migration block target: ${blockKey}`);
-  }
-  const generatedDir = getGeneratedDir(block, state);
-  const currentManifestWrapperCandidates = [
-    block.manifestFile.replace(/typia\.manifest\.json$/u, "manifest-document.ts"),
-    path4.join(path4.dirname(block.typesFile), "manifest-document.ts")
-  ].filter((candidate, index, allCandidates) => candidate !== block.manifestFile && allCandidates.indexOf(candidate) === index);
-  const currentManifestWrapperFile = currentManifestWrapperCandidates.find((candidate) => fs3.existsSync(path4.join(state.projectDir, candidate))) ?? null;
-  const currentManifestSourceFile = currentManifestWrapperFile ?? block.manifestFile;
-  const currentManifestImport = normalizeImportPath(path4.relative(generatedDir, path4.join(state.projectDir, currentManifestSourceFile)), currentManifestWrapperFile !== null);
-  const imports = [
-    `import rawCurrentManifest from "${currentManifestImport}";`,
-    `import type { ManifestDocument, MigrationRiskSummary } from "${normalizeImportPath(path4.relative(getGeneratedDir(block, state), path4.join(state.projectDir, "src", "migrations", "helpers.ts")), true)}";`,
-    `import { parseManifestDocument } from "@wp-typia/block-runtime/editor";`
-  ];
-  const body = [];
-  entries.forEach(({ entry, riskSummary }, index) => {
-    imports.push(`import manifest_${index} from "${entry.manifestImport}";`);
-    imports.push(`import * as rule_${index} from "${entry.ruleImport}";`);
-    body.push(`	{`);
-    body.push(`		fromMigrationVersion: "${entry.fromVersion}",`);
-    body.push(`		manifest: parseManifestDocument<ManifestDocument>(manifest_${index}),`);
-    body.push(`		riskSummary: ${JSON.stringify(riskSummary, null, "\t").replace(/\n/g, `
-		`)},`);
-    body.push(`		rule: rule_${index},`);
-    body.push(`	},`);
-  });
-  return `/* eslint-disable prettier/prettier, @typescript-eslint/method-signature-style */
-${imports.join(`
-`)}
-
-interface MigrationRegistryEntry {
-	fromMigrationVersion: string;
-	manifest: ManifestDocument;
-	riskSummary: MigrationRiskSummary;
-	rule: {
-		migrate(input: Record<string, unknown>): Record<string, unknown>;
-		unresolved?: readonly string[];
-	};
-}
-
-export const migrationRegistry: {
-	currentMigrationVersion: string;
-	currentManifest: ManifestDocument;
-	entries: MigrationRegistryEntry[];
-} = {
-	currentMigrationVersion: "${state.config.currentMigrationVersion}",
-	currentManifest: parseManifestDocument<ManifestDocument>(rawCurrentManifest),
-	entries: [
-${body.join(`
-`)}
-	],
-};
-
-export default migrationRegistry;
-`;
-}
-function renderGeneratedDeprecatedFile(state, blockKey, entries) {
-  const block = state.blocks.find((entry) => entry.key === blockKey);
-  if (!block) {
-    throw new Error(`Unknown migration block target: ${blockKey}`);
-  }
-  const currentTypeName = typeof block.currentManifest.sourceType === "string" && block.currentManifest.sourceType.length > 0 ? block.currentManifest.sourceType : "Record<string, unknown>";
-  const hasNamedCurrentType = currentTypeName !== "Record<string, unknown>";
-  const generatedDir = getGeneratedDir(block, state);
-  const typesImport = normalizeImportPath(path4.relative(generatedDir, path4.join(state.projectDir, block.typesFile)), true);
-  if (entries.length === 0) {
-    return `/* eslint-disable prettier/prettier */
-import type { BlockDeprecationList } from "@wp-typia/block-types/blocks/registration";
-${hasNamedCurrentType ? `import type { ${currentTypeName} } from "${typesImport}";
-` : ""}
-
-export const deprecated: BlockDeprecationList<${currentTypeName}> = [];
-`;
-  }
-  const imports = [
-    `import type { BlockConfiguration, BlockDeprecationList } from "@wp-typia/block-types/blocks/registration";`,
-    ...hasNamedCurrentType ? [`import type { ${currentTypeName} } from "${typesImport}";`] : []
-  ];
-  const definitions = [];
-  const arrayEntries = [];
-  entries.forEach((entry, index) => {
-    imports.push(`import block_${index} from "${entry.blockJsonImport}";`);
-    imports.push(`import save_${index} from "${entry.saveImport}";`);
-    imports.push(`import * as rule_${index} from "${entry.ruleImport}";`);
-    definitions.push(`const deprecated_${index}: BlockDeprecationList<${currentTypeName}>[number] = {`);
-    definitions.push(`	attributes: (block_${index}.attributes ?? {}) as BlockConfiguration["attributes"],`);
-    definitions.push(`	save: save_${index} as BlockConfiguration["save"],`);
-    definitions.push(`	migrate(attributes: Record<string, unknown>) {`);
-    definitions.push(`		return rule_${index}.migrate(attributes);`);
-    definitions.push(`	},`);
-    definitions.push(`};`);
-    arrayEntries.push(`deprecated_${index}`);
-  });
-  return `/* eslint-disable prettier/prettier */
-${imports.join(`
-`)}
-
-${definitions.join(`
-
-`)}
-
-export const deprecated: BlockDeprecationList<${currentTypeName}> = [${arrayEntries.join(", ")}];
-`;
-}
-function renderGeneratedMigrationIndexFile(state, entries) {
-  if (state.blocks.length === 0) {
-    return `export const migrationBlocks = [] as const;
-export default migrationBlocks;
-`;
-  }
-  const generatedDir = state.paths.generatedDir;
-  const imports = [];
-  const definitions = [];
-  state.blocks.forEach((block, index) => {
-    const scopedEntries = entries.filter((entry) => entry.block.key === block.key);
-    const registryImport = block.layout === "legacy" ? "./registry" : `./${block.key}/registry`;
-    const deprecatedImport = block.layout === "legacy" ? "./deprecated" : `./${block.key}/deprecated`;
-    const validatorsImport = normalizeImportPath(path4.relative(generatedDir, path4.join(state.projectDir, block.typesFile.replace(/types\.ts$/u, "validators.ts"))), true);
-    imports.push(`import registry_${index} from "${registryImport}";`);
-    imports.push(`import { deprecated as deprecated_${index} } from "${deprecatedImport}";`);
-    imports.push(`import { validators as validators_${index} } from "${validatorsImport}";`);
-    definitions.push(`	{`);
-    definitions.push(`		key: "${block.key}",`);
-    definitions.push(`		blockName: "${block.blockName}",`);
-    definitions.push(`		registry: registry_${index},`);
-    definitions.push(`		deprecated: deprecated_${index},`);
-    definitions.push(`		validators: validators_${index},`);
-    definitions.push(`		legacyMigrationVersions: ${JSON.stringify(scopedEntries.map((entry) => entry.fromVersion))},`);
-    definitions.push(`	},`);
-  });
-  return `/* eslint-disable prettier/prettier */
-${imports.join(`
-`)}
-
-export const migrationBlocks = [
-${definitions.join(`
-`)}
-] as const;
-
-export default migrationBlocks;
-`;
-}
-function renderPhpMigrationRegistryFile(state, entries) {
-  const blocks = state.blocks.map((block) => {
-    const snapshots = Object.fromEntries(state.config.supportedMigrationVersions.map((version) => {
-      const manifestPath = getSnapshotManifestPath(state.projectDir, block, version);
-      const blockJsonPath = getSnapshotBlockJsonPath(state.projectDir, block, version);
-      const savePath = getSnapshotSavePath(state.projectDir, block, version);
-      return [
-        version,
-        {
-          blockJson: fs3.existsSync(blockJsonPath) ? {
-            attributeNames: Object.keys(readJson(blockJsonPath).attributes ?? {}),
-            name: readJson(blockJsonPath).name ?? null
-          } : null,
-          hasSaveSnapshot: fs3.existsSync(savePath),
-          manifest: fs3.existsSync(manifestPath) ? summarizeManifest(readJson(manifestPath)) : null
-        }
-      ];
-    }));
-    const edgeSummaries = entries.filter((entry) => entry.block.key === block.key).map((entry) => {
-      const ruleMetadata = readRuleMetadata(entry.rulePath);
-      const snapshotManifest = snapshots[entry.fromVersion]?.manifest ?? null;
-      return {
-        autoAppliedRenameCount: ruleMetadata.renameMap.length,
-        autoAppliedRenames: ruleMetadata.renameMap,
-        fromMigrationVersion: entry.fromVersion,
-        nestedPathRenames: ruleMetadata.renameMap.filter((item) => item.currentPath.includes(".")),
-        ruleFile: path4.relative(state.projectDir, entry.rulePath).replace(/\\/g, "/"),
-        toMigrationVersion: entry.toVersion,
-        transformKeys: ruleMetadata.transforms,
-        unionBranches: snapshotManifest ? summarizeUnionBranches(snapshotManifest) : [],
-        unresolved: ruleMetadata.unresolved
-      };
-    });
-    return {
-      blockName: block.blockName,
-      currentManifest: summarizeManifest(block.currentManifest),
-      edges: edgeSummaries,
-      key: block.key,
-      legacyMigrationVersions: state.config.supportedMigrationVersions.filter((version) => version !== state.config.currentMigrationVersion),
-      snapshots
-    };
-  });
-  return `<?php
-declare(strict_types=1);
-
-if ( ! defined( 'ABSPATH' ) ) {
-	exit;
-}
-
-/**
- * Generated from advanced migration snapshots. Do not edit manually.
- */
-return ${renderPhpValue({
-    currentMigrationVersion: state.config.currentMigrationVersion,
-    blocks,
-    snapshotDir: state.config.snapshotDir,
-    supportedMigrationVersions: state.config.supportedMigrationVersions
-  }, 0)};
-`;
-}
-// ../wp-typia-project-tools/src/runtime/migration-render-execution.ts
-function renderVerifyFile(state, blockKey, entries) {
-  const block = state.blocks.find((entry) => entry.key === blockKey);
-  if (!block) {
-    throw new Error(`Unknown migration block target: ${blockKey}`);
-  }
-  if (entries.length === 0) {
-    return `/* eslint-disable no-console */
-console.log(
-	'Run \`wp-typia migrate scaffold --from-migration-version <label>\` before verify.'
-);
-`;
-  }
-  const imports = [
-    `import { validators } from "${entries[0]?.validatorImport ?? "./validators"}";`,
-    `import { deprecated } from "./deprecated";`
-  ];
-  const checks = [];
-  entries.forEach((entry, index) => {
-    imports.push(`import fixture_${index} from "${entry.fixtureImport}";`);
-    imports.push(`import * as rule_${index} from "${entry.ruleImport}";`);
-    checks.push(`	if (selectedMigrationVersions.length === 0 || selectedMigrationVersions.includes("${entry.fromVersion}")) {`);
-    checks.push(`		if (rule_${index}.unresolved.length > 0) {`);
-    checks.push(`			throw new Error("Unresolved migration TODOs remain for ${entry.fromVersion} -> ${entry.toVersion}: " + rule_${index}.unresolved.join(", "));`);
-    checks.push(`		}`);
-    checks.push(`		const cases_${index} = Array.isArray(fixture_${index}.cases) ? fixture_${index}.cases : [];`);
-    checks.push(`		for (const fixtureCase of cases_${index}) {`);
-    checks.push(`			const migrated_${index} = rule_${index}.migrate(fixtureCase.input ?? {});`);
-    checks.push(`			const validation_${index} = validators.validate(migrated_${index});`);
-    checks.push(`			if (!isValidationSuccess(validation_${index})) {`);
-    checks.push(`				throw new Error("Current validator rejected migrated fixture for ${entry.fromVersion} case " + String(fixtureCase.name ?? "unknown") + ": " + JSON.stringify(getValidationErrors(validation_${index})));`);
-    checks.push(`			}`);
-    checks.push(`		}`);
-    checks.push(`		console.log("Verified ${entry.fromVersion} -> ${entry.toVersion} (" + cases_${index}.length + " case(s))");`);
-    checks.push(`	}`);
-  });
-  return `/* eslint-disable prettier/prettier, no-console, @typescript-eslint/no-unused-vars, no-nested-ternary */
-${imports.join(`
-`)}
-
-function isValidationSuccess(result: unknown): boolean {
-	return (
-		result !== null &&
-		typeof result === "object" &&
-		(
-			(result as { isValid?: unknown }).isValid === true ||
-			(result as { success?: unknown }).success === true
-		)
-	);
-}
-
-function getValidationErrors(result: unknown): unknown[] {
-	if (result !== null && typeof result === "object" && Array.isArray((result as { errors?: unknown[] }).errors)) {
-		return (result as { errors: unknown[] }).errors;
-	}
-
-	return [];
-}
-
-const args = process.argv.slice(2);
-const selectedMigrationVersions =
-	args[0] === "--all"
-		? []
-		: args[0] === "--from-migration-version" && args[1]
-			? [args[1]]
-			: [];
-
-if (deprecated.length !== ${entries.length}) {
-	throw new Error("Generated deprecated entries are out of sync with migration registry.");
-}
-
-${checks.join(`
-`)}
-
-console.log("Migration verification passed for ${block.blockName}");
-`;
-}
-function renderFuzzFile(state, blockKey, entries) {
-  const block = state.blocks.find((entry) => entry.key === blockKey);
-  if (!block) {
-    throw new Error(`Unknown migration block target: ${blockKey}`);
-  }
-  if (entries.length === 0) {
-    return `/* eslint-disable no-console */
-console.log(
-	'Run \`wp-typia migrate scaffold --from-migration-version <label>\` before fuzz.'
-);
-`;
-  }
-  const imports = [
-    `import { validators } from "${entries[0]?.entry.validatorImport ?? "./validators"}";`
-  ];
-  const edgeDefinitions = [];
-  entries.forEach(({ entry, fuzzPlan }, index) => {
-    imports.push(`import fixture_${index} from "${entry.fixtureImport}";`);
-    imports.push(`import manifest_${index} from "${entry.manifestImport}";`);
-    imports.push(`import * as rule_${index} from "${entry.ruleImport}";`);
-    edgeDefinitions.push(`{
-	fromMigrationVersion: "${entry.fromVersion}",
-	toMigrationVersion: "${entry.toVersion}",
-	fixture: fixture_${index},
-	legacyManifest: manifest_${index},
-	rule: rule_${index},
-	plan: ${JSON.stringify(fuzzPlan, null, "\t").replace(/\n/g, `
-	`)},
-}`);
-  });
-  return `/* eslint-disable prettier/prettier, no-console, no-bitwise, @typescript-eslint/no-unused-vars, no-nested-ternary, @typescript-eslint/method-signature-style */
-${imports.join(`
-`)}
-
-type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };
-
-type ManifestAttribute = {
-	typia?: {
-		defaultValue?: JsonValue | null;
-		hasDefault?: boolean;
-	};
-	ts?: {
-		items?: ManifestAttribute | null;
-		kind?: string | null;
-		properties?: Record<string, ManifestAttribute> | null;
-		union?: {
-			branches?: Record<string, ManifestAttribute> | null;
-			discriminator?: string | null;
-		} | null;
-	} | null;
-	wp?: {
-		defaultValue?: JsonValue | null;
-		enum?: JsonValue[] | null;
-		hasDefault?: boolean;
-	} | null;
-};
-
-type ManifestDocument = {
-	attributes?: Record<string, ManifestAttribute>;
-};
-
-type FixtureDocument = {
-	cases?: Array<{ input?: Record<string, unknown>; name?: string }>;
-};
-
-type FuzzEdge = {
-	fixture: FixtureDocument;
-	fromMigrationVersion: string;
-	legacyManifest: ManifestDocument;
-	plan: {
-		blockedPaths: string[];
-		compatibleMappings: Array<{ currentPath: string; legacyPath: string }>;
-	};
-	rule: {
-		migrate(input: Record<string, unknown>): Record<string, unknown>;
-	};
-	toMigrationVersion: string;
-};
-
-const edges: FuzzEdge[] = [
-${edgeDefinitions.join(`,
-`)}
-];
-
-function cloneJsonValue<T>(value: T): T {
-	return JSON.parse(JSON.stringify(value));
-}
-
-function getValueAtPath(input: Record<string, unknown>, pathLabel: string): unknown {
-	return String(pathLabel)
-		.split(".")
-		.reduce<unknown>(
-			(value, segment) => (value && typeof value === "object" ? (value as Record<string, unknown>)[segment] : undefined),
-			input,
-		);
-}
-
-function setValueAtPath(input: Record<string, unknown>, pathLabel: string, value: unknown): void {
-	const segments = String(pathLabel).split(".").filter(Boolean);
-	if (segments.length === 0) {
-		return;
-	}
-
-	let target: Record<string, unknown> = input;
-	while (segments.length > 1) {
-		const segment = segments.shift();
-		if (!segment) {
-			continue;
-		}
-		if (!target[segment] || typeof target[segment] !== "object" || Array.isArray(target[segment])) {
-			target[segment] = {};
-		}
-		target = target[segment];
-	}
-
-	target[segments[0]!] = value;
-}
-
-function createDefaultValue(attribute: ManifestAttribute): JsonValue | Record<string, JsonValue> | null {
-	if (attribute?.typia?.hasDefault) {
-		return cloneJsonValue(attribute.typia.defaultValue ?? null);
-	}
-	if (attribute?.wp?.hasDefault) {
-		return cloneJsonValue(attribute.wp.defaultValue ?? null);
-	}
-	if (Array.isArray(attribute?.wp?.enum) && attribute.wp.enum.length > 0) {
-		return cloneJsonValue(attribute.wp.enum[0] ?? null);
-	}
-
-	switch (attribute?.ts?.kind) {
-		case "string":
-			return "";
-		case "number":
-			return 0;
-		case "boolean":
-			return false;
-		case "array":
-			return [];
-		case "object":
-			return Object.fromEntries(
-				Object.entries(attribute?.ts?.properties ?? {}).map(([key, property]) => [
-					key,
-					createDefaultValue(property),
-				]),
-			);
-		case "union": {
-			const firstBranch = Object.values(attribute?.ts?.union?.branches ?? {})[0];
-			return firstBranch ? createDefaultValue(firstBranch) : null;
-		}
-		default:
-			return null;
-	}
-}
-
-function createDefaultInput(manifest: ManifestDocument): Record<string, unknown> {
-	return Object.fromEntries(
-		Object.entries(manifest?.attributes ?? {}).map(([key, attribute]) => [key, createDefaultValue(attribute)]),
-	);
-}
-
-function isValidationSuccess(result: unknown): boolean {
-	const typedResult =
-		result !== null && typeof result === "object"
-			? (result as { isValid?: unknown; success?: unknown })
-			: null;
-
-	return (
-		typedResult !== null &&
-		(
-			typedResult.isValid === true ||
-			typedResult.success === true
-		)
-	);
-}
-
-function getValidationErrors(result: unknown): unknown[] {
-	if (
-		result !== null &&
-		typeof result === "object" &&
-		Array.isArray((result as { errors?: unknown[] }).errors)
-	) {
-		return (result as { errors: unknown[] }).errors;
-	}
-
-	return [];
-}
-
-function createSeededRandom(seed: number): () => number {
-	let state = seed >>> 0;
-	return () => {
-		state = (state * 1664525 + 1013904223) >>> 0;
-		return state / 4294967296;
-	};
-}
-
-function withSeededRandom<T>(seed: number, callback: () => T): T {
-	const originalRandom = Math.random;
-	Math.random = createSeededRandom(seed);
-	try {
-		return callback();
-	} finally {
-		Math.random = originalRandom;
-	}
-}
-
-function parseArgs(argv: string[]): {
-	all: boolean;
-	fromMigrationVersion?: string;
-	iterations: number;
-	seed?: number;
-} {
-	let all = false;
-	let fromMigrationVersion: string | undefined;
-	let iterations = 25;
-	let seed: number | undefined;
-
-	for (let index = 0; index < argv.length; index += 1) {
-		const arg = argv[index];
-		const next = argv[index + 1];
-
-		if (arg === "--all") {
-			all = true;
-			continue;
-		}
-		if (arg === "--from-migration-version") {
-			fromMigrationVersion = next;
-			index += 1;
-			continue;
-		}
-		if (arg === "--iterations") {
-			iterations = Number.parseInt(next ?? "", 10) || 25;
-			index += 1;
-			continue;
-		}
-		if (arg === "--seed") {
-			seed = Number.parseInt(next ?? "", 10);
-			index += 1;
-		}
-	}
-
-	return { all, fromMigrationVersion, iterations, seed };
-}
-
-function applyCompatibleMappings(
-	baseInput: Record<string, unknown>,
-	currentSample: Record<string, unknown>,
-	mappings: Array<{ currentPath: string; legacyPath: string }>,
-): Record<string, unknown> {
-	for (const mapping of mappings) {
-		const value = getValueAtPath(currentSample, mapping.currentPath);
-		if (value !== undefined) {
-			setValueAtPath(baseInput, mapping.legacyPath, cloneJsonValue(value));
-		}
-	}
-	return baseInput;
-}
-
-function assertValidMigration(
-	edge: FuzzEdge,
-	candidateInput: Record<string, unknown>,
-	migratedOutput: Record<string, unknown>,
-	validation: unknown,
-	iterationSeed: number,
-	iteration: number | string,
-): void {
-	if (isValidationSuccess(validation)) {
-		return;
-	}
-
-	throw new Error(
-		"Migration fuzz failed for " +
-			edge.fromMigrationVersion +
-			" -> " +
-			edge.toMigrationVersion +
-			" (seed " +
-			String(iterationSeed) +
-			", iteration " +
-			String(iteration) +
-			"): " +
-			JSON.stringify({
-				input: candidateInput,
-				migrated: migratedOutput,
-				errors: getValidationErrors(validation),
-			}),
-		);
-}
-
-const parsed = parseArgs(process.argv.slice(2));
-const selectedMigrationVersions = parsed.all
-	? []
-	: parsed.fromMigrationVersion
-		? [parsed.fromMigrationVersion]
-		: edges.map((edge) => edge.fromMigrationVersion);
-const baseSeed = typeof parsed.seed === "number" ? parsed.seed : Date.now();
-
-if (!Number.isInteger(parsed.seed)) {
-	console.log("Using migration fuzz seed " + String(baseSeed));
-}
-
-if (edges.length === 0) {
-	console.log("No legacy migration versions configured for migration fuzzing.");
-	process.exit(0);
-}
-
-let executedEdges = 0;
-
-for (const [edgeIndex, edge] of edges.entries()) {
-	if (selectedMigrationVersions.length > 0 && !selectedMigrationVersions.includes(edge.fromMigrationVersion)) {
-		continue;
-	}
-
-	executedEdges += 1;
-
-	const fixtureCases = Array.isArray(edge.fixture?.cases) ? edge.fixture.cases : [];
-	for (const fixtureCase of fixtureCases) {
-		const migrated = edge.rule.migrate(fixtureCase.input ?? {});
-		const validation = validators.validate(migrated);
-		assertValidMigration(edge, fixtureCase.input ?? {}, migrated, validation, baseSeed, fixtureCase.name ?? "fixture");
-	}
-
-	for (let iteration = 0; iteration < parsed.iterations; iteration += 1) {
-		const iterationSeed = (baseSeed + edgeIndex * 100003 + iteration) >>> 0;
-		const currentSample = withSeededRandom(iterationSeed, () => validators.random());
-		const baseFixture = fixtureCases.find((fixtureCase) => fixtureCase.name === "default")?.input;
-		const legacyInput = applyCompatibleMappings(
-			cloneJsonValue(baseFixture ?? createDefaultInput(edge.legacyManifest)),
-			currentSample,
-			edge.plan.compatibleMappings,
-		);
-		const migrated = edge.rule.migrate(legacyInput);
-		const validation = validators.validate(migrated);
-		assertValidMigration(edge, legacyInput, migrated, validation, iterationSeed, iteration);
-	}
-
-	console.log(
-		"Fuzzed " +
-			edge.fromMigrationVersion +
-			" -> " +
-			edge.toMigrationVersion +
-			" (" +
-			String(fixtureCases.length) +
-			" fixture case(s), " +
-			String(parsed.iterations) +
-			" fuzz iteration(s))",
-	);
-}
-
-if (selectedMigrationVersions.length > 0 && executedEdges === 0) {
-	throw new Error(
-		"Requested migration version was not exercised by fuzz: " +
-			selectedMigrationVersions.join(", "),
-	);
-}
-
-console.log("Migration fuzzing passed for ${block.blockName}");
-`;
-}
-// ../wp-typia-project-tools/src/runtime/migration-generated-artifacts.ts
-function collectGeneratedMigrationEntries(state) {
-  return discoverMigrationEntries(state).map((entry) => {
-    const block = state.blocks.find((target) => target.key === entry.block.key);
-    if (!block) {
-      throw new Error(`Unknown migration block target: ${entry.block.key}`);
-    }
-    const diff = createMigrationDiff(state, entry.block, entry.fromVersion, entry.toVersion);
-    const legacyManifest = readJson(getSnapshotManifestPath(state.projectDir, entry.block, entry.fromVersion));
-    return {
-      diff,
-      entry,
-      fuzzPlan: createMigrationFuzzPlan(legacyManifest, block.currentManifest, diff),
-      riskSummary: createMigrationRiskSummary(diff)
-    };
-  });
-}
-function regenerateGeneratedArtifacts(projectDir) {
-  const state = loadMigrationProject(projectDir);
-  const generatedEntries = collectGeneratedMigrationEntries(state);
-  for (const block of state.blocks) {
-    const blockGeneratedEntries = generatedEntries.filter(({ entry }) => entry.block.key === block.key);
-    const entries = blockGeneratedEntries.map(({ entry }) => entry);
-    const generatedDir = getGeneratedDirForBlock(state.paths, block);
-    fs4.mkdirSync(generatedDir, { recursive: true });
-    fs4.writeFileSync(path5.join(generatedDir, "registry.ts"), renderMigrationRegistryFile(state, block.key, blockGeneratedEntries), "utf8");
-    fs4.writeFileSync(path5.join(generatedDir, "deprecated.ts"), renderGeneratedDeprecatedFile(state, block.key, entries), "utf8");
-    fs4.writeFileSync(path5.join(generatedDir, "verify.ts"), renderVerifyFile(state, block.key, entries), "utf8");
-    fs4.writeFileSync(path5.join(generatedDir, "fuzz.ts"), renderFuzzFile(state, block.key, blockGeneratedEntries), "utf8");
-  }
-  fs4.writeFileSync(path5.join(state.paths.generatedDir, "index.ts"), renderGeneratedMigrationIndexFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
-  fs4.writeFileSync(path5.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-planning.ts
-import fs5 from "fs";
-function hasSnapshotForVersion(state, block, version) {
-  return fs5.existsSync(getSnapshotManifestPath(state.projectDir, block, version));
-}
-function listConfiguredLegacyVersions(state) {
-  return state.config.supportedMigrationVersions.filter((version) => version !== state.config.currentMigrationVersion).sort(compareMigrationVersionLabels);
-}
-function listPreviewableLegacyVersions(state) {
-  return [
-    ...new Set(state.blocks.flatMap((block) => getAvailableSnapshotVersionsForBlock(state.projectDir, state.config.supportedMigrationVersions, block)))
-  ].filter((version) => version !== state.config.currentMigrationVersion).sort(compareMigrationVersionLabels);
-}
-function resolveLegacyVersions(state, {
-  all = false,
-  availableVersions,
-  fromMigrationVersion
-}) {
-  const configuredLegacyVersions = listConfiguredLegacyVersions(state);
-  const legacyVersions = availableVersions ?? configuredLegacyVersions;
-  if (fromMigrationVersion) {
-    if (!legacyVersions.includes(fromMigrationVersion)) {
-      throw new Error(legacyVersions.length === 0 ? availableVersions && configuredLegacyVersions.length > 0 ? `Unsupported migration version: ${fromMigrationVersion}. No previewable legacy migration versions are available yet because none currently have snapshot coverage. ` + `Restore or recapture the missing snapshots first.` : `Unsupported migration version: ${fromMigrationVersion}. No legacy migration versions are configured yet. ` + `Capture an older schema release with \`wp-typia migrate snapshot --migration-version <label>\` first.` : `Unsupported migration version: ${fromMigrationVersion}. Available legacy migration versions: ${legacyVersions.join(", ")}.`);
-    }
-    return [fromMigrationVersion];
-  }
-  if (all) {
-    return legacyVersions;
-  }
-  return legacyVersions.slice(0, 1);
-}
-function isSnapshotOptionalForBlockVersion(state, block, version) {
-  if (block.layout !== "multi") {
-    return false;
-  }
-  const introducedVersions = [...new Set(state.config.supportedMigrationVersions)].filter((candidateVersion) => hasSnapshotForVersion(state, block, candidateVersion)).sort(compareMigrationVersionLabels);
-  const firstIntroducedVersion = introducedVersions[0];
-  if (!firstIntroducedVersion) {
-    return false;
-  }
-  return compareMigrationVersionLabels(version, firstIntroducedVersion) < 0;
-}
-function isLegacySingleBlockProject(state) {
-  return state.blocks.length === 1 && state.blocks[0]?.layout === "legacy";
-}
-function getSelectedEntriesByBlock(state, targetVersions, command) {
-  const discoveredEntries = discoverMigrationEntries(state);
-  const discoveredEntryKeys = new Set(discoveredEntries.map((entry) => `${entry.block.key}:${entry.fromVersion}`));
-  const missingEntries = targetVersions.flatMap((version) => state.blocks.filter((block) => hasSnapshotForVersion(state, block, version)).filter((block) => !discoveredEntryKeys.has(`${block.key}:${version}`)).map((block) => ({ block, version })));
-  if (missingEntries.length > 0) {
-    const missingLabels = missingEntries.map(({ block, version }) => `${block.blockName} @ ${version}`).join(", ");
-    const missingVersions = [...new Set(missingEntries.map(({ version }) => version))].sort(compareMigrationVersionLabels);
-    throw new Error(`Missing migration ${command} inputs for ${missingLabels}. ` + `Run \`${formatScaffoldCommand(missingVersions)}\` first, then \`wp-typia migrate doctor --all\` if the workspace should already be scaffolded.`);
-  }
-  return groupEntriesByBlock(discoveredEntries.filter((entry) => targetVersions.includes(entry.fromVersion)));
-}
-function assertDistinctMigrationEdge(command, fromVersion, toVersion) {
-  if (fromVersion === toVersion) {
-    throw new Error(`\`migrate ${command}\` requires different source and target migration versions, but both resolved to ${fromVersion}. ` + `Choose an older snapshot with \`--from-migration-version <label>\` or capture a newer schema release with \`wp-typia migrate snapshot --migration-version <label>\` first.`);
-  }
-}
-function createMigrationPlanNextSteps(fromVersion, targetVersion, currentVersion) {
-  if (targetVersion !== currentVersion) {
-    return [
-      formatEdgeCommand("scaffold", fromVersion, targetVersion, currentVersion)
-    ];
-  }
-  return [
-    formatEdgeCommand("scaffold", fromVersion, targetVersion, currentVersion),
-    `wp-typia migrate doctor --from-migration-version ${fromVersion}`,
-    `wp-typia migrate verify --from-migration-version ${fromVersion}`,
-    `wp-typia migrate fuzz --from-migration-version ${fromVersion}`
-  ];
-}
-function formatEdgeCommand(command, fromVersion, targetVersion, currentVersion) {
-  return targetVersion === currentVersion ? `wp-typia migrate ${command} --from-migration-version ${fromVersion}` : `wp-typia migrate ${command} --from-migration-version ${fromVersion} --to-migration-version ${targetVersion}`;
-}
-function createMissingProjectSnapshotMessage(state, fromVersion) {
-  const snapshotVersions = [
-    ...new Set(state.blocks.flatMap((block) => getAvailableSnapshotVersionsForBlock(state.projectDir, state.config.supportedMigrationVersions, block)))
-  ].sort(compareMigrationVersionLabels);
-  return snapshotVersions.length === 0 ? `No migration block targets have a snapshot for ${fromVersion}. No snapshots exist yet in this project. ` + `Run \`wp-typia migrate snapshot --migration-version ${fromVersion}\` first if you want to preserve that schema state.` : `No migration block targets have a snapshot for ${fromVersion}. ` + `Available snapshot versions in this project: ${snapshotVersions.join(", ")}. ` + `Run \`wp-typia migrate snapshot --migration-version ${fromVersion}\` first if you want to preserve that schema state.`;
-}
-function formatScaffoldCommand(versions) {
-  const uniqueVersions = [...new Set(versions)].sort(compareMigrationVersionLabels);
-  return uniqueVersions.length === 1 ? `wp-typia migrate scaffold --from-migration-version ${uniqueVersions[0]}` : "wp-typia migrate scaffold --from-migration-version <label>";
-}
-function collectFixtureTargets(state, targetVersions, targetVersion) {
-  return targetVersions.flatMap((version) => state.blocks.filter((block) => hasSnapshotForVersion(state, block, version)).map((block) => ({
-    block,
-    fixturePath: getFixtureFilePath(state.paths, block, version, targetVersion),
-    scopedLabel: `${block.key}@${version}`,
-    version
-  })));
-}
-function groupEntriesByBlock(entries) {
-  return entries.reduce((accumulator, entry) => {
-    if (!accumulator[entry.block.key]) {
-      accumulator[entry.block.key] = [];
-    }
-    accumulator[entry.block.key].push(entry);
-    return accumulator;
-  }, {});
-}
-
-// ../wp-typia-project-tools/src/runtime/migration-maintenance-verify.ts
-import fs6 from "fs";
-import path6 from "path";
-import { execFileSync } from "child_process";
-function verifyProjectMigrations(projectDir, {
-  all = false,
-  fromMigrationVersion,
-  renderLine = console.log
-} = {}) {
-  const state = loadMigrationProject(projectDir);
-  const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
-  const blockEntries = getSelectedEntriesByBlock(state, targetVersions, "verify");
-  const legacySingleBlock = isLegacySingleBlockProject(state);
-  if (targetVersions.length === 0) {
-    renderLine("No legacy migration versions configured for verification.");
-    return { verifiedVersions: [] };
-  }
-  const tsxBinary = getLocalTsxBinary(projectDir);
-  for (const [blockKey, entries] of Object.entries(blockEntries)) {
-    const block = state.blocks.find((entry) => entry.key === blockKey);
-    if (!block || entries.length === 0) {
-      continue;
-    }
-    for (const entry of entries) {
-      assertRuleHasNoTodos(projectDir, block, entry.fromVersion, state.config.currentMigrationVersion);
-    }
-    const verifyScriptPath = path6.join(getGeneratedDirForBlock(state.paths, block), "verify.ts");
-    if (!fs6.existsSync(verifyScriptPath)) {
-      const selectedVersionsForBlock2 = entries.map((entry) => entry.fromVersion);
-      throw new Error(`Generated verify script is missing for ${block.blockName} (${selectedVersionsForBlock2.join(", ")}). ` + `Run \`${formatScaffoldCommand(selectedVersionsForBlock2)}\` first, then \`wp-typia migrate doctor --all\` if the workspace should already be scaffolded.`);
-    }
-    const selectedVersionsForBlock = entries.map((entry) => entry.fromVersion);
-    const filteredArgs = all ? ["--all"] : ["--from-migration-version", selectedVersionsForBlock[0]];
-    execFileSync(tsxBinary, [verifyScriptPath, ...filteredArgs], {
-      cwd: projectDir,
-      shell: process.platform === "win32",
-      stdio: "inherit"
-    });
-    renderLine(legacySingleBlock ? `Verified migrations for ${selectedVersionsForBlock.join(", ")}` : `Verified ${block.blockName} migrations for ${selectedVersionsForBlock.join(", ")}`);
-  }
-  return { verifiedVersions: targetVersions };
-}
-function recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck) {
-  let invalidWorkspaceReason = null;
-  let workspace;
-  try {
-    invalidWorkspaceReason = getInvalidWorkspaceProjectReason(projectDir);
-    workspace = tryResolveWorkspaceProject(projectDir);
-  } catch (error) {
-    recordCheck("fail", "Workspace migration targets", error instanceof Error ? error.message : String(error));
-    return;
-  }
-  if (!workspace) {
-    if (invalidWorkspaceReason) {
-      recordCheck("fail", "Workspace migration targets", invalidWorkspaceReason);
-    }
-    return;
-  }
-  try {
-    const inventory = readWorkspaceInventory(workspace.projectDir);
-    const expectedTargets = inventory.blocks.map((block) => `${workspace.workspace.namespace}/${block.slug}`);
-    const configuredTargets = state.blocks.map((block) => block.blockName);
-    const expectedTargetSet = new Set(expectedTargets);
-    const configuredTargetSet = new Set(configuredTargets);
-    const missingTargets = expectedTargets.filter((target) => !configuredTargetSet.has(target));
-    const staleTargets = configuredTargets.filter((target) => !expectedTargetSet.has(target));
-    recordCheck(missingTargets.length === 0 && staleTargets.length === 0 ? "pass" : "fail", "Workspace migration targets", missingTargets.length === 0 && staleTargets.length === 0 ? `${expectedTargets.length} workspace block target(s) align with migration config` : [
-      missingTargets.length > 0 ? `Missing from migration config: ${missingTargets.join(", ")}` : null,
-      staleTargets.length > 0 ? `Not present in scripts/block-config.ts: ${staleTargets.join(", ")}` : null
-    ].filter((detail) => typeof detail === "string").join("; "));
-  } catch (error) {
-    recordCheck("fail", "Workspace migration targets", error instanceof Error ? error.message : String(error));
-  }
-}
-function doctorProjectMigrations(projectDir, {
-  all = false,
-  fromMigrationVersion,
-  renderLine = console.log
-} = {}) {
-  const checks = [];
-  const recordCheck = (status, label, detail) => {
-    checks.push({ detail, label, status });
-    renderLine(`${status === "pass" ? "PASS" : "FAIL"} ${label}: ${detail}`);
-  };
-  let state;
-  try {
-    state = loadMigrationProject(projectDir);
-    const legacySingleBlock2 = isLegacySingleBlockProject(state);
-    recordCheck("pass", "Migration config", legacySingleBlock2 ? `Loaded ${state.blocks[0]?.blockName} @ ${state.config.currentMigrationVersion}` : `Loaded ${state.blocks.length} block target(s) @ ${state.config.currentMigrationVersion}`);
-  } catch (error) {
-    recordCheck("fail", "Migration config", error instanceof Error ? error.message : String(error));
-    throw new Error("Migration doctor failed.");
-  }
-  const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
-  const legacySingleBlock = isLegacySingleBlockProject(state);
-  const snapshotVersions = new Set(targetVersions.length > 0 ? [state.config.currentMigrationVersion, ...targetVersions] : state.config.supportedMigrationVersions);
-  recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck);
-  for (const version of snapshotVersions) {
-    for (const block of state.blocks) {
-      const snapshotRoot = getSnapshotRoot(projectDir, block, version);
-      const blockJsonPath = getSnapshotBlockJsonPath(projectDir, block, version);
-      const manifestPath = getSnapshotManifestPath(projectDir, block, version);
-      const savePath = getSnapshotSavePath(projectDir, block, version);
-      const hasSnapshot = fs6.existsSync(snapshotRoot);
-      const snapshotIsOptional = !hasSnapshot && isSnapshotOptionalForBlockVersion(state, block, version);
-      recordCheck(hasSnapshot || snapshotIsOptional ? "pass" : "fail", legacySingleBlock ? `Snapshot ${version}` : `Snapshot ${block.blockName} @ ${version}`, hasSnapshot ? path6.relative(projectDir, snapshotRoot) : "Not present for this version");
-      if (!hasSnapshot) {
-        continue;
-      }
-      for (const targetPath of [blockJsonPath, manifestPath, savePath]) {
-        recordCheck(fs6.existsSync(targetPath) ? "pass" : "fail", legacySingleBlock ? `Snapshot file ${version}` : `Snapshot file ${block.blockName} @ ${version}`, fs6.existsSync(targetPath) ? path6.relative(projectDir, targetPath) : `Missing ${path6.relative(projectDir, targetPath)}`);
-      }
-    }
-  }
-  try {
-    const generatedEntries = collectGeneratedMigrationEntries(state);
-    const expectedGeneratedFiles = new Map;
-    for (const block of state.blocks) {
-      const blockGeneratedEntries = generatedEntries.filter(({ entry }) => entry.block.key === block.key);
-      const entries = blockGeneratedEntries.map(({ entry }) => entry);
-      const generatedDir = getGeneratedDirForBlock(state.paths, block);
-      expectedGeneratedFiles.set(path6.join(generatedDir, "registry.ts"), renderMigrationRegistryFile(state, block.key, blockGeneratedEntries));
-      expectedGeneratedFiles.set(path6.join(generatedDir, "deprecated.ts"), renderGeneratedDeprecatedFile(state, block.key, entries));
-      expectedGeneratedFiles.set(path6.join(generatedDir, "verify.ts"), renderVerifyFile(state, block.key, entries));
-      expectedGeneratedFiles.set(path6.join(generatedDir, "fuzz.ts"), renderFuzzFile(state, block.key, blockGeneratedEntries));
-    }
-    expectedGeneratedFiles.set(path6.join(state.paths.generatedDir, "index.ts"), renderGeneratedMigrationIndexFile(state, generatedEntries.map(({ entry }) => entry)));
-    expectedGeneratedFiles.set(path6.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, generatedEntries.map(({ entry }) => entry)));
-    for (const [filePath, expectedSource] of expectedGeneratedFiles) {
-      const inSync = fs6.existsSync(filePath) && fs6.readFileSync(filePath, "utf8") === expectedSource;
-      recordCheck(inSync ? "pass" : "fail", `Generated ${path6.relative(projectDir, filePath)}`, inSync ? "In sync" : "Run `wp-typia migrate scaffold --from-migration-version <label>` or regenerate artifacts");
-    }
-  } catch (error) {
-    recordCheck("fail", "Generated artifacts", error instanceof Error ? error.message : String(error));
-  }
-  for (const version of targetVersions) {
-    for (const block of state.blocks) {
-      if (!hasSnapshotForVersion(state, block, version)) {
-        recordCheck("pass", `Snapshot coverage ${block.blockName} @ ${version}`, "Target not present for this version");
-        continue;
-      }
-      const rulePath = getRuleFilePath(state.paths, block, version, state.config.currentMigrationVersion);
-      const fixturePath = getFixtureFilePath(state.paths, block, version, state.config.currentMigrationVersion);
-      recordCheck(fs6.existsSync(rulePath) ? "pass" : "fail", legacySingleBlock ? `Rule ${version}` : `Rule ${block.blockName} @ ${version}`, fs6.existsSync(rulePath) ? path6.relative(projectDir, rulePath) : `Missing ${path6.relative(projectDir, rulePath)}`);
-      recordCheck(fs6.existsSync(fixturePath) ? "pass" : "fail", legacySingleBlock ? `Fixture ${version}` : `Fixture ${block.blockName} @ ${version}`, fs6.existsSync(fixturePath) ? path6.relative(projectDir, fixturePath) : `Missing ${path6.relative(projectDir, fixturePath)}`);
-      if (!fs6.existsSync(rulePath) || !fs6.existsSync(fixturePath)) {
-        continue;
-      }
-      try {
-        assertRuleHasNoTodos(projectDir, block, version, state.config.currentMigrationVersion);
-        recordCheck("pass", legacySingleBlock ? `Rule TODOs ${version}` : `Rule TODOs ${block.blockName} @ ${version}`, "No TODO MIGRATION markers remain");
-      } catch (error) {
-        recordCheck("fail", legacySingleBlock ? `Rule TODOs ${version}` : `Rule TODOs ${block.blockName} @ ${version}`, error instanceof Error ? error.message : String(error));
-      }
-      try {
-        const ruleMetadata = readRuleMetadata(rulePath);
-        recordCheck(ruleMetadata.unresolved.length === 0 ? "pass" : "fail", legacySingleBlock ? `Rule unresolved ${version}` : `Rule unresolved ${block.blockName} @ ${version}`, ruleMetadata.unresolved.length === 0 ? "No unresolved entries remain" : ruleMetadata.unresolved.join(", "));
-      } catch (error) {
-        recordCheck("fail", legacySingleBlock ? `Rule unresolved ${version}` : `Rule unresolved ${block.blockName} @ ${version}`, error instanceof Error ? error.message : String(error));
-      }
-      try {
-        const fixtureDocument = readJson(fixturePath);
-        recordCheck(Array.isArray(fixtureDocument.cases) && fixtureDocument.cases.length > 0 ? "pass" : "fail", legacySingleBlock ? `Fixture parse ${version}` : `Fixture parse ${block.blockName} @ ${version}`, Array.isArray(fixtureDocument.cases) && fixtureDocument.cases.length > 0 ? `${fixtureDocument.cases.length} case(s)` : "Fixture document has no cases");
-        const diff = createMigrationDiff(state, block, version, state.config.currentMigrationVersion);
-        const expectedFixture = createEdgeFixtureDocument(projectDir, block, version, state.config.currentMigrationVersion, diff);
-        const actualCaseNames = new Set((fixtureDocument.cases ?? []).map((fixtureCase) => fixtureCase.name));
-        const missingCases = expectedFixture.cases.map((fixtureCase) => fixtureCase.name).filter((name) => !actualCaseNames.has(name));
-        recordCheck(missingCases.length === 0 ? "pass" : "fail", legacySingleBlock ? `Fixture coverage ${version}` : `Fixture coverage ${block.blockName} @ ${version}`, missingCases.length === 0 ? "All expected fixture cases are present" : `Missing ${missingCases.join(", ")}`);
-        recordCheck("pass", legacySingleBlock ? `Risk summary ${version}` : `Risk summary ${block.blockName} @ ${version}`, formatMigrationRiskSummary(createMigrationRiskSummary(diff)));
-      } catch (error) {
-        recordCheck("fail", legacySingleBlock ? `Fixture parse ${version}` : `Fixture parse ${block.blockName} @ ${version}`, error instanceof Error ? error.message : String(error));
-      }
-    }
-  }
-  const failedChecks = checks.filter((check) => check.status === "fail");
-  renderLine(`${failedChecks.length === 0 ? "PASS" : "FAIL"} Migration doctor summary: ${checks.length - failedChecks.length}/${checks.length} checks passed`);
-  if (failedChecks.length > 0) {
-    throw new Error("Migration doctor failed.");
-  }
-  return {
-    checkedVersions: targetVersions,
-    checks
-  };
-}
-// ../wp-typia-project-tools/src/runtime/migration-maintenance-fixtures.ts
-import fs7 from "fs";
-import path7 from "path";
-import { execFileSync as execFileSync2 } from "child_process";
-function fixturesProjectMigrations(projectDir, {
-  all = false,
-  confirmOverwrite,
-  force = false,
-  fromMigrationVersion,
-  isInteractive = isInteractiveTerminal(),
-  renderLine = console.log,
-  toMigrationVersion = "current"
-} = {}) {
-  const state = loadMigrationProject(projectDir);
-  const targetMigrationVersion = resolveTargetMigrationVersion(state.config.currentMigrationVersion, toMigrationVersion);
-  const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
-  if (targetVersions.length === 0) {
-    renderLine("No legacy migration versions configured for fixture generation.");
-    return { generatedVersions: [], skippedVersions: [] };
-  }
-  const generatedVersions = [];
-  const skippedVersions = [];
-  const fixtureTargets = collectFixtureTargets(state, targetVersions, targetMigrationVersion);
-  if (force) {
-    const overwriteTargets = fixtureTargets.filter(({ fixturePath }) => fs7.existsSync(fixturePath));
-    if (isInteractive && overwriteTargets.length > 0) {
-      const confirmed = confirmOverwrite?.(`About to overwrite ${overwriteTargets.length} existing migration fixture file(s). Continue?`) ?? promptForConfirmation(`About to overwrite ${overwriteTargets.length} existing migration fixture file(s). Continue?`);
-      if (!confirmed) {
-        renderLine(`Cancelled fixture refresh. Kept ${overwriteTargets.length} existing fixture file(s).`);
-        return {
-          generatedVersions,
-          skippedVersions: overwriteTargets.map(({ scopedLabel }) => scopedLabel)
-        };
-      }
-    }
-  }
-  for (const { block, fixturePath, scopedLabel, version } of fixtureTargets) {
-    const existed = fs7.existsSync(fixturePath);
-    const diff = createMigrationDiff(state, block, version, targetMigrationVersion);
-    const result = ensureEdgeFixtureFile(projectDir, block, version, targetMigrationVersion, diff, { force });
-    if (result.written) {
-      generatedVersions.push(scopedLabel);
-      renderLine(`${existed ? "Refreshed" : "Generated"} fixture ${path7.relative(projectDir, fixturePath)}`);
-    } else {
-      skippedVersions.push(scopedLabel);
-      renderLine(`Preserved existing fixture ${path7.relative(projectDir, fixturePath)} (use --force to refresh)`);
-    }
-  }
-  return {
-    generatedVersions,
-    skippedVersions
-  };
-}
-function fuzzProjectMigrations(projectDir, {
-  all = false,
-  fromMigrationVersion,
-  iterations = 25,
-  renderLine = console.log,
-  seed
-} = {}) {
-  const state = loadMigrationProject(projectDir);
-  const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
-  const blockEntries = getSelectedEntriesByBlock(state, targetVersions, "fuzz");
-  const legacySingleBlock = isLegacySingleBlockProject(state);
-  if (targetVersions.length === 0) {
-    renderLine("No legacy migration versions configured for fuzzing.");
-    return { fuzzedVersions: [], seed };
-  }
-  const tsxBinary = getLocalTsxBinary(projectDir);
-  for (const [blockKey, entries] of Object.entries(blockEntries)) {
-    const block = state.blocks.find((entry) => entry.key === blockKey);
-    if (!block || entries.length === 0) {
-      continue;
-    }
-    for (const entry of entries) {
-      assertRuleHasNoTodos(projectDir, block, entry.fromVersion, state.config.currentMigrationVersion);
-    }
-    const fuzzScriptPath = path7.join(getGeneratedDirForBlock(state.paths, block), "fuzz.ts");
-    if (!fs7.existsSync(fuzzScriptPath)) {
-      const selectedVersionsForBlock2 = entries.map((entry) => entry.fromVersion);
-      throw new Error(`Generated fuzz script is missing for ${block.blockName} (${selectedVersionsForBlock2.join(", ")}). ` + `Run \`${formatScaffoldCommand(selectedVersionsForBlock2)}\` first, then \`wp-typia migrate doctor --all\` if the workspace should already be scaffolded.`);
-    }
-    const selectedVersionsForBlock = entries.map((entry) => entry.fromVersion);
-    const args = [
-      fuzzScriptPath,
-      ...all ? ["--all"] : ["--from-migration-version", selectedVersionsForBlock[0]],
-      "--iterations",
-      String(iterations),
-      ...seed === undefined ? [] : ["--seed", String(seed)]
-    ];
-    execFileSync2(tsxBinary, args, {
-      cwd: projectDir,
-      shell: process.platform === "win32",
-      stdio: "inherit"
-    });
-    renderLine(legacySingleBlock ? `Fuzzed migrations for ${selectedVersionsForBlock.join(", ")}` : `Fuzzed ${block.blockName} migrations for ${selectedVersionsForBlock.join(", ")}`);
-  }
-  return { fuzzedVersions: targetVersions, seed };
-}
-function promptForConfirmation(message) {
-  process.stdout.write(`${message} [y/N]: `);
-  const buffer = Buffer.alloc(1);
-  let answer = "";
-  while (true) {
-    const bytesRead = fs7.readSync(process.stdin.fd, buffer, 0, 1, null);
-    if (bytesRead === 0) {
-      break;
-    }
-    const char = buffer.toString("utf8", 0, bytesRead);
-    if (char === `
-` || char === "\r") {
-      break;
-    }
-    answer += char;
-  }
-  const normalized = answer.trim().toLowerCase();
-  return normalized === "y" || normalized === "yes";
-}
-// ../wp-typia-project-tools/src/runtime/migrations.ts
-function runMigrationCommand(command, cwd, { prompt, renderLine = console.log } = {}) {
-  switch (command.command) {
-    case "init":
-      if (!command.flags.currentMigrationVersion) {
-        throw new Error("`migrate init` requires --current-migration-version <label>.");
-      }
-      return initProjectMigrations(cwd, command.flags.currentMigrationVersion, { renderLine });
-    case "snapshot":
-      if (!command.flags.migrationVersion) {
-        throw new Error("`migrate snapshot` requires --migration-version <label>.");
-      }
-      return snapshotProjectVersion(cwd, command.flags.migrationVersion, { renderLine });
-    case "plan":
-      if (!command.flags.fromMigrationVersion) {
-        throw new Error("`migrate plan` requires --from-migration-version <label>.");
-      }
-      return planProjectMigrations(cwd, {
-        fromMigrationVersion: command.flags.fromMigrationVersion,
-        renderLine,
-        toMigrationVersion: command.flags.toMigrationVersion ?? "current"
-      });
-    case "wizard":
-      return wizardProjectMigrations(cwd, {
-        prompt,
-        renderLine
-      });
-    case "diff":
-      if (!command.flags.fromMigrationVersion) {
-        throw new Error("`migrate diff` requires --from-migration-version <label>.");
-      }
-      return diffProjectMigrations(cwd, {
-        fromMigrationVersion: command.flags.fromMigrationVersion,
-        renderLine,
-        toMigrationVersion: command.flags.toMigrationVersion ?? "current"
-      });
-    case "scaffold":
-      if (!command.flags.fromMigrationVersion) {
-        throw new Error("`migrate scaffold` requires --from-migration-version <label>.");
-      }
-      return scaffoldProjectMigrations(cwd, {
-        fromMigrationVersion: command.flags.fromMigrationVersion,
-        renderLine,
-        toMigrationVersion: command.flags.toMigrationVersion ?? "current"
-      });
-    case "verify":
-      return verifyProjectMigrations(cwd, {
-        all: command.flags.all,
-        fromMigrationVersion: command.flags.fromMigrationVersion,
-        renderLine
-      });
-    case "doctor":
-      return doctorProjectMigrations(cwd, {
-        all: command.flags.all,
-        fromMigrationVersion: command.flags.fromMigrationVersion,
-        renderLine
-      });
-    case "fixtures":
-      return fixturesProjectMigrations(cwd, {
-        all: command.flags.all,
-        force: command.flags.force,
-        fromMigrationVersion: command.flags.fromMigrationVersion,
-        renderLine,
-        toMigrationVersion: command.flags.toMigrationVersion ?? "current"
-      });
-    case "fuzz":
-      return fuzzProjectMigrations(cwd, {
-        all: command.flags.all,
-        fromMigrationVersion: command.flags.fromMigrationVersion,
-        iterations: parsePositiveInteger(command.flags.iterations, "iterations") ?? 25,
-        renderLine,
-        seed: parseNonNegativeInteger(command.flags.seed, "seed")
-      });
-    default:
-      throw new Error(formatMigrationHelpText());
-  }
-}
-function planProjectMigrations(projectDir, { fromMigrationVersion, renderLine = console.log, toMigrationVersion = "current" } = {}) {
-  if (!fromMigrationVersion) {
-    throw new Error("`migrate plan` requires --from-migration-version <label>.");
-  }
-  const state = loadMigrationProject(projectDir, { allowSyncTypes: false });
-  const availableLegacyVersions = listPreviewableLegacyVersions(state).sort(compareMigrationVersionLabels).reverse();
-  const targetMigrationVersion = resolveTargetMigrationVersion(state.config.currentMigrationVersion, toMigrationVersion);
-  assertDistinctMigrationEdge("plan", fromMigrationVersion, targetMigrationVersion);
-  resolveLegacyVersions(state, {
-    fromMigrationVersion,
-    availableVersions: availableLegacyVersions
-  });
-  const includedBlocks = state.blocks.filter((block) => hasSnapshotForVersion(state, block, fromMigrationVersion));
-  if (includedBlocks.length === 0) {
-    throw new Error(createMissingProjectSnapshotMessage(state, fromMigrationVersion));
-  }
-  const skippedBlocks = state.blocks.filter((block) => !hasSnapshotForVersion(state, block, fromMigrationVersion)).map((block) => block.blockName);
-  const summaries = includedBlocks.map((block) => {
-    const diff = createMigrationDiff(state, block, fromMigrationVersion, targetMigrationVersion);
-    return {
-      blockName: block.blockName,
-      diff,
-      riskSummary: createMigrationRiskSummary(diff)
-    };
-  });
-  const nextSteps = createMigrationPlanNextSteps(fromMigrationVersion, targetMigrationVersion, state.config.currentMigrationVersion);
-  renderLine(`Current migration version: ${state.config.currentMigrationVersion}`);
-  renderLine(`Available legacy migration versions: ${availableLegacyVersions.length > 0 ? availableLegacyVersions.join(", ") : "None configured"}`);
-  renderLine(`Selected migration edge: ${fromMigrationVersion} -> ${targetMigrationVersion}`);
-  renderLine(`Included block targets: ${includedBlocks.map((block) => block.blockName).join(", ")}`);
-  renderLine(`Skipped block targets: ${skippedBlocks.length > 0 ? skippedBlocks.join(", ") : "None"}`);
-  for (const summary of summaries) {
-    renderLine(`Block: ${summary.blockName}`);
-    renderLine(formatDiffReport(summary.diff, { includeRiskSummary: false }));
-    renderLine(`Risk summary: ${formatMigrationRiskSummary(summary.riskSummary)}`);
-  }
-  renderLine("Next steps:");
-  for (const command of nextSteps) {
-    renderLine(`  ${command}`);
-  }
-  renderLine(`Optional after editing rules: ${formatEdgeCommand("fixtures", fromMigrationVersion, targetMigrationVersion, state.config.currentMigrationVersion)} --force`);
-  return {
-    availableLegacyVersions,
-    currentMigrationVersion: state.config.currentMigrationVersion,
-    fromMigrationVersion,
-    includedBlocks: includedBlocks.map((block) => block.blockName),
-    nextSteps,
-    skippedBlocks,
-    summaries,
-    targetMigrationVersion
-  };
-}
-async function wizardProjectMigrations(projectDir, {
-  isInteractive = isInteractiveTerminal(),
-  prompt,
-  renderLine = console.log
-} = {}) {
-  if (!isInteractive) {
-    throw new Error("`migrate wizard` requires an interactive terminal. " + "Use `wp-typia migrate plan --from-migration-version <label>` for a read-only preview or run the direct migration commands with explicit flags.");
-  }
-  const state = loadMigrationProject(projectDir, { allowSyncTypes: false });
-  const availableLegacyVersions = listPreviewableLegacyVersions(state).sort(compareMigrationVersionLabels).reverse();
-  if (availableLegacyVersions.length === 0) {
-    throw new Error("No legacy migration versions are configured yet. " + "Capture an older schema release with `wp-typia migrate snapshot --migration-version <label>` first, then rerun `wp-typia migrate wizard`.");
-  }
-  const activePrompt = prompt ?? createReadlinePrompt();
-  const createdPrompt = !prompt;
-  try {
-    const selectedVersion = await activePrompt.select("Choose a legacy version to preview", [
-      ...availableLegacyVersions.map((version) => ({
-        hint: `Preview ${version} -> ${state.config.currentMigrationVersion}`,
-        label: version,
-        value: version
-      })),
-      {
-        hint: "Exit without previewing a migration edge",
-        label: "Cancel",
-        value: "cancel"
-      }
-    ], 1);
-    if (selectedVersion === "cancel") {
-      renderLine("Cancelled migration planning.");
-      return { cancelled: true };
-    }
-    return planProjectMigrations(projectDir, {
-      fromMigrationVersion: selectedVersion,
-      renderLine
-    });
-  } finally {
-    if (createdPrompt) {
-      activePrompt.close();
-    }
-  }
-}
-function initProjectMigrations(projectDir, currentMigrationVersion, { renderLine = console.log } = {}) {
-  assertMigrationVersionLabel(currentMigrationVersion, "current migration version");
-  assertNoLegacySemverMigrationWorkspace(projectDir);
-  const discoveredLayout = discoverMigrationInitLayout(projectDir);
-  const configuredBlocks = discoveredLayout.mode === "multi" ? discoveredLayout.blocks : undefined;
-  ensureAdvancedMigrationProject(projectDir, configuredBlocks);
-  ensureMigrationDirectories(projectDir, configuredBlocks);
-  writeMigrationConfig(projectDir, {
-    blockName: discoveredLayout.mode === "single" ? discoveredLayout.block.blockName : undefined,
-    blocks: configuredBlocks,
-    currentMigrationVersion,
-    snapshotDir: SNAPSHOT_DIR.replace(/\\/g, "/"),
-    supportedMigrationVersions: [currentMigrationVersion]
-  });
-  writeInitialMigrationScaffold(projectDir, currentMigrationVersion, configuredBlocks);
-  snapshotProjectVersion(projectDir, currentMigrationVersion, { renderLine, skipConfigUpdate: true });
-  regenerateGeneratedArtifacts(projectDir);
-  if (discoveredLayout.mode === "multi") {
-    renderLine(`Detected multi-block migration retrofit (${discoveredLayout.blocks.length} targets): ${discoveredLayout.blocks.map((block) => block.blockName).join(", ")}`);
-  } else {
-    renderLine(`Detected single-block migration retrofit: ${discoveredLayout.block.blockName}`);
-  }
-  renderLine("Wrote src/migrations/config.ts");
-  renderLine(`Initialized migrations for ${discoveredLayout.mode === "multi" ? discoveredLayout.blocks.map((block) => block.blockName).join(", ") : discoveredLayout.block.blockName} at migration version ${currentMigrationVersion}`);
-  return loadMigrationProject(projectDir);
-}
-function snapshotProjectVersion(projectDir, migrationVersion, {
-  renderLine = console.log,
-  skipConfigUpdate = false,
-  skipSyncTypes = false
-} = {}) {
-  ensureAdvancedMigrationProject(projectDir);
-  assertMigrationVersionLabel(migrationVersion, "migration version");
-  if (!skipSyncTypes) {
-    try {
-      runProjectScriptIfPresent(projectDir, "sync-types");
-    } catch (error) {
-      const syncTypesCommand = formatRunScript(detectPackageManagerId(projectDir), "sync-types");
-      const reason = error instanceof Error ? error.message : String(error);
-      throw new Error(`Could not capture migration snapshot ${migrationVersion} because \`${syncTypesCommand}\` failed first. ` + `Install project dependencies if needed, rerun \`${syncTypesCommand}\` in the project root to inspect the underlying error, ` + `then retry \`wp-typia migrate snapshot --migration-version ${migrationVersion}\`.
-` + `Original error: ${reason}`);
-    }
-  }
-  const state = loadMigrationProject(projectDir, { allowMissingConfig: skipConfigUpdate });
-  for (const block of state.blocks) {
-    const snapshotRoot = getSnapshotRoot(projectDir, block, migrationVersion);
-    fs8.mkdirSync(snapshotRoot, { recursive: true });
-    fs8.writeFileSync(getSnapshotBlockJsonPath(projectDir, block, migrationVersion), `${JSON.stringify(sanitizeSnapshotBlockJson(readJson(path8.join(projectDir, block.blockJsonFile))), null, "\t")}
-`, "utf8");
-    copyFile(path8.join(projectDir, block.manifestFile), getSnapshotManifestPath(projectDir, block, migrationVersion));
-    fs8.writeFileSync(getSnapshotSavePath(projectDir, block, migrationVersion), sanitizeSaveSnapshotSource(fs8.readFileSync(path8.join(projectDir, block.saveFile), "utf8")), "utf8");
-  }
-  if (!skipConfigUpdate) {
-    const nextSupported = [
-      ...new Set([...state.config.supportedMigrationVersions, migrationVersion])
-    ].sort(compareMigrationVersionLabels);
-    writeMigrationConfig(projectDir, {
-      ...state.config,
-      currentMigrationVersion: migrationVersion,
-      supportedMigrationVersions: nextSupported
-    });
-  }
-  regenerateGeneratedArtifacts(projectDir);
-  renderLine(`Snapshot stored for migration version ${migrationVersion}`);
-  return loadMigrationProject(projectDir);
-}
-function diffProjectMigrations(projectDir, {
-  fromMigrationVersion,
-  toMigrationVersion = "current",
-  renderLine = console.log
-} = {}) {
-  if (!fromMigrationVersion) {
-    throw new Error("`migrate diff` requires --from-migration-version <label>.");
-  }
-  const state = loadMigrationProject(projectDir);
-  const targetMigrationVersion = resolveTargetMigrationVersion(state.config.currentMigrationVersion, toMigrationVersion);
-  assertDistinctMigrationEdge("diff", fromMigrationVersion, targetMigrationVersion);
-  const diffs = state.blocks.filter((block) => hasSnapshotForVersion(state, block, fromMigrationVersion)).map((block) => ({
-    block,
-    diff: createMigrationDiff(state, block, fromMigrationVersion, targetMigrationVersion)
-  }));
-  if (diffs.length === 0) {
-    throw new Error(createMissingProjectSnapshotMessage(state, fromMigrationVersion));
-  }
-  for (const { block, diff } of diffs) {
-    renderLine(`Block: ${block.blockName}`);
-    renderLine(formatDiffReport(diff));
-  }
-  return diffs.length === 1 ? diffs[0].diff : diffs;
-}
-function scaffoldProjectMigrations(projectDir, {
-  fromMigrationVersion,
-  toMigrationVersion = "current",
-  renderLine = console.log
-} = {}) {
-  if (!fromMigrationVersion) {
-    throw new Error("`migrate scaffold` requires --from-migration-version <label>.");
-  }
-  ensureMigrationDirectories(projectDir);
-  const state = loadMigrationProject(projectDir);
-  const targetMigrationVersion = resolveTargetMigrationVersion(state.config.currentMigrationVersion, toMigrationVersion);
-  assertDistinctMigrationEdge("scaffold", fromMigrationVersion, targetMigrationVersion);
-  const paths = getProjectPaths(projectDir);
-  const scaffolded = [];
-  let eligibleBlocks = 0;
-  for (const block of state.blocks) {
-    if (!hasSnapshotForVersion(state, block, fromMigrationVersion)) {
-      renderLine(`Skipped ${block.blockName}: no snapshot for ${fromMigrationVersion}`);
-      continue;
-    }
-    eligibleBlocks += 1;
-    const diff = createMigrationDiff(state, block, fromMigrationVersion, targetMigrationVersion);
-    const rulePath = getRuleFilePath(paths, block, fromMigrationVersion, targetMigrationVersion);
-    if (!fs8.existsSync(rulePath)) {
-      fs8.mkdirSync(path8.dirname(rulePath), { recursive: true });
-      fs8.writeFileSync(rulePath, renderMigrationRuleFile({
-        block,
-        currentAttributes: block.currentManifest.attributes ?? {},
-        currentTypeName: block.currentManifest.sourceType,
-        diff,
-        fromVersion: fromMigrationVersion,
-        projectDir,
-        rulePath,
-        targetVersion: targetMigrationVersion
-      }), "utf8");
-    }
-    ensureEdgeFixtureFile(projectDir, block, fromMigrationVersion, targetMigrationVersion, diff);
-    scaffolded.push({ blockName: block.blockName, diff, rulePath });
-  }
-  regenerateGeneratedArtifacts(projectDir);
-  for (const entry of scaffolded) {
-    renderLine(`Block: ${entry.blockName}`);
-    renderLine(formatDiffReport(entry.diff));
-    renderLine(`Scaffolded ${path8.relative(projectDir, entry.rulePath)}`);
-  }
-  if (eligibleBlocks === 0) {
-    throw new Error(createMissingProjectSnapshotMessage(state, fromMigrationVersion));
-  }
-  return scaffolded.length === 1 ? scaffolded[0] : { scaffolded };
-}
-function seedProjectMigrations(projectDir, currentMigrationVersion, blocks, { renderLine = console.log } = {}) {
-  ensureAdvancedMigrationProject(projectDir, blocks);
-  assertMigrationVersionLabel(currentMigrationVersion, "current migration version");
-  ensureMigrationDirectories(projectDir, blocks);
-  writeMigrationConfig(projectDir, {
-    blocks,
-    currentMigrationVersion,
-    snapshotDir: SNAPSHOT_DIR.replace(/\\/g, "/"),
-    supportedMigrationVersions: [currentMigrationVersion]
-  });
-  writeInitialMigrationScaffold(projectDir, currentMigrationVersion, blocks);
-  snapshotProjectVersion(projectDir, currentMigrationVersion, {
-    renderLine,
-    skipConfigUpdate: true,
-    skipSyncTypes: true
-  });
-  regenerateGeneratedArtifacts(projectDir);
-  renderLine(`Initialized migrations for ${blocks.map((block) => block.blockName).join(", ")} at migration version ${currentMigrationVersion}`);
-  return loadMigrationProject(projectDir);
-}
-
-export { formatMigrationHelpText, parseMigrationArgs, formatDiffReport, verifyProjectMigrations, doctorProjectMigrations, fixturesProjectMigrations, fuzzProjectMigrations, runMigrationCommand, planProjectMigrations, wizardProjectMigrations, initProjectMigrations, snapshotProjectVersion, diffProjectMigrations, scaffoldProjectMigrations, seedProjectMigrations };
-
-//# debugId=A37691396E12D94E64756E2164756E21