@wp-typia/project-tools 0.16.11 → 0.16.13

package/dist/runtime/migration-diff.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
-import { flattenManifestLeafAttributes, getAttributeByCurrentPath, getManifestDefaultValue, hasManifestDefault, } from "./migration-manifest.js";
+import { flattenManifestLeafAttributes, getManifestDefaultValue, hasManifestDefault, } from "./migration-manifest.js";
+import { createRenameCandidates } from "./migration-diff-rename.js";
+import { createTransformSuggestions, describeConstraintChange, } from "./migration-diff-transform.js";
 import { createMissingBlockSnapshotMessage, getAvailableSnapshotVersionsForBlock, getSnapshotManifestPath, } from "./migration-project.js";
 import { isNumber, readJson } from "./migration-utils.js";
 export function createMigrationDiff(state, blockOrFromVersion, fromVersionOrToVersion, maybeToVersion) {
@@ -79,7 +81,15 @@ export function createMigrationDiff(state, blockOrFromVersion, fromVersionOrToVe
             });
         }
     }
-    const renameCandidates = createRenameCandidates(oldAttributes, newAttributes, removedKeys, addedKeys, oldLeafAttributes, newLeafAttributes);
+    const renameCandidates = createRenameCandidates({
+        addedKeys,
+        isUnionRenameCompatible: (oldAttribute, newAttribute) => compareUnionAttribute(oldAttribute, newAttribute, "$rename").status === "auto",
+        newAttributes,
+        newLeafAttributes,
+        oldAttributes,
+        oldLeafAttributes,
+        removedKeys,
+    });
     const activeRenameCandidates = renameCandidates.filter((candidate) => candidate.autoApply);
     for (const candidate of activeRenameCandidates) {
         removeOutcomeByPath(autoItems, candidate.legacyPath, "drop");
@@ -234,301 +244,6 @@ function hasStricterConstraints(oldAttribute, newAttribute) {
     }
     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" };
 }

package/dist/runtime/migration-generated-artifacts.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratedMigrationEntry, MigrationProjectState } from "./migration-types.js";
+export declare function collectGeneratedMigrationEntries(state: MigrationProjectState): GeneratedMigrationEntry[];
+export declare function regenerateGeneratedArtifacts(projectDir: string): void;

