@wp-typia/create 0.1.0

package/dist/cli.js

@@ -0,0 +1,2492 @@
+#!/usr/bin/env node
+
+// src/runtime/cli-core.ts
+import fs3 from "node:fs";
+import os from "node:os";
+import path3 from "node:path";
+import readline from "node:readline";
+import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+
+// src/runtime/scaffold.ts
+import fs2 from "node:fs";
+import { promises as fsp } from "node:fs";
+import path2 from "node:path";
+import { execSync } from "node:child_process";
+
+// src/runtime/package-managers.ts
+var PACKAGE_MANAGER_DATA = [
+  {
+    id: "bun",
+    label: "Bun",
+    packageManagerField: "bun@1.3.10",
+    installCommand: "bun install",
+    frozenInstallCommand: "bun install --frozen-lockfile"
+  },
+  {
+    id: "npm",
+    label: "npm",
+    packageManagerField: "npm@11.6.1",
+    installCommand: "npm install",
+    frozenInstallCommand: "npm ci"
+  },
+  {
+    id: "pnpm",
+    label: "pnpm",
+    packageManagerField: "pnpm@8.3.1",
+    installCommand: "pnpm install",
+    frozenInstallCommand: "pnpm install --frozen-lockfile"
+  },
+  {
+    id: "yarn",
+    label: "Yarn",
+    packageManagerField: "yarn@3.2.4",
+    installCommand: "yarn install",
+    frozenInstallCommand: "yarn install --frozen-lockfile"
+  }
+];
+var PACKAGE_MANAGER_IDS = PACKAGE_MANAGER_DATA.map((manager) => manager.id);
+var PACKAGE_MANAGERS = Object.freeze(Object.fromEntries(PACKAGE_MANAGER_DATA.map((manager) => [manager.id, manager])));
+var DEV_INSTALL_FLAGS = {
+  bun: "add -d",
+  npm: "install --save-dev",
+  pnpm: "add -D",
+  yarn: "add -D"
+};
+var STOP_CHARS = new Set([`
+`, "\r", "`", '"', "'", ")", "]", "}", "!", ",", "."]);
+function getPackageManager(id) {
+  const manager = PACKAGE_MANAGERS[id];
+  if (!manager) {
+    throw new Error(`Unknown package manager "${id}". Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}`);
+  }
+  return manager;
+}
+function getPackageManagerSelectOptions() {
+  return PACKAGE_MANAGER_DATA.map((manager) => ({
+    label: manager.label,
+    value: manager.id,
+    hint: manager.installCommand
+  }));
+}
+function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
+  const args = extraArgs.trim();
+  if (packageManagerId === "bun") {
+    return args ? `bun run ${scriptName} ${args}` : `bun run ${scriptName}`;
+  }
+  if (packageManagerId === "npm") {
+    return args ? `npm run ${scriptName} -- ${args}` : `npm run ${scriptName}`;
+  }
+  if (packageManagerId === "pnpm") {
+    return args ? `pnpm run ${scriptName} -- ${args}` : `pnpm run ${scriptName}`;
+  }
+  return args ? `yarn run ${scriptName} ${args}` : `yarn run ${scriptName}`;
+}
+function formatInstallCommand(packageManagerId) {
+  return getPackageManager(packageManagerId).installCommand;
+}
+function consumeCommandArguments(content, startIndex) {
+  let cursor = startIndex;
+  let args = "";
+  while (cursor < content.length) {
+    const current = content[cursor];
+    if (STOP_CHARS.has(current) || content.startsWith("&&", cursor) || content.startsWith("||", cursor) || current === ";") {
+      break;
+    }
+    args += current;
+    cursor += 1;
+  }
+  return {
+    args: args.trim(),
+    cursor
+  };
+}
+function replaceBunRunCommands(content, packageManagerId) {
+  const marker = "bun run ";
+  let result = "";
+  let cursor = 0;
+  while (cursor < content.length) {
+    const index = content.indexOf(marker, cursor);
+    if (index === -1) {
+      result += content.slice(cursor);
+      break;
+    }
+    if (index > 0 && /[A-Za-z0-9_-]/.test(content[index - 1])) {
+      result += content.slice(cursor, index + marker.length);
+      cursor = index + marker.length;
+      continue;
+    }
+    result += content.slice(cursor, index);
+    const scriptNameStart = index + marker.length;
+    const scriptNameMatch = /^[A-Za-z0-9:_-]+/.exec(content.slice(scriptNameStart));
+    if (!scriptNameMatch) {
+      result += marker;
+      cursor = scriptNameStart;
+      continue;
+    }
+    const scriptName = scriptNameMatch[0];
+    const argsStart = scriptNameStart + scriptName.length;
+    const { args, cursor: nextCursor } = consumeCommandArguments(content, argsStart);
+    result += formatRunScript(packageManagerId, scriptName, args);
+    cursor = nextCursor;
+  }
+  return result;
+}
+function replaceDevDependencyInstalls(content, packageManagerId) {
+  return content.replace(/\bbun add -d ([^\s&|;`"'()]+)\b/g, (_, packageName) => {
+    if (packageManagerId === "bun") {
+      return `bun add -d ${packageName}`;
+    }
+    return `${packageManagerId} ${DEV_INSTALL_FLAGS[packageManagerId]} ${packageName}`;
+  });
+}
+function transformPackageManagerText(content, packageManagerId) {
+  const manager = getPackageManager(packageManagerId);
+  return replaceDevDependencyInstalls(replaceBunRunCommands(content.replace(/\bbun install --frozen-lockfile\b/g, manager.frozenInstallCommand).replace(/\bbun install\b/g, manager.installCommand), packageManagerId), packageManagerId).replace(/\s*&&\s*/g, " && ").replace(/\s*\|\|\s*/g, " || ");
+}
+
+// src/runtime/template-registry.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+function resolvePackageRoot(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+        if (packageJson.name === "@wp-typia/create") {
+          return currentDir;
+        }
+      } catch {}
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      throw new Error("Unable to resolve the @wp-typia/create package root.");
+    }
+    currentDir = parentDir;
+  }
+}
+var TEMPLATE_ROOT = path.join(resolvePackageRoot(__dirname2), "templates");
+var TEMPLATE_REGISTRY = Object.freeze([
+  {
+    id: "basic",
+    description: "A lightweight WordPress block with Typia validation",
+    defaultCategory: "text",
+    features: ["Type-safe attributes", "Runtime validation", "Minimal setup"],
+    templateDir: path.join(TEMPLATE_ROOT, "basic")
+  },
+  {
+    id: "full",
+    description: "A full-featured WordPress block with Typia validation and utilities",
+    defaultCategory: "widgets",
+    features: ["Advanced controls", "Custom hooks", "Style options"],
+    templateDir: path.join(TEMPLATE_ROOT, "full")
+  },
+  {
+    id: "interactivity",
+    description: "An interactive WordPress block with Typia validation and Interactivity API",
+    defaultCategory: "widgets",
+    features: ["Interactivity API", "Client-side state", "Event handling"],
+    templateDir: path.join(TEMPLATE_ROOT, "interactivity")
+  },
+  {
+    id: "advanced",
+    description: "An advanced WordPress block with Typia validation and migration tooling",
+    defaultCategory: "widgets",
+    features: ["Migration system", "Version tracking", "Admin dashboard"],
+    templateDir: path.join(TEMPLATE_ROOT, "advanced")
+  }
+]);
+var TEMPLATE_IDS = TEMPLATE_REGISTRY.map((template) => template.id);
+function listTemplates() {
+  return TEMPLATE_REGISTRY;
+}
+function getTemplateById(templateId) {
+  const template = TEMPLATE_REGISTRY.find((entry) => entry.id === templateId);
+  if (!template) {
+    throw new Error(`Unknown template "${templateId}". Expected one of: ${TEMPLATE_IDS.join(", ")}`);
+  }
+  return template;
+}
+function getTemplateSelectOptions() {
+  return TEMPLATE_REGISTRY.map((template) => ({
+    label: template.id,
+    value: template.id,
+    hint: template.features.join(", ")
+  }));
+}
+
+// src/runtime/scaffold.ts
+var BLOCK_SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
+var LOCKFILES = {
+  bun: ["bun.lock", "bun.lockb"],
+  npm: ["package-lock.json"],
+  pnpm: ["pnpm-lock.yaml"],
+  yarn: ["yarn.lock"]
+};
+function toKebabCase(input) {
+  return input.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").toLowerCase();
+}
+function toSnakeCase(input) {
+  return toKebabCase(input).replace(/-/g, "_");
+}
+function toPascalCase(input) {
+  return toKebabCase(input).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
+function toTitle(input) {
+  return toKebabCase(input).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+}
+function validateBlockSlug(input) {
+  return BLOCK_SLUG_PATTERN.test(input) || "Use lowercase letters, numbers, and hyphens only";
+}
+function detectAuthor() {
+  try {
+    return execSync("git config user.name", {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim() || "Your Name";
+  } catch {
+    return "Your Name";
+  }
+}
+function getDefaultAnswers(projectName, templateId) {
+  const template = getTemplateById(templateId);
+  const slugDefault = toKebabCase(projectName || "my-wp-typia-block");
+  return {
+    author: detectAuthor(),
+    description: template.description,
+    namespace: "create-block",
+    slug: slugDefault,
+    title: toTitle(slugDefault)
+  };
+}
+async function resolveTemplateId({
+  templateId,
+  yes = false,
+  isInteractive = false,
+  selectTemplate
+}) {
+  if (templateId) {
+    return getTemplateById(templateId).id;
+  }
+  if (yes) {
+    return "basic";
+  }
+  if (!isInteractive || !selectTemplate) {
+    throw new Error(`Template is required in non-interactive mode. Use --template <${TEMPLATE_IDS.join("|")}>.`);
+  }
+  return selectTemplate();
+}
+async function resolvePackageManagerId({
+  packageManager,
+  yes = false,
+  isInteractive = false,
+  selectPackageManager
+}) {
+  if (packageManager) {
+    return getPackageManager(packageManager).id;
+  }
+  if (yes) {
+    throw new Error(`Package manager is required when using --yes. Use --package-manager <${PACKAGE_MANAGER_IDS.join("|")}>.`);
+  }
+  if (!isInteractive || !selectPackageManager) {
+    throw new Error(`Package manager is required in non-interactive mode. Use --package-manager <${PACKAGE_MANAGER_IDS.join("|")}>.`);
+  }
+  return selectPackageManager();
+}
+async function collectScaffoldAnswers({
+  projectName,
+  templateId,
+  yes = false,
+  promptText
+}) {
+  const defaults = getDefaultAnswers(projectName, templateId);
+  if (yes) {
+    return defaults;
+  }
+  if (!promptText) {
+    throw new Error("Interactive answers require a promptText callback.");
+  }
+  const slug = toKebabCase(await promptText("Block slug", defaults.slug, validateBlockSlug));
+  return {
+    author: await promptText("Author", defaults.author),
+    description: await promptText("Description", defaults.description),
+    namespace: await promptText("Namespace", defaults.namespace),
+    slug,
+    title: await promptText("Block title", toTitle(slug))
+  };
+}
+function getTemplateVariables(templateId, answers) {
+  const template = getTemplateById(templateId);
+  const slug = toKebabCase(answers.slug);
+  const slugSnakeCase = toSnakeCase(slug);
+  const pascalCase = toPascalCase(slug);
+  const title = answers.title.trim();
+  const namespace = answers.namespace.trim();
+  const description = answers.description.trim();
+  return {
+    author: answers.author.trim(),
+    category: template.defaultCategory,
+    cssClassName: `wp-block-${slug}`,
+    dashCase: slug,
+    dashicon: "smiley",
+    description,
+    keyword: slug.replace(/-/g, " "),
+    namespace,
+    needsMigration: "{{needsMigration}}",
+    pascalCase,
+    slug,
+    slugCamelCase: pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1),
+    slugKebabCase: slug,
+    slugSnakeCase,
+    textDomain: slugSnakeCase,
+    textdomain: slugSnakeCase,
+    title,
+    titleCase: pascalCase
+  };
+}
+function replaceVariables(content, variables) {
+  return content.replace(/\{\{([^}]+)\}\}/g, (match, rawKey) => {
+    const key = rawKey.trim();
+    return Object.prototype.hasOwnProperty.call(variables, key) ? variables[key] : match;
+  });
+}
+async function ensureDirectory(targetDir, allowExisting = false) {
+  if (!fs2.existsSync(targetDir)) {
+    await fsp.mkdir(targetDir, { recursive: true });
+    return;
+  }
+  if (allowExisting) {
+    return;
+  }
+  const entries = await fsp.readdir(targetDir);
+  if (entries.length > 0) {
+    throw new Error(`Target directory is not empty: ${targetDir}`);
+  }
+}
+async function copyTemplateDir(sourceDir, targetDir, variables) {
+  const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourcePath = path2.join(sourceDir, entry.name);
+    const destinationName = entry.name.endsWith(".mustache") ? entry.name.slice(0, -".mustache".length) : entry.name;
+    const destinationPath = path2.join(targetDir, destinationName);
+    if (entry.isDirectory()) {
+      await fsp.mkdir(destinationPath, { recursive: true });
+      await copyTemplateDir(sourcePath, destinationPath, variables);
+      continue;
+    }
+    const content = await fsp.readFile(sourcePath, "utf8");
+    await fsp.writeFile(destinationPath, replaceVariables(content, variables), "utf8");
+  }
+}
+function buildReadme(templateId, variables, packageManager) {
+  return `# ${variables.title}
+
+${variables.description}
+
+## Template
+
+${templateId}
+
+## Development
+
+\`\`\`bash
+${formatInstallCommand(packageManager)}
+${formatRunScript(packageManager, "start")}
+\`\`\`
+
+## Build
+
+\`\`\`bash
+${formatRunScript(packageManager, "build")}
+\`\`\`
+
+## Type Sync
+
+\`\`\`bash
+${formatRunScript(packageManager, "sync-types")}
+\`\`\`
+
+\`src/types.ts\` remains the source of truth for \`block.json\` and \`typia.manifest.json\`.
+`;
+}
+function buildGitignore() {
+  return `# Dependencies
+node_modules/
+.yarn/
+.pnp.*
+
+# Build
+build/
+dist/
+
+# Editor
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# WordPress
+*.log
+.wp-env/
+`;
+}
+async function normalizePackageManagerFiles(targetDir, packageManagerId) {
+  const yarnRcPath = path2.join(targetDir, ".yarnrc.yml");
+  if (packageManagerId === "yarn") {
+    await fsp.writeFile(yarnRcPath, `nodeLinker: node-modules
+`, "utf8");
+    return;
+  }
+  if (fs2.existsSync(yarnRcPath)) {
+    await fsp.rm(yarnRcPath, { force: true });
+  }
+}
+async function normalizePackageJson(targetDir, packageManagerId) {
+  const packageJsonPath = path2.join(targetDir, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    return;
+  }
+  const packageManager = getPackageManager(packageManagerId);
+  const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, "utf8"));
+  packageJson.packageManager = packageManager.packageManagerField;
+  if (packageJson.scripts) {
+    for (const [key, value] of Object.entries(packageJson.scripts)) {
+      if (typeof value === "string") {
+        packageJson.scripts[key] = transformPackageManagerText(value, packageManagerId);
+      }
+    }
+  }
+  await fsp.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+`, "utf8");
+}
+async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
+  const keep = new Set(LOCKFILES[packageManagerId] ?? []);
+  const allLockfiles = Object.values(LOCKFILES).flat();
+  await Promise.all(allLockfiles.map(async (filename) => {
+    if (keep.has(filename)) {
+      return;
+    }
+    const filePath = path2.join(targetDir, filename);
+    if (fs2.existsSync(filePath)) {
+      await fsp.rm(filePath, { force: true });
+    }
+  }));
+}
+async function replaceTextRecursively(targetDir, packageManagerId) {
+  const textExtensions = new Set([
+    ".css",
+    ".js",
+    ".json",
+    ".jsx",
+    ".md",
+    ".php",
+    ".scss",
+    ".ts",
+    ".tsx",
+    ".txt"
+  ]);
+  async function visit(currentPath) {
+    const stats = await fsp.stat(currentPath);
+    if (stats.isDirectory()) {
+      const entries = await fsp.readdir(currentPath);
+      for (const entry of entries) {
+        await visit(path2.join(currentPath, entry));
+      }
+      return;
+    }
+    if (path2.basename(currentPath) === "package.json" || !textExtensions.has(path2.extname(currentPath))) {
+      return;
+    }
+    const content = await fsp.readFile(currentPath, "utf8");
+    const nextContent = transformPackageManagerText(content, packageManagerId).replace(/yourusername\/wp-typia-boilerplate/g, "imjlk/wp-typia").replace(/yourusername\/wp-typia/g, "imjlk/wp-typia");
+    if (nextContent !== content) {
+      await fsp.writeFile(currentPath, nextContent, "utf8");
+    }
+  }
+  await visit(targetDir);
+}
+async function defaultInstallDependencies({
+  projectDir,
+  packageManager
+}) {
+  execSync(formatInstallCommand(packageManager), {
+    cwd: projectDir,
+    stdio: "inherit"
+  });
+}
+async function scaffoldProject({
+  projectDir,
+  templateId,
+  answers,
+  packageManager,
+  allowExistingDir = false,
+  noInstall = false,
+  installDependencies = undefined
+}) {
+  const template = getTemplateById(templateId);
+  const resolvedPackageManager = getPackageManager(packageManager).id;
+  await ensureDirectory(projectDir, allowExistingDir);
+  const variables = getTemplateVariables(template.id, answers);
+  await copyTemplateDir(template.templateDir, projectDir, variables);
+  const readmePath = path2.join(projectDir, "README.md");
+  if (!fs2.existsSync(readmePath)) {
+    await fsp.writeFile(readmePath, buildReadme(template.id, variables, resolvedPackageManager), "utf8");
+  }
+  await fsp.writeFile(path2.join(projectDir, ".gitignore"), buildGitignore(), "utf8");
+  await normalizePackageJson(projectDir, resolvedPackageManager);
+  await normalizePackageManagerFiles(projectDir, resolvedPackageManager);
+  await removeUnexpectedLockfiles(projectDir, resolvedPackageManager);
+  await replaceTextRecursively(projectDir, resolvedPackageManager);
+  if (!noInstall) {
+    const installer = installDependencies ?? defaultInstallDependencies;
+    await installer({
+      projectDir,
+      packageManager: resolvedPackageManager
+    });
+  }
+  return {
+    projectDir,
+    templateId: template.id,
+    packageManager: resolvedPackageManager,
+    variables
+  };
+}
+
+// src/runtime/cli-core.ts
+function createReadlinePrompt() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return {
+    async text(message, defaultValue, validate) {
+      const suffix = defaultValue ? ` (${defaultValue})` : "";
+      const answer = await new Promise((resolve) => {
+        rl.question(`${message}${suffix}: `, resolve);
+      });
+      const value = String(answer).trim() || defaultValue;
+      if (validate) {
+        const result = validate(value);
+        if (result !== true) {
+          console.error(`❌ ${typeof result === "string" ? result : "Invalid input"}`);
+          return this.text(message, defaultValue, validate);
+        }
+      }
+      return value;
+    },
+    async select(message, options, defaultValue = 1) {
+      console.log(message);
+      options.forEach((option, index) => {
+        const hint = option.hint ? ` - ${option.hint}` : "";
+        console.log(`  ${index + 1}. ${option.label}${hint}`);
+      });
+      const answer = await this.text("Choice", String(defaultValue));
+      const numericChoice = Number(answer);
+      if (!Number.isNaN(numericChoice) && options[numericChoice - 1]) {
+        return options[numericChoice - 1].value;
+      }
+      const directChoice = options.find((option) => option.value === answer);
+      if (directChoice) {
+        return directChoice.value;
+      }
+      console.error(`❌ Invalid selection: ${answer}`);
+      return this.select(message, options, defaultValue);
+    },
+    close() {
+      rl.close();
+    }
+  };
+}
+function formatHelpText() {
+  return `Usage:
+  wp-typia <project-dir> [--template <id>] [--yes] [--no-install] [--package-manager <id>]
+  wp-typia templates list
+  wp-typia templates inspect <id>
+  wp-typia migrations <init|snapshot|diff|scaffold|verify> [...]
+  wp-typia doctor
+
+Templates: ${TEMPLATE_IDS.join(", ")}
+Package managers: ${PACKAGE_MANAGER_IDS.join(", ")}`;
+}
+function formatTemplateSummary(template) {
+  return `${template.id.padEnd(14)} ${template.description}`;
+}
+function formatTemplateFeatures(template) {
+  return `  ${template.features.join(" • ")}`;
+}
+function formatTemplateDetails(template) {
+  return [
+    template.id,
+    template.description,
+    `Category: ${template.defaultCategory}`,
+    `Path: ${template.templateDir}`,
+    `Features: ${template.features.join(", ")}`
+  ].join(`
+`);
+}
+function readCommandVersion(command, args = ["--version"]) {
+  try {
+    return execFileSync(command, args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function compareMajorVersion(actualVersion, minimumMajor) {
+  const parsed = Number.parseInt(actualVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
+  return Number.isFinite(parsed) && parsed >= minimumMajor;
+}
+async function checkWritableDirectory(directory) {
+  try {
+    await access(directory, fsConstants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkTempDirectory() {
+  const tempFile = path3.join(os.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+  try {
+    await writeFile(tempFile, "ok", "utf8");
+    await rm(tempFile, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getDoctorChecks(cwd) {
+  const checks = [];
+  const bunVersion = readCommandVersion("bun");
+  const nodeVersion = readCommandVersion("node");
+  const gitVersion = readCommandVersion("git");
+  const cwdWritable = await checkWritableDirectory(cwd);
+  const tempWritable = await checkTempDirectory();
+  checks.push({
+    status: bunVersion && compareMajorVersion(bunVersion, 1) ? "pass" : "fail",
+    label: "Bun",
+    detail: bunVersion ? `Detected ${bunVersion}` : "Not available"
+  });
+  checks.push({
+    status: nodeVersion && compareMajorVersion(nodeVersion, 16) ? "pass" : "fail",
+    label: "Node",
+    detail: nodeVersion ? `Detected ${nodeVersion}` : "Not available"
+  });
+  checks.push({
+    status: gitVersion ? "pass" : "fail",
+    label: "git",
+    detail: gitVersion ?? "Not available"
+  });
+  checks.push({
+    status: cwdWritable ? "pass" : "fail",
+    label: "Current directory",
+    detail: cwdWritable ? "Writable" : "Not writable"
+  });
+  checks.push({
+    status: tempWritable ? "pass" : "fail",
+    label: "Temp directory",
+    detail: tempWritable ? "Writable" : "Not writable"
+  });
+  for (const template of listTemplates()) {
+    const hasAssets = fs3.existsSync(template.templateDir) && fs3.existsSync(path3.join(template.templateDir, "package.json.mustache"));
+    checks.push({
+      status: hasAssets ? "pass" : "fail",
+      label: `Template ${template.id}`,
+      detail: hasAssets ? template.templateDir : "Missing core template assets"
+    });
+  }
+  return checks;
+}
+async function runDoctor(cwd, { renderLine = (check) => console.log(`${check.status.toUpperCase()} ${check.label}: ${check.detail}`) } = {}) {
+  const checks = await getDoctorChecks(cwd);
+  for (const check of checks) {
+    renderLine(check);
+  }
+  if (checks.some((check) => check.status === "fail")) {
+    throw new Error("Doctor found one or more failing checks.");
+  }
+  return checks;
+}
+function getNextSteps({
+  projectInput,
+  projectDir,
+  packageManager,
+  noInstall
+}) {
+  const steps = [`cd ${path3.isAbsolute(projectInput) ? projectDir : projectInput}`];
+  if (noInstall) {
+    steps.push(formatInstallCommand(packageManager));
+  }
+  steps.push(formatRunScript(packageManager, "start"));
+  return steps;
+}
+async function runScaffoldFlow({
+  projectInput,
+  cwd = process.cwd(),
+  templateId,
+  packageManager,
+  yes = false,
+  noInstall = false,
+  isInteractive = false,
+  allowExistingDir = false,
+  selectTemplate,
+  selectPackageManager,
+  promptText,
+  installDependencies = undefined
+}) {
+  if (!projectInput) {
+    throw new Error("Project directory is required. Usage: wp-typia <project-dir>");
+  }
+  const resolvedTemplateId = await resolveTemplateId({
+    templateId,
+    yes,
+    isInteractive,
+    selectTemplate
+  });
+  const resolvedPackageManager = await resolvePackageManagerId({
+    packageManager,
+    yes,
+    isInteractive,
+    selectPackageManager
+  });
+  const projectDir = path3.resolve(cwd, projectInput);
+  const projectName = path3.basename(projectDir);
+  const answers = await collectScaffoldAnswers({
+    projectName,
+    templateId: resolvedTemplateId,
+    yes,
+    promptText
+  });
+  const result = await scaffoldProject({
+    answers,
+    allowExistingDir,
+    installDependencies,
+    noInstall,
+    packageManager: resolvedPackageManager,
+    projectDir,
+    templateId: resolvedTemplateId
+  });
+  return {
+    projectDir,
+    projectInput,
+    packageManager: resolvedPackageManager,
+    result,
+    nextSteps: getNextSteps({
+      projectInput,
+      projectDir,
+      packageManager: resolvedPackageManager,
+      noInstall
+    })
+  };
+}
+
+// src/runtime/migrations.ts
+import fs9 from "node:fs";
+import path10 from "node:path";
+import { execSync as execSync3 } from "node:child_process";
+
+// src/runtime/migration-constants.ts
+import path4 from "node:path";
+var ROOT_BLOCK_JSON = "block.json";
+var ROOT_MANIFEST = "typia.manifest.json";
+var ROOT_PHP_MIGRATION_REGISTRY = "typia-migration-registry.php";
+var ROOT_SAVE_FILE = path4.join("src", "save.tsx");
+var ROOT_TYPES_FILE = path4.join("src", "types.ts");
+var MIGRATIONS_DIR = path4.join("src", "migrations");
+var CONFIG_FILE = path4.join(MIGRATIONS_DIR, "config.ts");
+var GENERATED_DIR = path4.join(MIGRATIONS_DIR, "generated");
+var FIXTURES_DIR = path4.join(MIGRATIONS_DIR, "fixtures");
+var RULES_DIR = path4.join(MIGRATIONS_DIR, "rules");
+var SNAPSHOT_DIR = path4.join(MIGRATIONS_DIR, "versions");
+var SUPPORTED_PROJECT_FILES = ["package.json", ROOT_BLOCK_JSON, ROOT_SAVE_FILE, ROOT_TYPES_FILE];
+var MIGRATION_TODO_PREFIX = "TODO MIGRATION:";
+
+// src/runtime/migration-diff.ts
+import fs5 from "node:fs";
+import path6 from "node:path";
+
+// 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;
+  }
+}
+
+// src/runtime/migration-utils.ts
+import fs4 from "node:fs";
+import path5 from "node:path";
+import { execSync as execSync2 } from "node:child_process";
+function cloneJsonValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function getValueAtPath(input, pathLabel) {
+  return String(pathLabel).split(".").reduce((value, segment) => value && typeof value === "object" ? value[segment] : undefined, input);
+}
+function setValueAtPath(input, pathLabel, value) {
+  const segments = String(pathLabel).split(".");
+  let target = 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 deleteValueAtPath(input, pathLabel) {
+  const segments = String(pathLabel).split(".");
+  let target = input;
+  while (segments.length > 1) {
+    const segment = segments.shift();
+    if (!segment || !target[segment] || typeof target[segment] !== "object") {
+      return;
+    }
+    target = target[segment];
+  }
+  delete target[segments[0]];
+}
+function createFixtureScalarValue(pathLabel) {
+  const normalized = String(pathLabel).toLowerCase();
+  if (normalized.includes("id")) {
+    return "00000000-0000-4000-8000-000000000000";
+  }
+  if (normalized.includes("count") || normalized.includes("number")) {
+    return 1;
+  }
+  if (normalized.includes("visible") || normalized.startsWith("is")) {
+    return true;
+  }
+  return `legacy:${pathLabel}`;
+}
+function createTransformFixtureValue(attribute, pathLabel) {
+  switch (attribute?.ts?.kind) {
+    case "number":
+      return "42";
+    case "boolean":
+      return "1";
+    case "union":
+      return { kind: "unknown" };
+    default:
+      return createFixtureScalarValue(pathLabel);
+  }
+}
+function readJson(filePath) {
+  return JSON.parse(fs4.readFileSync(filePath, "utf8"));
+}
+function renderPhpValue(value, indentLevel) {
+  const indent = "\t".repeat(indentLevel);
+  const nestedIndent = "\t".repeat(indentLevel + 1);
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((item) => `${nestedIndent}${renderPhpValue(item, indentLevel + 1)}`);
+    return `[
+${items.join(`,
+`)}
+${indent}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return "[]";
+    }
+    const items = entries.map(([key, item]) => `${nestedIndent}'${String(key).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}' => ${renderPhpValue(item, indentLevel + 1)}`);
+    return `[
+${items.join(`,
+`)}
+${indent}]`;
+  }
+  throw new Error(`Unable to encode PHP migration registry value for ${String(value)}`);
+}
+function copyFile(sourcePath, targetPath) {
+  fs4.mkdirSync(path5.dirname(targetPath), { recursive: true });
+  fs4.copyFileSync(sourcePath, targetPath);
+}
+function sanitizeSaveSnapshotSource(source) {
+  return source.replace(/^import\s+\{[^}]+\}\s+from\s+['"]\.\/types['"];?\n?/gm, "").replace(/^interface\s+SaveProps\s*\{[\s\S]*?\}\n?/m, "").replace(/: SaveProps/g, ": { attributes: any }").replace(/attributes:\s*[A-Za-z0-9_<>{}\[\]|&,\s]+;/g, "attributes: any;").replace(/\(\{\s*attributes\s*\}:\s*\{\s*attributes:\s*any\s*\}\)/g, "({ attributes }: { attributes: any })");
+}
+function sanitizeSnapshotBlockJson(blockJson) {
+  const snapshot = { ...blockJson };
+  for (const key of [
+    "editorScript",
+    "script",
+    "scriptModule",
+    "viewScript",
+    "viewScriptModule",
+    "style",
+    "editorStyle",
+    "render"
+  ]) {
+    delete snapshot[key];
+  }
+  return snapshot;
+}
+function runProjectScriptIfPresent(projectDir, scriptName) {
+  const packageJson = readJson(path5.join(projectDir, "package.json"));
+  if (!packageJson.scripts?.[scriptName]) {
+    return;
+  }
+  const packageManagerId = detectPackageManagerId(projectDir);
+  execSync2(formatRunScript(packageManagerId, scriptName), {
+    cwd: projectDir,
+    stdio: "inherit"
+  });
+}
+function detectPackageManagerId(projectDir) {
+  const packageJson = readJson(path5.join(projectDir, "package.json"));
+  const field = String(packageJson.packageManager ?? "");
+  if (field.startsWith("bun@"))
+    return "bun";
+  if (field.startsWith("npm@"))
+    return "npm";
+  if (field.startsWith("pnpm@"))
+    return "pnpm";
+  if (field.startsWith("yarn@"))
+    return "yarn";
+  return "bun";
+}
+function getLocalTsxBinary(projectDir) {
+  const filename = process.platform === "win32" ? "tsx.cmd" : "tsx";
+  const binaryPath = path5.join(projectDir, "node_modules", ".bin", filename);
+  if (!fs4.existsSync(binaryPath)) {
+    throw new Error("Local tsx binary was not found. Install project dependencies before running migration verification.");
+  }
+  return binaryPath;
+}
+function resolveTargetVersion(currentVersion, value) {
+  return value === "current" ? currentVersion : value;
+}
+function assertSemver(value, label) {
+  if (!/^\d+\.\d+\.\d+$/.test(value)) {
+    throw new Error(`Invalid ${label}: ${value}. Expected x.y.z`);
+  }
+}
+function compareSemver(left, right) {
+  const leftParts = left.split(".").map((part) => Number.parseInt(part, 10));
+  const rightParts = right.split(".").map((part) => Number.parseInt(part, 10));
+  for (let index = 0;index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const delta = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (delta !== 0) {
+      return delta;
+    }
+  }
+  return 0;
+}
+function escapeForCode(value) {
+  return String(value).replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function renderObjectKey(key) {
+  return JSON.stringify(String(key));
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/runtime/migration-diff.ts
+function createMigrationDiff(state, fromVersion, toVersion) {
+  const snapshotManifestPath = path6.join(state.projectDir, SNAPSHOT_DIR, fromVersion, ROOT_MANIFEST);
+  if (!fs5.existsSync(snapshotManifestPath)) {
+    throw new Error(`Snapshot manifest for ${fromVersion} does not exist. Run \`migrations snapshot --version ${fromVersion}\` first.`);
+  }
+  const targetManifest = toVersion === state.config.currentVersion ? state.currentManifest : readJson(path6.join(state.projectDir, SNAPSHOT_DIR, toVersion, ROOT_MANIFEST));
+  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(oldAttributes, newAttributes, removedKeys, addedKeys, oldLeafAttributes, newLeafAttributes);
+  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 ?? state.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 nested;
+    }
+  }
+  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 createRenameCandidates(oldAttributes, newAttributes, removedKeys, addedKeys, oldLeafAttributes, newLeafAttributes) {
+  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);
+      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);
+      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 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 isRenameCandidateShapeCompatible(oldAttribute, newAttribute) {
+  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 compareUnionAttribute(oldAttribute, newAttribute, "$rename").status === "auto";
+  }
+  return false;
+}
+function assessRenameCandidate(oldAttribute, newAttribute, legacyPath, currentPath) {
+  if (!isRenameCandidateShapeCompatible(oldAttribute, newAttribute)) {
+    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 passesNameSimilarityRule(legacyPath, currentPath) {
+  return scoreRenameSimilarity(legacyPath, currentPath) >= 0.6;
+}
+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} → ${currentPath})`;
+  }
+  if (score >= 0.9)
+    return "high-confidence compatible field";
+  if (score >= 0.6)
+    return "name-similar compatible field";
+  return "compatible field requiring review";
+}
+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}`];
+  }
+}
+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 autoOutcome(pathLabel, kind, detail) {
+  return { detail, kind, path: pathLabel, status: "auto" };
+}
+function manualOutcome(pathLabel, kind, detail) {
+  return { detail, kind, path: pathLabel, status: "manual" };
+}
+
+// src/runtime/migration-fixtures.ts
+import fs6 from "node:fs";
+import path7 from "node:path";
+function ensureEdgeFixtureFile(projectDir, fromVersion, toVersion, diff) {
+  const fixturePath = path7.join(projectDir, FIXTURES_DIR, `${fromVersion}-to-${toVersion}.json`);
+  if (fs6.existsSync(fixturePath)) {
+    return;
+  }
+  const manifest = readJson(path7.join(projectDir, SNAPSHOT_DIR, fromVersion, ROOT_MANIFEST));
+  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)
+  ];
+  const fixtureDocument = {
+    cases,
+    fromVersion,
+    toVersion
+  };
+  fs6.writeFileSync(fixturePath, `${JSON.stringify(fixtureDocument, null, "\t")}
+`, "utf8");
+}
+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
+  };
+}
+
+// src/runtime/migration-project.ts
+import fs7 from "node:fs";
+import path8 from "node:path";
+function ensureAdvancedMigrationProject(projectDir) {
+  const missing = SUPPORTED_PROJECT_FILES.filter((relativePath) => !fs7.existsSync(path8.join(projectDir, relativePath)));
+  if (missing.length > 0) {
+    throw new Error(`This directory is not a supported advanced migration project. Missing: ${missing.join(", ")}`);
+  }
+}
+function getProjectPaths(projectDir) {
+  return {
+    configFile: path8.join(projectDir, CONFIG_FILE),
+    fixturesDir: path8.join(projectDir, FIXTURES_DIR),
+    generatedDir: path8.join(projectDir, GENERATED_DIR),
+    rulesDir: path8.join(projectDir, RULES_DIR),
+    snapshotDir: path8.join(projectDir, SNAPSHOT_DIR)
+  };
+}
+function ensureMigrationDirectories(projectDir) {
+  const paths = getProjectPaths(projectDir);
+  fs7.mkdirSync(paths.fixturesDir, { recursive: true });
+  fs7.mkdirSync(paths.generatedDir, { recursive: true });
+  fs7.mkdirSync(paths.rulesDir, { recursive: true });
+  fs7.mkdirSync(paths.snapshotDir, { recursive: true });
+}
+function writeInitialMigrationScaffold(projectDir, currentVersion) {
+  const paths = getProjectPaths(projectDir);
+  const readmeFiles = [
+    [path8.join(paths.snapshotDir, "README.md"), `# Version Snapshots
+
+Snapshots for ${currentVersion} and future versions live here.
+`],
+    [path8.join(paths.rulesDir, "README.md"), `# Migration Rules
+
+Scaffold direct legacy-to-current migration rules in this directory.
+`],
+    [path8.join(paths.fixturesDir, "README.md"), `# Migration Fixtures
+
+Generated fixtures are used by verify to assert migrations.
+`]
+  ];
+  for (const [targetPath, content] of readmeFiles) {
+    if (!fs7.existsSync(targetPath)) {
+      fs7.writeFileSync(targetPath, content, "utf8");
+    }
+  }
+}
+function loadMigrationProject(projectDir, { allowMissingConfig = false } = {}) {
+  ensureAdvancedMigrationProject(projectDir);
+  if (!fs7.existsSync(path8.join(projectDir, ROOT_MANIFEST))) {
+    runProjectScriptIfPresent(projectDir, "sync-types");
+  }
+  const paths = getProjectPaths(projectDir);
+  const config = allowMissingConfig && !fs7.existsSync(paths.configFile) ? {
+    blockName: readProjectBlockName(projectDir),
+    currentVersion: "0.0.0",
+    snapshotDir: SNAPSHOT_DIR.replace(/\\/g, "/"),
+    supportedVersions: []
+  } : parseMigrationConfig(fs7.readFileSync(paths.configFile, "utf8"));
+  return {
+    config,
+    currentBlockJson: readJson(path8.join(projectDir, ROOT_BLOCK_JSON)),
+    currentManifest: readJson(path8.join(projectDir, ROOT_MANIFEST)),
+    paths,
+    projectDir
+  };
+}
+function discoverMigrationEntries(state) {
+  const entries = [];
+  const currentVersion = state.config.currentVersion;
+  for (const version of state.config.supportedVersions) {
+    if (version === currentVersion) {
+      continue;
+    }
+    const snapshotRoot = path8.join(state.projectDir, SNAPSHOT_DIR, version);
+    const manifestPath = path8.join(snapshotRoot, ROOT_MANIFEST);
+    const blockJsonPath = path8.join(snapshotRoot, ROOT_BLOCK_JSON);
+    const savePath = path8.join(snapshotRoot, "save.tsx");
+    const rulePath = getRuleFilePath(state.paths, version, currentVersion);
+    if (fs7.existsSync(manifestPath) && fs7.existsSync(blockJsonPath) && fs7.existsSync(savePath) && fs7.existsSync(rulePath)) {
+      entries.push({
+        blockJsonImport: `../versions/${version}/block.json`,
+        fixtureImport: `../fixtures/${version}-to-${currentVersion}.json`,
+        fromVersion: version,
+        manifestImport: `../versions/${version}/typia.manifest.json`,
+        ruleImport: `../rules/${version}-to-${currentVersion}`,
+        rulePath,
+        saveImport: `../versions/${version}/save`,
+        toVersion: currentVersion
+      });
+    }
+  }
+  return entries.sort((left, right) => compareSemver(right.fromVersion, left.fromVersion));
+}
+function parseMigrationConfig(source) {
+  const blockName = matchConfigValue(source, "blockName");
+  const currentVersion = matchConfigValue(source, "currentVersion");
+  const snapshotDir = matchConfigValue(source, "snapshotDir");
+  const supportedVersionsMatch = source.match(/supportedVersions:\s*\[([\s\S]*?)\]/);
+  if (!blockName || !currentVersion || !snapshotDir || !supportedVersionsMatch) {
+    throw new Error("Unable to parse migration config. Regenerate with `wp-typia migrations init`.");
+  }
+  const supportedVersions = supportedVersionsMatch[1].split(",").map((item) => item.trim().replace(/^["']|["']$/g, "")).filter(Boolean).sort(compareSemver);
+  return {
+    blockName,
+    currentVersion,
+    snapshotDir,
+    supportedVersions
+  };
+}
+function matchConfigValue(source, key) {
+  return source.match(new RegExp(`${key}:\\s*"([^"]+)"`))?.[1] ?? null;
+}
+function writeMigrationConfig(projectDir, config) {
+  const paths = getProjectPaths(projectDir);
+  fs7.mkdirSync(path8.dirname(paths.configFile), { recursive: true });
+  fs7.writeFileSync(paths.configFile, `export const migrationConfig = {
+	blockName: "${config.blockName}",
+	currentVersion: "${config.currentVersion}",
+	supportedVersions: [${config.supportedVersions.map((version) => `"${version}"`).join(", ")}],
+	snapshotDir: "${config.snapshotDir}",
+} as const;
+
+export default migrationConfig;
+`, "utf8");
+}
+function readProjectBlockName(projectDir) {
+  const blockJson = readJson(path8.join(projectDir, ROOT_BLOCK_JSON));
+  const blockName = blockJson?.name;
+  if (typeof blockName !== "string" || blockName.length === 0) {
+    throw new Error("Unable to resolve block name from block.json");
+  }
+  return blockName;
+}
+function assertRuleHasNoTodos(projectDir, fromVersion, toVersion) {
+  const rulePath = getRuleFilePath(getProjectPaths(projectDir), fromVersion, toVersion);
+  if (!fs7.existsSync(rulePath)) {
+    throw new Error(`Missing migration rule: ${path8.relative(projectDir, rulePath)}`);
+  }
+  const source = fs7.readFileSync(rulePath, "utf8");
+  if (source.includes(MIGRATION_TODO_PREFIX)) {
+    throw new Error(`Migration rule still contains ${MIGRATION_TODO_PREFIX} markers: ${path8.relative(projectDir, rulePath)}`);
+  }
+}
+function getRuleFilePath(paths, fromVersion, toVersion) {
+  return path8.join(paths.rulesDir, `${fromVersion}-to-${toVersion}.ts`);
+}
+function readRuleMetadata(rulePath) {
+  const source = fs7.readFileSync(rulePath, "utf8");
+  const unresolvedBlock = source.match(/export const unresolved = \[([\s\S]*?)\] as const;/);
+  const renameMapBlock = source.match(/export const renameMap: RenameMap = \{([\s\S]*?)\};/);
+  const transformsBlock = source.match(/export const transforms: TransformMap = \{([\s\S]*?)\};/);
+  const unresolved = unresolvedBlock ? [...unresolvedBlock[1].matchAll(/"([^"]+)"/g)].map((match) => match[1]) : [];
+  const renameMap = renameMapBlock ? [...renameMapBlock[1].matchAll(/^\s*"([^"]+)":\s*"([^"]+)"/gm)].map((match) => ({
+    currentPath: match[1],
+    legacyPath: match[2]
+  })) : [];
+  const transforms = transformsBlock ? [...transformsBlock[1].matchAll(/^\s*"([^"]+)":\s*\(/gm)].map((match) => match[1]) : [];
+  return { renameMap, transforms, unresolved };
+}
+
+// src/runtime/migration-render.ts
+import fs8 from "node:fs";
+import path9 from "node:path";
+function formatDiffReport(diff) {
+  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})`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderMigrationRuleFile({
+  currentAttributes,
+  currentTypeName,
+  diff,
+  fromVersion,
+  targetVersion
+}) {
+  const activeRenameCandidates = diff.summary.renameCandidates.filter((candidate) => candidate.autoApply);
+  const suggestedRenameCandidates = diff.summary.renameCandidates.filter((candidate) => !candidate.autoApply);
+  const lines = [];
+  lines.push(`import type { ${currentTypeName} } from "../../types";`);
+  lines.push(`import currentManifest from "../../../${ROOT_MANIFEST}";`);
+  lines.push(`import {`);
+  lines.push(`	type RenameMap,`);
+  lines.push(`	type TransformMap,`);
+  lines.push(`	resolveMigrationAttribute,`);
+  lines.push(`} from "../helpers";`);
+  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(`
+`)}
+`;
+}
+function renderMigrationRegistryFile(state, entries) {
+  const imports = [`import currentManifest from "../../../${ROOT_MANIFEST}";`];
+  const body = [];
+  entries.forEach((entry, index) => {
+    imports.push(`import manifest_${index} from "${entry.manifestImport}";`);
+    imports.push(`import * as rule_${index} from "${entry.ruleImport}";`);
+    body.push(`	{`);
+    body.push(`		fromVersion: "${entry.fromVersion}",`);
+    body.push(`		manifest: manifest_${index},`);
+    body.push(`		rule: rule_${index},`);
+    body.push(`	},`);
+  });
+  return `${imports.join(`
+`)}
+
+export const migrationRegistry = {
+	currentVersion: "${state.config.currentVersion}",
+	currentManifest,
+	entries: [
+${body.join(`
+`)}
+	],
+} as const;
+
+export default migrationRegistry;
+`;
+}
+function renderGeneratedDeprecatedFile(entries) {
+  if (entries.length === 0) {
+    return `import type { BlockConfiguration } from "@wordpress/blocks";
+
+export const deprecated: NonNullable<BlockConfiguration["deprecated"]> = [];
+`;
+  }
+  const imports = [`import type { BlockConfiguration } from "@wordpress/blocks";`];
+  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}: NonNullable<BlockConfiguration["deprecated"]>[number] = {`);
+    definitions.push(`	attributes: (block_${index}.attributes ?? {}) as Record<string, unknown>,`);
+    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 `${imports.join(`
+`)}
+
+${definitions.join(`
+
+`)}
+
+export const deprecated: NonNullable<BlockConfiguration["deprecated"]> = [${arrayEntries.join(", ")}];
+`;
+}
+function renderPhpMigrationRegistryFile(state, entries) {
+  const snapshots = Object.fromEntries(state.config.supportedVersions.map((version) => {
+    const snapshotRoot = path9.join(state.projectDir, SNAPSHOT_DIR, version);
+    const manifestPath = path9.join(snapshotRoot, ROOT_MANIFEST);
+    const blockJsonPath = path9.join(snapshotRoot, ROOT_BLOCK_JSON);
+    const savePath = path9.join(snapshotRoot, "save.tsx");
+    return [
+      version,
+      {
+        blockJson: fs8.existsSync(blockJsonPath) ? {
+          attributeNames: Object.keys(readJson(blockJsonPath).attributes ?? {}),
+          name: readJson(blockJsonPath).name ?? null
+        } : null,
+        hasSaveSnapshot: fs8.existsSync(savePath),
+        manifest: fs8.existsSync(manifestPath) ? summarizeManifest(readJson(manifestPath)) : null
+      }
+    ];
+  }));
+  const edgeSummaries = entries.map((entry) => {
+    const ruleMetadata = readRuleMetadata(entry.rulePath);
+    const snapshotManifest = snapshots[entry.fromVersion]?.manifest ?? null;
+    return {
+      autoAppliedRenameCount: ruleMetadata.renameMap.length,
+      autoAppliedRenames: ruleMetadata.renameMap,
+      fromVersion: entry.fromVersion,
+      nestedPathRenames: ruleMetadata.renameMap.filter((item) => item.currentPath.includes(".")),
+      ruleFile: path9.relative(state.projectDir, entry.rulePath).replace(/\\/g, "/"),
+      toVersion: entry.toVersion,
+      transformKeys: ruleMetadata.transforms,
+      unionBranches: snapshotManifest ? summarizeUnionBranches(snapshotManifest) : [],
+      unresolved: ruleMetadata.unresolved
+    };
+  });
+  return `<?php
+declare(strict_types=1);
+
+/**
+ * Generated from advanced migration snapshots. Do not edit manually.
+ */
+return ${renderPhpValue({
+    blockName: state.config.blockName,
+    currentManifest: summarizeManifest(state.currentManifest),
+    currentVersion: state.config.currentVersion,
+    edges: edgeSummaries,
+    legacyVersions: state.config.supportedVersions.filter((version) => version !== state.config.currentVersion),
+    snapshotDir: state.config.snapshotDir,
+    snapshots,
+    supportedVersions: state.config.supportedVersions
+  }, 0)};
+`;
+}
+function renderVerifyFile(state, entries) {
+  const imports = [
+    `import { validators } from "../../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 (selectedVersions.length === 0 || selectedVersions.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 (!validation_${index}.success) {`);
+    checks.push(`				throw new Error("Current validator rejected migrated fixture for ${entry.fromVersion} case " + String(fixtureCase.name ?? "unknown") + ": " + JSON.stringify(validation_${index}.errors));`);
+    checks.push(`			}`);
+    checks.push(`		}`);
+    checks.push(`		console.log("Verified ${entry.fromVersion} -> ${entry.toVersion} (" + cases_${index}.length + " case(s))");`);
+    checks.push(`	}`);
+  });
+  return `${imports.join(`
+`)}
+
+const args = process.argv.slice(2);
+const selectedVersions =
+	args[0] === "--all"
+		? []
+		: args[0] === "--from" && 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 ${state.config.blockName}");
+`;
+}
+
+// src/runtime/migrations.ts
+function formatMigrationHelpText() {
+  return `Usage:
+  wp-typia migrations init --current-version <semver>
+  wp-typia migrations snapshot --version <semver>
+  wp-typia migrations diff --from <semver> [--to current]
+  wp-typia migrations scaffold --from <semver> [--to current]
+  wp-typia migrations verify [--from <semver>|--all]`;
+}
+function parseMigrationArgs(argv) {
+  const parsed = {
+    command: undefined,
+    flags: {
+      all: false,
+      currentVersion: undefined,
+      from: undefined,
+      to: "current",
+      version: undefined
+    }
+  };
+  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 === "--current-version") {
+      parsed.flags.currentVersion = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--current-version=")) {
+      parsed.flags.currentVersion = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--from") {
+      parsed.flags.from = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--from=")) {
+      parsed.flags.from = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--to") {
+      parsed.flags.to = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--to=")) {
+      parsed.flags.to = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--version") {
+      parsed.flags.version = next;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--version=")) {
+      parsed.flags.version = arg.split("=", 2)[1];
+      continue;
+    }
+    throw new Error(`Unknown migrations flag: ${arg}`);
+  }
+  return parsed;
+}
+function runMigrationCommand(command, cwd, { renderLine = console.log } = {}) {
+  switch (command.command) {
+    case "init":
+      if (!command.flags.currentVersion) {
+        throw new Error("`migrations init` requires --current-version <semver>.");
+      }
+      return initProjectMigrations(cwd, command.flags.currentVersion, { renderLine });
+    case "snapshot":
+      if (!command.flags.version) {
+        throw new Error("`migrations snapshot` requires --version <semver>.");
+      }
+      return snapshotProjectVersion(cwd, command.flags.version, { renderLine });
+    case "diff":
+      if (!command.flags.from) {
+        throw new Error("`migrations diff` requires --from <semver>.");
+      }
+      return diffProjectMigrations(cwd, {
+        fromVersion: command.flags.from,
+        renderLine,
+        toVersion: command.flags.to ?? "current"
+      });
+    case "scaffold":
+      if (!command.flags.from) {
+        throw new Error("`migrations scaffold` requires --from <semver>.");
+      }
+      return scaffoldProjectMigrations(cwd, {
+        fromVersion: command.flags.from,
+        renderLine,
+        toVersion: command.flags.to ?? "current"
+      });
+    case "verify":
+      return verifyProjectMigrations(cwd, {
+        all: command.flags.all,
+        fromVersion: command.flags.from,
+        renderLine
+      });
+    default:
+      throw new Error(formatMigrationHelpText());
+  }
+}
+function initProjectMigrations(projectDir, currentVersion, { renderLine = console.log } = {}) {
+  ensureAdvancedMigrationProject(projectDir);
+  assertSemver(currentVersion, "current version");
+  const blockName = readProjectBlockName(projectDir);
+  ensureMigrationDirectories(projectDir);
+  writeMigrationConfig(projectDir, {
+    blockName,
+    currentVersion,
+    snapshotDir: SNAPSHOT_DIR.replace(/\\/g, "/"),
+    supportedVersions: [currentVersion]
+  });
+  writeInitialMigrationScaffold(projectDir, currentVersion);
+  snapshotProjectVersion(projectDir, currentVersion, { renderLine, skipConfigUpdate: true });
+  regenerateGeneratedArtifacts(projectDir);
+  renderLine(`Initialized migrations for ${blockName} at version ${currentVersion}`);
+  return loadMigrationProject(projectDir);
+}
+function snapshotProjectVersion(projectDir, version, {
+  renderLine = console.log,
+  skipConfigUpdate = false
+} = {}) {
+  ensureAdvancedMigrationProject(projectDir);
+  assertSemver(version, "snapshot version");
+  runProjectScriptIfPresent(projectDir, "sync-types");
+  const state = loadMigrationProject(projectDir, { allowMissingConfig: skipConfigUpdate });
+  const snapshotRoot = path10.join(projectDir, SNAPSHOT_DIR, version);
+  fs9.mkdirSync(snapshotRoot, { recursive: true });
+  fs9.writeFileSync(path10.join(snapshotRoot, ROOT_BLOCK_JSON), `${JSON.stringify(sanitizeSnapshotBlockJson(readJson(path10.join(projectDir, ROOT_BLOCK_JSON))), null, "\t")}
+`, "utf8");
+  copyFile(path10.join(projectDir, ROOT_MANIFEST), path10.join(snapshotRoot, ROOT_MANIFEST));
+  fs9.writeFileSync(path10.join(snapshotRoot, "save.tsx"), sanitizeSaveSnapshotSource(fs9.readFileSync(path10.join(projectDir, ROOT_SAVE_FILE), "utf8")), "utf8");
+  if (!skipConfigUpdate) {
+    const nextSupported = [...new Set([...state.config.supportedVersions, version])].sort(compareSemver);
+    writeMigrationConfig(projectDir, {
+      ...state.config,
+      currentVersion: version,
+      supportedVersions: nextSupported
+    });
+  }
+  regenerateGeneratedArtifacts(projectDir);
+  renderLine(`Snapshot stored for ${version}`);
+  return loadMigrationProject(projectDir);
+}
+function diffProjectMigrations(projectDir, { fromVersion, toVersion = "current", renderLine = console.log } = {}) {
+  if (!fromVersion) {
+    throw new Error("`migrations diff` requires --from <semver>.");
+  }
+  const state = loadMigrationProject(projectDir);
+  const targetVersion = resolveTargetVersion(state.config.currentVersion, toVersion);
+  const diff = createMigrationDiff(state, fromVersion, targetVersion);
+  renderLine(formatDiffReport(diff));
+  return diff;
+}
+function scaffoldProjectMigrations(projectDir, { fromVersion, toVersion = "current", renderLine = console.log } = {}) {
+  if (!fromVersion) {
+    throw new Error("`migrations scaffold` requires --from <semver>.");
+  }
+  ensureMigrationDirectories(projectDir);
+  const state = loadMigrationProject(projectDir);
+  const targetVersion = resolveTargetVersion(state.config.currentVersion, toVersion);
+  const diff = createMigrationDiff(state, fromVersion, targetVersion);
+  const paths = getProjectPaths(projectDir);
+  const rulePath = getRuleFilePath(paths, fromVersion, targetVersion);
+  if (!fs9.existsSync(rulePath)) {
+    fs9.writeFileSync(rulePath, renderMigrationRuleFile({
+      currentAttributes: state.currentManifest.attributes ?? {},
+      currentTypeName: state.currentManifest.sourceType,
+      diff,
+      fromVersion,
+      targetVersion
+    }), "utf8");
+  }
+  ensureEdgeFixtureFile(projectDir, fromVersion, targetVersion, diff);
+  regenerateGeneratedArtifacts(projectDir);
+  renderLine(formatDiffReport(diff));
+  renderLine(`Scaffolded ${path10.relative(projectDir, rulePath)}`);
+  return { diff, rulePath };
+}
+function verifyProjectMigrations(projectDir, { all = false, fromVersion, renderLine = console.log } = {}) {
+  const state = loadMigrationProject(projectDir);
+  const verifyScriptPath = path10.join(projectDir, GENERATED_DIR, "verify.ts");
+  if (!fs9.existsSync(verifyScriptPath)) {
+    throw new Error("Generated verify script is missing. Run `wp-typia migrations scaffold --from <semver>` first.");
+  }
+  const targetVersions = all ? state.config.supportedVersions.filter((version) => version !== state.config.currentVersion) : fromVersion ? [fromVersion] : state.config.supportedVersions.filter((version) => version !== state.config.currentVersion);
+  if (targetVersions.length === 0) {
+    renderLine("No legacy versions configured for verification.");
+    return { verifiedVersions: [] };
+  }
+  for (const version of targetVersions) {
+    assertRuleHasNoTodos(projectDir, version, state.config.currentVersion);
+  }
+  const tsxBinary = getLocalTsxBinary(projectDir);
+  const filteredArgs = all ? ["--all"] : fromVersion ? ["--from", fromVersion] : [];
+  execSync3(`"${tsxBinary}" "${verifyScriptPath}" ${filteredArgs.join(" ")}`.trim(), {
+    cwd: projectDir,
+    stdio: "inherit"
+  });
+  renderLine(`Verified migrations for ${targetVersions.join(", ")}`);
+  return { verifiedVersions: targetVersions };
+}
+function regenerateGeneratedArtifacts(projectDir) {
+  const state = loadMigrationProject(projectDir);
+  const entries = discoverMigrationEntries(state);
+  fs9.mkdirSync(state.paths.generatedDir, { recursive: true });
+  fs9.writeFileSync(path10.join(state.paths.generatedDir, "registry.ts"), renderMigrationRegistryFile(state, entries), "utf8");
+  fs9.writeFileSync(path10.join(state.paths.generatedDir, "deprecated.ts"), renderGeneratedDeprecatedFile(entries), "utf8");
+  fs9.writeFileSync(path10.join(state.paths.generatedDir, "verify.ts"), renderVerifyFile(state, entries), "utf8");
+  fs9.writeFileSync(path10.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, entries), "utf8");
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const parsed = {
+    help: false,
+    noInstall: false,
+    packageManager: undefined,
+    positionals: [],
+    template: undefined,
+    yes: false
+  };
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("-")) {
+      parsed.positionals.push(arg);
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--yes" || arg === "-y") {
+      parsed.yes = true;
+      continue;
+    }
+    if (arg === "--no-install") {
+      parsed.noInstall = true;
+      continue;
+    }
+    if (arg === "--template" || arg === "-t") {
+      parsed.template = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--template=")) {
+      parsed.template = arg.split("=", 2)[1];
+      continue;
+    }
+    if (arg === "--package-manager" || arg === "-p") {
+      parsed.packageManager = argv[index + 1];
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith("--package-manager=")) {
+      parsed.packageManager = arg.split("=", 2)[1];
+      continue;
+    }
+    throw new Error(`Unknown flag: ${arg}`);
+  }
+  return parsed;
+}
+function printDoctorLine({
+  status,
+  label,
+  detail
+}) {
+  const prefix = status === "pass" ? "PASS" : status === "fail" ? "FAIL" : "WARN";
+  console.log(`${prefix} ${label}: ${detail}`);
+}
+async function runScaffold(parsed, cwd) {
+  const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const prompt = createReadlinePrompt();
+  try {
+    const flow = await runScaffoldFlow({
+      cwd,
+      isInteractive,
+      noInstall: parsed.noInstall,
+      packageManager: parsed.packageManager,
+      projectInput: parsed.positionals[0],
+      promptText: (message, defaultValue, validate) => prompt.text(message, defaultValue, validate),
+      selectPackageManager: () => prompt.select("Choose a package manager", getPackageManagerSelectOptions(), 1),
+      selectTemplate: () => prompt.select("Select a template", getTemplateSelectOptions(), 1),
+      templateId: parsed.template,
+      yes: parsed.yes
+    });
+    console.log(`
+✅ Created ${flow.result.variables.title} in ${flow.projectDir}`);
+    console.log("Next steps:");
+    for (const step of flow.nextSteps) {
+      console.log(`  ${step}`);
+    }
+  } finally {
+    prompt.close();
+  }
+}
+async function main(argv = process.argv.slice(2), cwd = process.cwd()) {
+  if (argv[0] === "migrations") {
+    const migrationCommand = parseMigrationArgs(argv.slice(1));
+    if (!migrationCommand.command) {
+      console.log(formatMigrationHelpText());
+      return;
+    }
+    await runMigrationCommand(migrationCommand, cwd, { renderLine: console.log });
+    return;
+  }
+  const parsed = parseArgs(argv);
+  if (parsed.help) {
+    console.log(formatHelpText());
+    return;
+  }
+  const [first, second] = parsed.positionals;
+  if (first === "templates") {
+    if (second === "list") {
+      for (const template of listTemplates()) {
+        console.log(formatTemplateSummary(template));
+        console.log(formatTemplateFeatures(template));
+      }
+      return;
+    }
+    if (second === "inspect") {
+      const templateId = parsed.positionals[2];
+      if (!templateId) {
+        throw new Error(`Template ID is required. Use one of: ${listTemplates().map((template) => template.id).join(", ")}`);
+      }
+      console.log(formatTemplateDetails(getTemplateById(templateId)));
+      return;
+    }
+    throw new Error("Usage: wp-typia templates <list|inspect>");
+  }
+  if (first === "doctor") {
+    await runDoctor(cwd, { renderLine: printDoctorLine });
+    return;
+  }
+  if (parsed.yes && !parsed.packageManager) {
+    throw new Error(`Package manager is required when using --yes. Use --package-manager <${PACKAGE_MANAGER_IDS.join("|")}>.`);
+  }
+  await runScaffold(parsed, cwd);
+}
+main().catch((error) => {
+  console.error("❌ wp-typia failed:", error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+export {
+  main
+};