@wp-typia/project-tools 0.24.4 → 0.24.5

package/dist/runtime/migration-fixtures.js

@@ -1,94 +1 @@
-import fs from "node:fs";
-import path from "node:path";
-import { getProjectPaths, getFixtureFilePath, getSnapshotManifestPath, } from "./migration-project.js";
-import { defaultValueForManifestAttribute } from "./migration-manifest.js";
-import { cloneJsonValue, createFixtureScalarValue, createTransformFixtureValue, deleteValueAtPath, readJson, setValueAtPath, getValueAtPath, } from "./migration-utils.js";
-export function ensureEdgeFixtureFile(projectDir, block, fromVersion, toVersion, diff, { force = false } = {}) {
-    const fixturePath = getFixtureFilePath(getProjectPaths(projectDir), block, fromVersion, toVersion);
-    fs.mkdirSync(path.dirname(fixturePath), { recursive: true });
-    if (!force && fs.existsSync(fixturePath)) {
-        return { fixturePath, written: false };
-    }
-    const fixtureDocument = createEdgeFixtureDocument(projectDir, block, fromVersion, toVersion, diff);
-    fs.writeFileSync(fixturePath, `${JSON.stringify(fixtureDocument, null, "\t")}\n`, "utf8");
-    return { fixturePath, written: true };
-}
-export function createEdgeFixtureDocument(projectDir, block, fromVersion, toVersion, diff) {
-    const manifest = readJson(getSnapshotManifestPath(projectDir, block, fromVersion));
-    const attributes = {};
-    for (const [key, attribute] of Object.entries(manifest.attributes ?? {})) {
-        attributes[key] = defaultValueForManifestAttribute(attribute) ?? null;
-    }
-    const cases = [
-        {
-            input: attributes,
-            name: "default",
-        },
-        ...createRenameFixtureCases(attributes, diff.summary.renameCandidates),
-        ...createTransformFixtureCases(attributes, diff.summary.transformSuggestions),
-        ...createUnionFixtureCases(attributes, manifest.attributes ?? {}, diff.summary.renameCandidates),
-    ];
-    return {
-        cases,
-        fromVersion,
-        toVersion,
-    };
-}
-function createRenameFixtureCases(baseAttributes, renameCandidates) {
-    return renameCandidates
-        .filter((candidate) => candidate.autoApply)
-        .map((candidate) => {
-        const nextInput = cloneJsonValue(baseAttributes);
-        const legacyValue = getValueAtPath(nextInput, candidate.legacyPath);
-        deleteValueAtPath(nextInput, candidate.currentPath);
-        if (legacyValue === undefined) {
-            setValueAtPath(nextInput, candidate.legacyPath, createFixtureScalarValue(candidate.currentPath));
-        }
-        return {
-            input: nextInput,
-            name: `rename:${candidate.legacyPath}->${candidate.currentPath}`,
-        };
-    });
-}
-function createTransformFixtureCases(baseAttributes, transformSuggestions) {
-    return transformSuggestions.map((suggestion) => {
-        const nextInput = cloneJsonValue(baseAttributes);
-        const legacyPath = suggestion.legacyPath ?? suggestion.currentPath;
-        setValueAtPath(nextInput, legacyPath, createTransformFixtureValue(suggestion.attribute, suggestion.currentPath));
-        return {
-            input: nextInput,
-            name: `transform:${legacyPath}->${suggestion.currentPath}`,
-        };
-    });
-}
-function createUnionFixtureCases(baseAttributes, manifestAttributes, renameCandidates) {
-    const cases = [];
-    for (const [key, attribute] of Object.entries(manifestAttributes)) {
-        if (attribute.ts.kind !== "union" || !attribute.ts.union) {
-            continue;
-        }
-        for (const [branchKey, branch] of Object.entries(attribute.ts.union.branches ?? {})) {
-            const nextInput = cloneJsonValue(baseAttributes);
-            const legacyPath = renameCandidates.find((candidate) => candidate.autoApply && candidate.currentPath === key)?.legacyPath ??
-                key;
-            setValueAtPath(nextInput, legacyPath, createUnionBranchFixtureValue(attribute.ts.union.discriminator, branchKey, branch));
-            cases.push({
-                input: nextInput,
-                name: `union:${key}:${branchKey}`,
-            });
-        }
-    }
-    return cases;
-}
-function createUnionBranchFixtureValue(discriminator, branchKey, branchAttribute) {
-    const branchValue = defaultValueForManifestAttribute(branchAttribute);
-    if (typeof branchValue === "object" && branchValue !== null && !Array.isArray(branchValue)) {
-        return {
-            ...branchValue,
-            [discriminator]: branchKey,
-        };
-    }
-    return {
-        [discriminator]: branchKey,
-    };
-}
+export * from "./migration/migration-fixtures.js";

