@wp-typia/create 0.1.0

package/dist/runtime/migration-manifest.js

@@ -0,0 +1,129 @@
+export function flattenManifestLeafAttributes(attributes) {
+    return Object.entries(attributes).flatMap(([key, attribute]) => flattenManifestAttribute(attribute, key, key, {
+        rootPath: key,
+        unionBranch: null,
+        unionDiscriminator: null,
+        unionRoot: null,
+    }));
+}
+export 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 }];
+}
+export 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;
+}
+export function hasManifestDefault(attribute) {
+    return attribute?.typia?.hasDefault === true;
+}
+export function getManifestDefaultValue(attribute) {
+    return attribute?.typia?.defaultValue ?? null;
+}
+export 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,
+    };
+}
+export 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,
+    }));
+}
+export 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;
+    }
+}

package/dist/runtime/migration-project.js

@@ -0,0 +1,167 @@
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_FILE, FIXTURES_DIR, GENERATED_DIR, MIGRATION_TODO_PREFIX, ROOT_BLOCK_JSON, ROOT_MANIFEST, RULES_DIR, SNAPSHOT_DIR, SUPPORTED_PROJECT_FILES, } from "./migration-constants.js";
+import { compareSemver, readJson, runProjectScriptIfPresent, } from "./migration-utils.js";
+export function ensureAdvancedMigrationProject(projectDir) {
+    const missing = SUPPORTED_PROJECT_FILES.filter((relativePath) => !fs.existsSync(path.join(projectDir, relativePath)));
+    if (missing.length > 0) {
+        throw new Error(`This directory is not a supported advanced migration project. Missing: ${missing.join(", ")}`);
+    }
+}
+export function getProjectPaths(projectDir) {
+    return {
+        configFile: path.join(projectDir, CONFIG_FILE),
+        fixturesDir: path.join(projectDir, FIXTURES_DIR),
+        generatedDir: path.join(projectDir, GENERATED_DIR),
+        rulesDir: path.join(projectDir, RULES_DIR),
+        snapshotDir: path.join(projectDir, SNAPSHOT_DIR),
+    };
+}
+export function ensureMigrationDirectories(projectDir) {
+    const paths = getProjectPaths(projectDir);
+    fs.mkdirSync(paths.fixturesDir, { recursive: true });
+    fs.mkdirSync(paths.generatedDir, { recursive: true });
+    fs.mkdirSync(paths.rulesDir, { recursive: true });
+    fs.mkdirSync(paths.snapshotDir, { recursive: true });
+}
+export function writeInitialMigrationScaffold(projectDir, currentVersion) {
+    const paths = getProjectPaths(projectDir);
+    const readmeFiles = [
+        [path.join(paths.snapshotDir, "README.md"), `# Version Snapshots\n\nSnapshots for ${currentVersion} and future versions live here.\n`],
+        [path.join(paths.rulesDir, "README.md"), `# Migration Rules\n\nScaffold direct legacy-to-current migration rules in this directory.\n`],
+        [path.join(paths.fixturesDir, "README.md"), `# Migration Fixtures\n\nGenerated fixtures are used by verify to assert migrations.\n`],
+    ];
+    for (const [targetPath, content] of readmeFiles) {
+        if (!fs.existsSync(targetPath)) {
+            fs.writeFileSync(targetPath, content, "utf8");
+        }
+    }
+}
+export function loadMigrationProject(projectDir, { allowMissingConfig = false } = {}) {
+    ensureAdvancedMigrationProject(projectDir);
+    if (!fs.existsSync(path.join(projectDir, ROOT_MANIFEST))) {
+        runProjectScriptIfPresent(projectDir, "sync-types");
+    }
+    const paths = getProjectPaths(projectDir);
+    const config = allowMissingConfig && !fs.existsSync(paths.configFile)
+        ? {
+            blockName: readProjectBlockName(projectDir),
+            currentVersion: "0.0.0",
+            snapshotDir: SNAPSHOT_DIR.replace(/\\/g, "/"),
+            supportedVersions: [],
+        }
+        : parseMigrationConfig(fs.readFileSync(paths.configFile, "utf8"));
+    return {
+        config,
+        currentBlockJson: readJson(path.join(projectDir, ROOT_BLOCK_JSON)),
+        currentManifest: readJson(path.join(projectDir, ROOT_MANIFEST)),
+        paths,
+        projectDir,
+    };
+}
+export function discoverMigrationEntries(state) {
+    const entries = [];
+    const currentVersion = state.config.currentVersion;
+    for (const version of state.config.supportedVersions) {
+        if (version === currentVersion) {
+            continue;
+        }
+        const snapshotRoot = path.join(state.projectDir, SNAPSHOT_DIR, version);
+        const manifestPath = path.join(snapshotRoot, ROOT_MANIFEST);
+        const blockJsonPath = path.join(snapshotRoot, ROOT_BLOCK_JSON);
+        const savePath = path.join(snapshotRoot, "save.tsx");
+        const rulePath = getRuleFilePath(state.paths, version, currentVersion);
+        if (fs.existsSync(manifestPath) &&
+            fs.existsSync(blockJsonPath) &&
+            fs.existsSync(savePath) &&
+            fs.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));
+}
+export 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;
+}
+export function writeMigrationConfig(projectDir, config) {
+    const paths = getProjectPaths(projectDir);
+    fs.mkdirSync(path.dirname(paths.configFile), { recursive: true });
+    fs.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");
+}
+export function readProjectBlockName(projectDir) {
+    const blockJson = readJson(path.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;
+}
+export function assertRuleHasNoTodos(projectDir, fromVersion, toVersion) {
+    const rulePath = getRuleFilePath(getProjectPaths(projectDir), fromVersion, toVersion);
+    if (!fs.existsSync(rulePath)) {
+        throw new Error(`Missing migration rule: ${path.relative(projectDir, rulePath)}`);
+    }
+    const source = fs.readFileSync(rulePath, "utf8");
+    if (source.includes(MIGRATION_TODO_PREFIX)) {
+        throw new Error(`Migration rule still contains ${MIGRATION_TODO_PREFIX} markers: ${path.relative(projectDir, rulePath)}`);
+    }
+}
+export function getRuleFilePath(paths, fromVersion, toVersion) {
+    return path.join(paths.rulesDir, `${fromVersion}-to-${toVersion}.ts`);
+}
+export function readRuleMetadata(rulePath) {
+    const source = fs.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 };
+}