package/dist/runtime/migration-generated-artifacts.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ROOT_PHP_MIGRATION_REGISTRY } from "./migration-constants.js";
+import { createMigrationDiff } from "./migration-diff.js";
+import { createMigrationFuzzPlan } from "./migration-fuzz-plan.js";
+import { discoverMigrationEntries, getGeneratedDirForBlock, getSnapshotManifestPath, loadMigrationProject, } from "./migration-project.js";
+import { renderFuzzFile, renderGeneratedDeprecatedFile, renderGeneratedMigrationIndexFile, renderMigrationRegistryFile, renderPhpMigrationRegistryFile, renderVerifyFile, } from "./migration-render.js";
+import { createMigrationRiskSummary } from "./migration-risk.js";
+import { readJson } from "./migration-utils.js";
+export function collectGeneratedMigrationEntries(state) {
+    return discoverMigrationEntries(state).map((entry) => {
+        const block = state.blocks.find((target) => target.key === entry.block.key);
+        if (!block) {
+            throw new Error(`Unknown migration block target: ${entry.block.key}`);
+        }
+        const diff = createMigrationDiff(state, entry.block, entry.fromVersion, entry.toVersion);
+        const legacyManifest = readJson(getSnapshotManifestPath(state.projectDir, entry.block, entry.fromVersion));
+        return {
+            diff,
+            entry,
+            fuzzPlan: createMigrationFuzzPlan(legacyManifest, block.currentManifest, diff),
+            riskSummary: createMigrationRiskSummary(diff),
+        };
+    });
+}
+export function regenerateGeneratedArtifacts(projectDir) {
+    const state = loadMigrationProject(projectDir);
+    const generatedEntries = collectGeneratedMigrationEntries(state);
+    for (const block of state.blocks) {
+        const blockGeneratedEntries = generatedEntries.filter(({ entry }) => entry.block.key === block.key);
+        const entries = blockGeneratedEntries.map(({ entry }) => entry);
+        const generatedDir = getGeneratedDirForBlock(state.paths, block);
+        fs.mkdirSync(generatedDir, { recursive: true });
+        fs.writeFileSync(path.join(generatedDir, "registry.ts"), renderMigrationRegistryFile(state, block.key, blockGeneratedEntries), "utf8");
+        fs.writeFileSync(path.join(generatedDir, "deprecated.ts"), renderGeneratedDeprecatedFile(state, block.key, entries), "utf8");
+        fs.writeFileSync(path.join(generatedDir, "verify.ts"), renderVerifyFile(state, block.key, entries), "utf8");
+        fs.writeFileSync(path.join(generatedDir, "fuzz.ts"), renderFuzzFile(state, block.key, blockGeneratedEntries), "utf8");
+    }
+    fs.writeFileSync(path.join(state.paths.generatedDir, "index.ts"), renderGeneratedMigrationIndexFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
+    fs.writeFileSync(path.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
+}

package/dist/runtime/migration-maintenance-fixtures.d.ts

@@ -0,0 +1,23 @@
+import type { FixturesOptions, FuzzOptions } from './migration-command-surface.js';
+/**
+ * Generate or refresh migration fixtures for one or more legacy edges.
+ *
+ * @param projectDir Absolute or relative project directory containing the migration workspace.
+ * @param options Fixture generation scope and refresh options.
+ * @returns Generated and skipped legacy versions.
+ */
+export declare function fixturesProjectMigrations(projectDir: string, { all, confirmOverwrite, force, fromMigrationVersion, isInteractive, renderLine, toMigrationVersion, }?: FixturesOptions): {
+    generatedVersions: string[];
+    skippedVersions: string[];
+};
+/**
+ * Run seeded migration fuzz verification against generated fuzz artifacts.
+ *
+ * @param projectDir Absolute or relative project directory containing the migration workspace.
+ * @param options Fuzz scope, iteration count, seed, and console rendering options.
+ * @returns Fuzzed legacy versions and the effective seed.
+ */
+export declare function fuzzProjectMigrations(projectDir: string, { all, fromMigrationVersion, iterations, renderLine, seed, }?: FuzzOptions): {
+    fuzzedVersions: string[];
+    seed: number | undefined;
+};

package/dist/runtime/migration-maintenance-fixtures.js

@@ -0,0 +1,126 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { createMigrationDiff } from './migration-diff.js';
+import { ensureEdgeFixtureFile, } from './migration-fixtures.js';
+import { collectFixtureTargets, formatScaffoldCommand, getSelectedEntriesByBlock, isLegacySingleBlockProject, resolveLegacyVersions, } from './migration-planning.js';
+import { assertRuleHasNoTodos, getGeneratedDirForBlock, loadMigrationProject, } from './migration-project.js';
+import { getLocalTsxBinary, isInteractiveTerminal, resolveTargetMigrationVersion, } from './migration-utils.js';
+/**
+ * Generate or refresh migration fixtures for one or more legacy edges.
+ *
+ * @param projectDir Absolute or relative project directory containing the migration workspace.
+ * @param options Fixture generation scope and refresh options.
+ * @returns Generated and skipped legacy versions.
+ */
+export function fixturesProjectMigrations(projectDir, { all = false, confirmOverwrite, force = false, fromMigrationVersion, isInteractive = isInteractiveTerminal(), renderLine = console.log, toMigrationVersion = 'current', } = {}) {
+    const state = loadMigrationProject(projectDir);
+    const targetMigrationVersion = resolveTargetMigrationVersion(state.config.currentMigrationVersion, toMigrationVersion);
+    const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
+    if (targetVersions.length === 0) {
+        renderLine('No legacy migration versions configured for fixture generation.');
+        return { generatedVersions: [], skippedVersions: [] };
+    }
+    const generatedVersions = [];
+    const skippedVersions = [];
+    const fixtureTargets = collectFixtureTargets(state, targetVersions, targetMigrationVersion);
+    if (force) {
+        const overwriteTargets = fixtureTargets.filter(({ fixturePath }) => fs.existsSync(fixturePath));
+        if (isInteractive && overwriteTargets.length > 0) {
+            const confirmed = confirmOverwrite?.(`About to overwrite ${overwriteTargets.length} existing migration fixture file(s). Continue?`) ??
+                promptForConfirmation(`About to overwrite ${overwriteTargets.length} existing migration fixture file(s). Continue?`);
+            if (!confirmed) {
+                renderLine(`Cancelled fixture refresh. Kept ${overwriteTargets.length} existing fixture file(s).`);
+                return {
+                    generatedVersions,
+                    skippedVersions: overwriteTargets.map(({ scopedLabel }) => scopedLabel),
+                };
+            }
+        }
+    }
+    for (const { block, fixturePath, scopedLabel, version } of fixtureTargets) {
+        const existed = fs.existsSync(fixturePath);
+        const diff = createMigrationDiff(state, block, version, targetMigrationVersion);
+        const result = ensureEdgeFixtureFile(projectDir, block, version, targetMigrationVersion, diff, { force });
+        if (result.written) {
+            generatedVersions.push(scopedLabel);
+            renderLine(`${existed ? 'Refreshed' : 'Generated'} fixture ${path.relative(projectDir, fixturePath)}`);
+        }
+        else {
+            skippedVersions.push(scopedLabel);
+            renderLine(`Preserved existing fixture ${path.relative(projectDir, fixturePath)} (use --force to refresh)`);
+        }
+    }
+    return {
+        generatedVersions,
+        skippedVersions,
+    };
+}
+/**
+ * Run seeded migration fuzz verification against generated fuzz artifacts.
+ *
+ * @param projectDir Absolute or relative project directory containing the migration workspace.
+ * @param options Fuzz scope, iteration count, seed, and console rendering options.
+ * @returns Fuzzed legacy versions and the effective seed.
+ */
+export function fuzzProjectMigrations(projectDir, { all = false, fromMigrationVersion, iterations = 25, renderLine = console.log, seed, } = {}) {
+    const state = loadMigrationProject(projectDir);
+    const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
+    const blockEntries = getSelectedEntriesByBlock(state, targetVersions, 'fuzz');
+    const legacySingleBlock = isLegacySingleBlockProject(state);
+    if (targetVersions.length === 0) {
+        renderLine('No legacy migration versions configured for fuzzing.');
+        return { fuzzedVersions: [], seed };
+    }
+    const tsxBinary = getLocalTsxBinary(projectDir);
+    for (const [blockKey, entries] of Object.entries(blockEntries)) {
+        const block = state.blocks.find((entry) => entry.key === blockKey);
+        if (!block || entries.length === 0) {
+            continue;
+        }
+        for (const entry of entries) {
+            assertRuleHasNoTodos(projectDir, block, entry.fromVersion, state.config.currentMigrationVersion);
+        }
+        const fuzzScriptPath = path.join(getGeneratedDirForBlock(state.paths, block), 'fuzz.ts');
+        if (!fs.existsSync(fuzzScriptPath)) {
+            const selectedVersionsForBlock = entries.map((entry) => entry.fromVersion);
+            throw new Error(`Generated fuzz script is missing for ${block.blockName} (${selectedVersionsForBlock.join(', ')}). ` +
+                `Run \`${formatScaffoldCommand(selectedVersionsForBlock)}\` first, then \`wp-typia migrate doctor --all\` if the workspace should already be scaffolded.`);
+        }
+        const selectedVersionsForBlock = entries.map((entry) => entry.fromVersion);
+        const args = [
+            fuzzScriptPath,
+            ...(all ? ['--all'] : ['--from-migration-version', selectedVersionsForBlock[0]]),
+            '--iterations',
+            String(iterations),
+            ...(seed === undefined ? [] : ['--seed', String(seed)]),
+        ];
+        execFileSync(tsxBinary, args, {
+            cwd: projectDir,
+            shell: process.platform === 'win32',
+            stdio: 'inherit',
+        });
+        renderLine(legacySingleBlock
+            ? `Fuzzed migrations for ${selectedVersionsForBlock.join(', ')}`
+            : `Fuzzed ${block.blockName} migrations for ${selectedVersionsForBlock.join(', ')}`);
+    }
+    return { fuzzedVersions: targetVersions, seed };
+}
+function promptForConfirmation(message) {
+    process.stdout.write(`${message} [y/N]: `);
+    const buffer = Buffer.alloc(1);
+    let answer = '';
+    while (true) {
+        const bytesRead = fs.readSync(process.stdin.fd, buffer, 0, 1, null);
+        if (bytesRead === 0) {
+            break;
+        }
+        const char = buffer.toString('utf8', 0, bytesRead);
+        if (char === '\n' || char === '\r') {
+            break;
+        }
+        answer += char;
+    }
+    const normalized = answer.trim().toLowerCase();
+    return normalized === 'y' || normalized === 'yes';
+}

package/dist/runtime/migration-maintenance-verify.d.ts

@@ -0,0 +1,26 @@
+import type { VerifyOptions } from './migration-command-surface.js';
+/**
+ * Run deterministic migration verification against generated fixtures.
+ *
+ * @param projectDir Absolute or relative project directory containing the migration workspace.
+ * @param options Verification scope and console rendering options.
+ * @returns Verified legacy versions.
+ */
+export declare function verifyProjectMigrations(projectDir: string, { all, fromMigrationVersion, renderLine, }?: VerifyOptions): {
+    verifiedVersions: string[];
+};
+/**
+ * Validate the migration workspace without mutating files.
+ *
+ * @param projectDir Absolute or relative project directory containing the migration workspace.
+ * @param options Doctor scope and console rendering options.
+ * @returns Structured doctor check results for the selected legacy versions.
+ */
+export declare function doctorProjectMigrations(projectDir: string, { all, fromMigrationVersion, renderLine, }?: VerifyOptions): {
+    checkedVersions: string[];
+    checks: {
+        detail: string;
+        label: string;
+        status: "fail" | "pass";
+    }[];
+};