package/dist/runtime/migration-fuzz-plan.d.ts

@@ -1,2 +1 @@
-import type { ManifestDocument, MigrationDiff, MigrationFuzzPlan } from "./migration-types.js";
-export declare function createMigrationFuzzPlan(legacyManifest: ManifestDocument, currentManifest: ManifestDocument, diff: MigrationDiff): MigrationFuzzPlan;
+export * from "./migration/migration-fuzz-plan.js";

package/dist/runtime/migration-fuzz-plan.js

@@ -1,50 +1 @@
-import { flattenManifestLeafAttributes } from "./migration-manifest.js";
-function isBlockedPath(pathLabel, blockedPaths) {
-    return blockedPaths.some((blockedPath) => pathLabel === blockedPath || pathLabel.startsWith(`${blockedPath}.`));
-}
-function unique(items) {
-    return [...new Set(items)];
-}
-export function createMigrationFuzzPlan(legacyManifest, currentManifest, diff) {
-    const legacyLeafMap = new Map(flattenManifestLeafAttributes(legacyManifest.attributes ?? {}).map((descriptor) => [
-        descriptor.currentPath,
-        descriptor,
-    ]));
-    const currentLeafDescriptors = flattenManifestLeafAttributes(currentManifest.attributes ?? {});
-    const autoRenameMap = new Map(diff.summary.renameCandidates
-        .filter((candidate) => candidate.autoApply)
-        .map((candidate) => [candidate.currentPath, candidate.legacyPath]));
-    const blockedPaths = unique([
-        ...diff.summary.manualItems.map((item) => item.path),
-        ...diff.summary.transformSuggestions.map((item) => item.currentPath),
-        ...diff.summary.renameCandidates
-            .filter((candidate) => !candidate.autoApply)
-            .map((candidate) => candidate.currentPath),
-    ]);
-    const compatibleMappings = [];
-    for (const descriptor of currentLeafDescriptors) {
-        const currentPath = descriptor.currentPath;
-        if (isBlockedPath(currentPath, blockedPaths)) {
-            continue;
-        }
-        const legacyPath = autoRenameMap.get(currentPath) ?? currentPath;
-        const legacyDescriptor = legacyLeafMap.get(legacyPath);
-        if (!legacyDescriptor) {
-            continue;
-        }
-        if (legacyDescriptor.attribute.ts.kind !== descriptor.attribute.ts.kind) {
-            continue;
-        }
-        if (!["string", "number", "boolean"].includes(descriptor.attribute.ts.kind)) {
-            continue;
-        }
-        compatibleMappings.push({
-            currentPath,
-            legacyPath,
-        });
-    }
-    return {
-        blockedPaths,
-        compatibleMappings,
-    };
-}
+export * from "./migration/migration-fuzz-plan.js";

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

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

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

@@ -1,41 +1 @@
-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");
-}
+export * from "./migration/migration-generated-artifacts.js";

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

@@ -1,23 +1 @@
-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;
-};
+export * from "./migration/migration-maintenance-fixtures.js";

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

@@ -1,126 +1 @@
-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';
-}
+export * from "./migration/migration-maintenance-fixtures.js";

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