package/dist/runtime/migration-render.js

@@ -0,0 +1,267 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MIGRATION_TODO_PREFIX, ROOT_BLOCK_JSON, ROOT_MANIFEST, SNAPSHOT_DIR, } from "./migration-constants.js";
+import { summarizeManifest, summarizeUnionBranches } from "./migration-manifest.js";
+import { readRuleMetadata } from "./migration-project.js";
+import { escapeForCode, readJson, renderObjectKey, renderPhpValue } from "./migration-utils.js";
+export 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("\n");
+}
+export 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(`\ttype RenameMap,`);
+    lines.push(`\ttype TransformMap,`);
+    lines.push(`\tresolveMigrationAttribute,`);
+    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(`\t${renderObjectKey(candidate.currentPath)}: "${escapeForCode(candidate.legacyPath)}",`);
+    }
+    for (const candidate of suggestedRenameCandidates) {
+        lines.push(`\t// ${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(`\t// ${renderObjectKey(suggestion.currentPath)}: (legacyValue, legacyInput) => {`);
+        for (const bodyLine of suggestion.bodyLines) {
+            lines.push(`\t${bodyLine}`);
+        }
+        lines.push(`\t// },`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const unresolved = [");
+    for (const item of diff.summary.manualItems) {
+        lines.push(`\t"${item.path}: ${item.kind}${item.detail ? ` (${escapeForCode(item.detail)})` : ""}",`);
+    }
+    for (const candidate of suggestedRenameCandidates) {
+        lines.push(`\t"${candidate.currentPath}: rename candidate from ${candidate.legacyPath}",`);
+    }
+    for (const suggestion of diff.summary.transformSuggestions) {
+        lines.push(`\t"${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(`\treturn {`);
+    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(`\t\t// ${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(`\t\t// ${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(`\t\t// ${MIGRATION_TODO_PREFIX} review transforms[${JSON.stringify(suggestion.currentPath)}]`);
+        }
+        lines.push(`\t\t${key}: resolveMigrationAttribute(currentManifest.attributes.${key}, "${key}", "${key}", input, renameMap, transforms),`);
+    }
+    lines.push(`\t} as ${currentTypeName};`);
+    lines.push("}");
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}
+export 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(`\t{`);
+        body.push(`\t\tfromVersion: "${entry.fromVersion}",`);
+        body.push(`\t\tmanifest: manifest_${index},`);
+        body.push(`\t\trule: rule_${index},`);
+        body.push(`\t},`);
+    });
+    return `${imports.join("\n")}
+
+export const migrationRegistry = {
+	currentVersion: "${state.config.currentVersion}",
+	currentManifest,
+	entries: [
+${body.join("\n")}
+	],
+} as const;
+
+export default migrationRegistry;
+`;
+}
+export 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(`\tattributes: (block_${index}.attributes ?? {}) as Record<string, unknown>,`);
+        definitions.push(`\tsave: save_${index} as BlockConfiguration["save"],`);
+        definitions.push(`\tmigrate(attributes: Record<string, unknown>) {`);
+        definitions.push(`\t\treturn rule_${index}.migrate(attributes);`);
+        definitions.push(`\t},`);
+        definitions.push(`};`);
+        arrayEntries.push(`deprecated_${index}`);
+    });
+    return `${imports.join("\n")}
+
+${definitions.join("\n\n")}
+
+export const deprecated: NonNullable<BlockConfiguration["deprecated"]> = [${arrayEntries.join(", ")}];
+`;
+}
+export function renderPhpMigrationRegistryFile(state, entries) {
+    const snapshots = Object.fromEntries(state.config.supportedVersions.map((version) => {
+        const snapshotRoot = path.join(state.projectDir, SNAPSHOT_DIR, version);
+        const manifestPath = path.join(snapshotRoot, ROOT_MANIFEST);
+        const blockJsonPath = path.join(snapshotRoot, ROOT_BLOCK_JSON);
+        const savePath = path.join(snapshotRoot, "save.tsx");
+        return [
+            version,
+            {
+                blockJson: fs.existsSync(blockJsonPath)
+                    ? {
+                        attributeNames: Object.keys((readJson(blockJsonPath).attributes ?? {})),
+                        name: readJson(blockJsonPath).name ?? null,
+                    }
+                    : null,
+                hasSaveSnapshot: fs.existsSync(savePath),
+                manifest: fs.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: path.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)};
+`;
+}
+export 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(`\tif (selectedVersions.length === 0 || selectedVersions.includes("${entry.fromVersion}")) {`);
+        checks.push(`\t\tif (rule_${index}.unresolved.length > 0) {`);
+        checks.push(`\t\t\tthrow new Error("Unresolved migration TODOs remain for ${entry.fromVersion} -> ${entry.toVersion}: " + rule_${index}.unresolved.join(", "));`);
+        checks.push(`\t\t}`);
+        checks.push(`\t\tconst cases_${index} = Array.isArray(fixture_${index}.cases) ? fixture_${index}.cases : [];`);
+        checks.push(`\t\tfor (const fixtureCase of cases_${index}) {`);
+        checks.push(`\t\t\tconst migrated_${index} = rule_${index}.migrate(fixtureCase.input ?? {});`);
+        checks.push(`\t\t\tconst validation_${index} = validators.validate(migrated_${index});`);
+        checks.push(`\t\t\tif (!validation_${index}.success) {`);
+        checks.push(`\t\t\t\tthrow new Error("Current validator rejected migrated fixture for ${entry.fromVersion} case " + String(fixtureCase.name ?? "unknown") + ": " + JSON.stringify(validation_${index}.errors));`);
+        checks.push(`\t\t\t}`);
+        checks.push(`\t\t}`);
+        checks.push(`\t\tconsole.log("Verified ${entry.fromVersion} -> ${entry.toVersion} (" + cases_${index}.length + " case(s))");`);
+        checks.push(`\t}`);
+    });
+    return `${imports.join("\n")}
+
+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("\n")}
+
+console.log("Migration verification passed for ${state.config.blockName}");
+`;
+}

package/dist/runtime/migration-types.js

@@ -0,0 +1 @@
+export {};