@@ -1,26 +1 @@
-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";
-    }[];
-};
+export * from "./migration/migration-maintenance-verify.js";

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

@@ -1,267 +1 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { ROOT_PHP_MIGRATION_REGISTRY, } from './migration-constants.js';
-import { createMigrationDiff } from './migration-diff.js';
-import { createEdgeFixtureDocument, } from './migration-fixtures.js';
-import { collectGeneratedMigrationEntries, } from './migration-generated-artifacts.js';
-import { formatScaffoldCommand, getSelectedEntriesByBlock, hasSnapshotForVersion, isLegacySingleBlockProject, isSnapshotOptionalForBlockVersion, resolveLegacyVersions, } from './migration-planning.js';
-import { assertRuleHasNoTodos, getFixtureFilePath, getGeneratedDirForBlock, getRuleFilePath, getSnapshotBlockJsonPath, getSnapshotManifestPath, getSnapshotRoot, getSnapshotSavePath, loadMigrationProject, readRuleMetadata, } from './migration-project.js';
-import { renderFuzzFile, renderGeneratedDeprecatedFile, renderGeneratedMigrationIndexFile, renderMigrationRegistryFile, renderPhpMigrationRegistryFile, renderVerifyFile, } from './migration-render.js';
-import { createMigrationRiskSummary, formatMigrationRiskSummary, } from './migration-risk.js';
-import { getLocalTsxBinary, readJson, } from './migration-utils.js';
-import { readWorkspaceInventory } from './workspace-inventory.js';
-import { getInvalidWorkspaceProjectReason, tryResolveWorkspaceProject, } from './workspace-project.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 function verifyProjectMigrations(projectDir, { all = false, fromMigrationVersion, renderLine = console.log, } = {}) {
-    const state = loadMigrationProject(projectDir);
-    const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
-    const blockEntries = getSelectedEntriesByBlock(state, targetVersions, 'verify');
-    const legacySingleBlock = isLegacySingleBlockProject(state);
-    if (targetVersions.length === 0) {
-        renderLine('No legacy migration versions configured for verification.');
-        return { verifiedVersions: [] };
-    }
-    const tsxBinary = getLocalTsxBinary(projectDir);
-    for (const [blockKey, entries] of Object.entries(blockEntries)) {
-        const block = state.blocks.find((entry) => entry.key === blockKey);
-        if (!block || entries.length === 0) {
-            continue;
-        }
-        for (const entry of entries) {
-            assertRuleHasNoTodos(projectDir, block, entry.fromVersion, state.config.currentMigrationVersion);
-        }
-        const verifyScriptPath = path.join(getGeneratedDirForBlock(state.paths, block), 'verify.ts');
-        if (!fs.existsSync(verifyScriptPath)) {
-            const selectedVersionsForBlock = entries.map((entry) => entry.fromVersion);
-            throw new Error(`Generated verify 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 filteredArgs = all
-            ? ['--all']
-            : ['--from-migration-version', selectedVersionsForBlock[0]];
-        execFileSync(tsxBinary, [verifyScriptPath, ...filteredArgs], {
-            cwd: projectDir,
-            shell: process.platform === 'win32',
-            stdio: 'inherit',
-        });
-        renderLine(legacySingleBlock
-            ? `Verified migrations for ${selectedVersionsForBlock.join(', ')}`
-            : `Verified ${block.blockName} migrations for ${selectedVersionsForBlock.join(', ')}`);
-    }
-    return { verifiedVersions: targetVersions };
-}
-function recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck) {
-    // `migrate doctor` is still a synchronous maintenance command: it shares
-    // sync migration project loading, generated artifact comparisons, and
-    // execFileSync verification with the rest of migration maintenance.
-    let invalidWorkspaceReason = null;
-    let workspace;
-    try {
-        invalidWorkspaceReason = getInvalidWorkspaceProjectReason(projectDir);
-        workspace = tryResolveWorkspaceProject(projectDir);
-    }
-    catch (error) {
-        recordCheck('fail', 'Workspace migration targets', error instanceof Error ? error.message : String(error));
-        return;
-    }
-    if (!workspace) {
-        if (invalidWorkspaceReason) {
-            recordCheck('fail', 'Workspace migration targets', invalidWorkspaceReason);
-        }
-        return;
-    }
-    try {
-        // Maintenance verification is intentionally synchronous so it can compare
-        // migration state against a single inventory snapshot.
-        const inventory = readWorkspaceInventory(workspace.projectDir);
-        const expectedTargets = inventory.blocks.map((block) => `${workspace.workspace.namespace}/${block.slug}`);
-        const configuredTargets = state.blocks.map((block) => block.blockName);
-        const expectedTargetSet = new Set(expectedTargets);
-        const configuredTargetSet = new Set(configuredTargets);
-        const missingTargets = expectedTargets.filter((target) => !configuredTargetSet.has(target));
-        const staleTargets = configuredTargets.filter((target) => !expectedTargetSet.has(target));
-        recordCheck(missingTargets.length === 0 && staleTargets.length === 0 ? 'pass' : 'fail', 'Workspace migration targets', missingTargets.length === 0 && staleTargets.length === 0
-            ? `${expectedTargets.length} workspace block target(s) align with migration config`
-            : [
-                missingTargets.length > 0
-                    ? `Missing from migration config: ${missingTargets.join(', ')}`
-                    : null,
-                staleTargets.length > 0
-                    ? `Not present in scripts/block-config.ts: ${staleTargets.join(', ')}`
-                    : null,
-            ]
-                .filter((detail) => typeof detail === 'string')
-                .join('; '));
-    }
-    catch (error) {
-        recordCheck('fail', 'Workspace migration targets', error instanceof Error ? error.message : String(error));
-    }
-}
-/**
- * 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 function doctorProjectMigrations(projectDir, { all = false, fromMigrationVersion, renderLine = console.log, } = {}) {
-    const checks = [];
-    const recordCheck = (status, label, detail) => {
-        checks.push({ detail, label, status });
-        renderLine(`${status === 'pass' ? 'PASS' : 'FAIL'} ${label}: ${detail}`);
-    };
-    let state;
-    try {
-        state = loadMigrationProject(projectDir);
-        const legacySingleBlock = isLegacySingleBlockProject(state);
-        recordCheck('pass', 'Migration config', legacySingleBlock
-            ? `Loaded ${state.blocks[0]?.blockName} @ ${state.config.currentMigrationVersion}`
-            : `Loaded ${state.blocks.length} block target(s) @ ${state.config.currentMigrationVersion}`);
-    }
-    catch (error) {
-        recordCheck('fail', 'Migration config', error instanceof Error ? error.message : String(error));
-        throw new Error('Migration doctor failed.');
-    }
-    const targetVersions = resolveLegacyVersions(state, { all, fromMigrationVersion });
-    const legacySingleBlock = isLegacySingleBlockProject(state);
-    const snapshotVersions = new Set(targetVersions.length > 0
-        ? [state.config.currentMigrationVersion, ...targetVersions]
-        : state.config.supportedMigrationVersions);
-    recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck);
-    for (const version of snapshotVersions) {
-        for (const block of state.blocks) {
-            const snapshotRoot = getSnapshotRoot(projectDir, block, version);
-            const blockJsonPath = getSnapshotBlockJsonPath(projectDir, block, version);
-            const manifestPath = getSnapshotManifestPath(projectDir, block, version);
-            const savePath = getSnapshotSavePath(projectDir, block, version);
-            const hasSnapshot = fs.existsSync(snapshotRoot);
-            const snapshotIsOptional = !hasSnapshot && isSnapshotOptionalForBlockVersion(state, block, version);
-            recordCheck(hasSnapshot || snapshotIsOptional ? 'pass' : 'fail', legacySingleBlock ? `Snapshot ${version}` : `Snapshot ${block.blockName} @ ${version}`, hasSnapshot
-                ? path.relative(projectDir, snapshotRoot)
-                : 'Not present for this version');
-            if (!hasSnapshot) {
-                continue;
-            }
-            for (const targetPath of [blockJsonPath, manifestPath, savePath]) {
-                recordCheck(fs.existsSync(targetPath) ? 'pass' : 'fail', legacySingleBlock
-                    ? `Snapshot file ${version}`
-                    : `Snapshot file ${block.blockName} @ ${version}`, fs.existsSync(targetPath)
-                    ? path.relative(projectDir, targetPath)
-                    : `Missing ${path.relative(projectDir, targetPath)}`);
-            }
-        }
-    }
-    try {
-        const generatedEntries = collectGeneratedMigrationEntries(state);
-        const expectedGeneratedFiles = new Map();
-        for (const block of state.blocks) {
-            const blockGeneratedEntries = generatedEntries.filter(({ entry }) => entry.block.key === block.key);
-            const entries = blockGeneratedEntries.map(({ entry }) => entry);
-            const generatedDir = getGeneratedDirForBlock(state.paths, block);
-            expectedGeneratedFiles.set(path.join(generatedDir, 'registry.ts'), renderMigrationRegistryFile(state, block.key, blockGeneratedEntries));
-            expectedGeneratedFiles.set(path.join(generatedDir, 'deprecated.ts'), renderGeneratedDeprecatedFile(state, block.key, entries));
-            expectedGeneratedFiles.set(path.join(generatedDir, 'verify.ts'), renderVerifyFile(state, block.key, entries));
-            expectedGeneratedFiles.set(path.join(generatedDir, 'fuzz.ts'), renderFuzzFile(state, block.key, blockGeneratedEntries));
-        }
-        expectedGeneratedFiles.set(path.join(state.paths.generatedDir, 'index.ts'), renderGeneratedMigrationIndexFile(state, generatedEntries.map(({ entry }) => entry)));
-        expectedGeneratedFiles.set(path.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, generatedEntries.map(({ entry }) => entry)));
-        for (const [filePath, expectedSource] of expectedGeneratedFiles) {
-            const inSync = fs.existsSync(filePath) && fs.readFileSync(filePath, 'utf8') === expectedSource;
-            recordCheck(inSync ? 'pass' : 'fail', `Generated ${path.relative(projectDir, filePath)}`, inSync
-                ? 'In sync'
-                : 'Run `wp-typia migrate scaffold --from-migration-version <label>` or regenerate artifacts');
-        }
-    }
-    catch (error) {
-        recordCheck('fail', 'Generated artifacts', error instanceof Error ? error.message : String(error));
-    }
-    for (const version of targetVersions) {
-        for (const block of state.blocks) {
-            if (!hasSnapshotForVersion(state, block, version)) {
-                recordCheck('pass', `Snapshot coverage ${block.blockName} @ ${version}`, 'Target not present for this version');
-                continue;
-            }
-            const rulePath = getRuleFilePath(state.paths, block, version, state.config.currentMigrationVersion);
-            const fixturePath = getFixtureFilePath(state.paths, block, version, state.config.currentMigrationVersion);
-            recordCheck(fs.existsSync(rulePath) ? 'pass' : 'fail', legacySingleBlock ? `Rule ${version}` : `Rule ${block.blockName} @ ${version}`, fs.existsSync(rulePath)
-                ? path.relative(projectDir, rulePath)
-                : `Missing ${path.relative(projectDir, rulePath)}`);
-            recordCheck(fs.existsSync(fixturePath) ? 'pass' : 'fail', legacySingleBlock ? `Fixture ${version}` : `Fixture ${block.blockName} @ ${version}`, fs.existsSync(fixturePath)
-                ? path.relative(projectDir, fixturePath)
-                : `Missing ${path.relative(projectDir, fixturePath)}`);
-            if (!fs.existsSync(rulePath) || !fs.existsSync(fixturePath)) {
-                continue;
-            }
-            try {
-                assertRuleHasNoTodos(projectDir, block, version, state.config.currentMigrationVersion);
-                recordCheck('pass', legacySingleBlock
-                    ? `Rule TODOs ${version}`
-                    : `Rule TODOs ${block.blockName} @ ${version}`, 'No TODO MIGRATION markers remain');
-            }
-            catch (error) {
-                recordCheck('fail', legacySingleBlock
-                    ? `Rule TODOs ${version}`
-                    : `Rule TODOs ${block.blockName} @ ${version}`, error instanceof Error ? error.message : String(error));
-            }
-            try {
-                const ruleMetadata = readRuleMetadata(rulePath);
-                recordCheck(ruleMetadata.unresolved.length === 0 ? 'pass' : 'fail', legacySingleBlock
-                    ? `Rule unresolved ${version}`
-                    : `Rule unresolved ${block.blockName} @ ${version}`, ruleMetadata.unresolved.length === 0
-                    ? 'No unresolved entries remain'
-                    : ruleMetadata.unresolved.join(', '));
-            }
-            catch (error) {
-                recordCheck('fail', legacySingleBlock
-                    ? `Rule unresolved ${version}`
-                    : `Rule unresolved ${block.blockName} @ ${version}`, error instanceof Error ? error.message : String(error));
-            }
-            try {
-                const fixtureDocument = readJson(fixturePath);
-                recordCheck(Array.isArray(fixtureDocument.cases) && fixtureDocument.cases.length > 0
-                    ? 'pass'
-                    : 'fail', legacySingleBlock
-                    ? `Fixture parse ${version}`
-                    : `Fixture parse ${block.blockName} @ ${version}`, Array.isArray(fixtureDocument.cases) && fixtureDocument.cases.length > 0
-                    ? `${fixtureDocument.cases.length} case(s)`
-                    : 'Fixture document has no cases');
-                const diff = createMigrationDiff(state, block, version, state.config.currentMigrationVersion);
-                const expectedFixture = createEdgeFixtureDocument(projectDir, block, version, state.config.currentMigrationVersion, diff);
-                const actualCaseNames = new Set((fixtureDocument.cases ?? []).map((fixtureCase) => fixtureCase.name));
-                const missingCases = expectedFixture.cases
-                    .map((fixtureCase) => fixtureCase.name)
-                    .filter((name) => !actualCaseNames.has(name));
-                recordCheck(missingCases.length === 0 ? 'pass' : 'fail', legacySingleBlock
-                    ? `Fixture coverage ${version}`
-                    : `Fixture coverage ${block.blockName} @ ${version}`, missingCases.length === 0
-                    ? 'All expected fixture cases are present'
-                    : `Missing ${missingCases.join(', ')}`);
-                recordCheck('pass', legacySingleBlock
-                    ? `Risk summary ${version}`
-                    : `Risk summary ${block.blockName} @ ${version}`, formatMigrationRiskSummary(createMigrationRiskSummary(diff)));
-            }
-            catch (error) {
-                recordCheck('fail', legacySingleBlock
-                    ? `Fixture parse ${version}`
-                    : `Fixture parse ${block.blockName} @ ${version}`, error instanceof Error ? error.message : String(error));
-            }
-        }
-    }
-    const failedChecks = checks.filter((check) => check.status === 'fail');
-    renderLine(`${failedChecks.length === 0 ? 'PASS' : 'FAIL'} Migration doctor summary: ${checks.length - failedChecks.length}/${checks.length} checks passed`);
-    if (failedChecks.length > 0) {
-        throw new Error('Migration doctor failed.');
-    }
-    return {
-        checkedVersions: targetVersions,
-        checks,
-    };
-}
+export * from "./migration/migration-maintenance-verify.js";

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

@@ -1,2 +1 @@
-export * from './migration-maintenance-verify.js';
-export * from './migration-maintenance-fixtures.js';
+export * from "./migration/migration-maintenance.js";