@wp-typia/project-tools 0.16.7 → 0.16.9

package/dist/runtime/migration-render.js

@@ -120,14 +120,34 @@ export function renderMigrationRuleFile({ block, currentAttributes, currentTypeN
     lines.push("");
     return `${lines.join("\n")}\n`;
 }
+/**
+ * Renders the generated migration registry module for a block target.
+ *
+ * Prefers manifest wrapper modules when they are available in the project,
+ * while still validating the imported manifest before the registry consumes it.
+ *
+ * @param state The resolved migration project state.
+ * @param blockKey The stable key for the block whose registry is being generated.
+ * @param entries The generated migration entries to include in the registry.
+ * @returns The generated TypeScript source code for the migration registry file.
+ */
 export function renderMigrationRegistryFile(state, blockKey, entries) {
     const block = state.blocks.find((entry) => entry.key === blockKey);
     if (!block) {
         throw new Error(`Unknown migration block target: ${blockKey}`);
     }
+    const generatedDir = getGeneratedDir(block, state);
+    const currentManifestWrapperCandidates = [
+        block.manifestFile.replace(/typia\.manifest\.json$/u, "manifest-document.ts"),
+        path.join(path.dirname(block.typesFile), "manifest-document.ts"),
+    ].filter((candidate, index, allCandidates) => candidate !== block.manifestFile && allCandidates.indexOf(candidate) === index);
+    const currentManifestWrapperFile = currentManifestWrapperCandidates.find((candidate) => fs.existsSync(path.join(state.projectDir, candidate))) ?? null;
+    const currentManifestSourceFile = currentManifestWrapperFile ?? block.manifestFile;
+    const currentManifestImport = normalizeImportPath(path.relative(generatedDir, path.join(state.projectDir, currentManifestSourceFile)), currentManifestWrapperFile !== null);
     const imports = [
-        `import currentManifest from "${normalizeImportPath(path.relative(getGeneratedDir(block, state), path.join(state.projectDir, block.manifestFile)))}";`,
+        `import rawCurrentManifest from "${currentManifestImport}";`,
         `import type { ManifestDocument, MigrationRiskSummary } from "${normalizeImportPath(path.relative(getGeneratedDir(block, state), path.join(state.projectDir, "src", "migrations", "helpers.ts")), true)}";`,
+        `import { parseManifestDocument } from "@wp-typia/block-runtime/editor";`,
     ];
     const body = [];
     entries.forEach(({ entry, riskSummary }, index) => {
@@ -135,7 +155,7 @@ export function renderMigrationRegistryFile(state, blockKey, entries) {
         imports.push(`import * as rule_${index} from "${entry.ruleImport}";`);
         body.push(`\t{`);
         body.push(`\t\tfromMigrationVersion: "${entry.fromVersion}",`);
-        body.push(`\t\tmanifest: manifest_${index},`);
+        body.push(`\t\tmanifest: parseManifestDocument<ManifestDocument>(manifest_${index}),`);
         body.push(`\t\triskSummary: ${JSON.stringify(riskSummary, null, "\t").replace(/\n/g, "\n\t\t")},`);
         body.push(`\t\trule: rule_${index},`);
         body.push(`\t},`);
@@ -159,7 +179,7 @@ export const migrationRegistry: {
 	entries: MigrationRegistryEntry[];
 } = {
 	currentMigrationVersion: "${state.config.currentMigrationVersion}",
-	currentManifest: currentManifest as ManifestDocument,
+	currentManifest: parseManifestDocument<ManifestDocument>(rawCurrentManifest),
 	entries: [
 ${body.join("\n")}
 	],
@@ -168,23 +188,51 @@ ${body.join("\n")}
 export default migrationRegistry;
 `;
 }
-export function renderGeneratedDeprecatedFile(entries) {
+/**
+ * Renders the generated deprecated module for a block target.
+ *
+ * The emitted module exposes the ordered deprecation array consumed by block
+ * registration and migration helpers.
+ *
+ * @param state The resolved migration project state.
+ * @param blockKey The stable key for the block whose deprecated entries are being generated.
+ * @param entries The migration entries that define deprecated manifest versions.
+ * @returns The generated TypeScript source code for the deprecated module.
+ */
+export function renderGeneratedDeprecatedFile(state, blockKey, entries) {
+    const block = state.blocks.find((entry) => entry.key === blockKey);
+    if (!block) {
+        throw new Error(`Unknown migration block target: ${blockKey}`);
+    }
+    const currentTypeName = typeof block.currentManifest.sourceType === "string" &&
+        block.currentManifest.sourceType.length > 0
+        ? block.currentManifest.sourceType
+        : "Record<string, unknown>";
+    const hasNamedCurrentType = currentTypeName !== "Record<string, unknown>";
+    const generatedDir = getGeneratedDir(block, state);
+    const typesImport = normalizeImportPath(path.relative(generatedDir, path.join(state.projectDir, block.typesFile)), true);
     if (entries.length === 0) {
         return `/* eslint-disable prettier/prettier */
-import type { BlockConfiguration } from "@wordpress/blocks";
+import type { BlockDeprecationList } from "@wp-typia/block-types/blocks/registration";
+${hasNamedCurrentType ? `import type { ${currentTypeName} } from "${typesImport}";\n` : ""}
 
-export const deprecated: NonNullable<BlockConfiguration["deprecated"]> = [];
+export const deprecated: BlockDeprecationList<${currentTypeName}> = [];
 `;
     }
-    const imports = [`import type { BlockConfiguration } from "@wordpress/blocks";`];
+    const imports = [
+        `import type { BlockConfiguration, BlockDeprecationList } from "@wp-typia/block-types/blocks/registration";`,
+        ...(hasNamedCurrentType
+            ? [`import type { ${currentTypeName} } from "${typesImport}";`]
+            : []),
+    ];
     const definitions = [];
     const arrayEntries = [];
     entries.forEach((entry, index) => {
         imports.push(`import block_${index} from "${entry.blockJsonImport}";`);
         imports.push(`import save_${index} from "${entry.saveImport}";`);
         imports.push(`import * as rule_${index} from "${entry.ruleImport}";`);
-        definitions.push(`const deprecated_${index}: NonNullable<BlockConfiguration["deprecated"]>[number] = {`);
-        definitions.push(`\tattributes: (block_${index}.attributes ?? {}) as Record<string, unknown>,`);
+        definitions.push(`const deprecated_${index}: BlockDeprecationList<${currentTypeName}>[number] = {`);
+        definitions.push(`\tattributes: (block_${index}.attributes ?? {}) as BlockConfiguration["attributes"],`);
         definitions.push(`\tsave: save_${index} as BlockConfiguration["save"],`);
         definitions.push(`\tmigrate(attributes: Record<string, unknown>) {`);
         definitions.push(`\t\treturn rule_${index}.migrate(attributes);`);
@@ -197,7 +245,7 @@ ${imports.join("\n")}
 
 ${definitions.join("\n\n")}
 
-export const deprecated: NonNullable<BlockConfiguration["deprecated"]> = [${arrayEntries.join(", ")}];
+export const deprecated: BlockDeprecationList<${currentTypeName}> = [${arrayEntries.join(", ")}];
 `;
 }
 export function renderGeneratedMigrationIndexFile(state, entries) {

package/dist/runtime/migration-ui-capability.js

@@ -6,6 +6,8 @@ import { seedProjectMigrations } from "./migrations.js";
 import { copyInterpolatedDirectory } from "./template-render.js";
 import { SHARED_MIGRATION_UI_TEMPLATE_ROOT, } from "./template-registry.js";
 const INITIAL_MIGRATION_VERSION = "v1";
+const BLOCK_METADATA_IMPORT_LINE = "import metadata from './block-metadata';";
+const LEGACY_BLOCK_JSON_IMPORT_LINE = "import metadata from './block.json';";
 async function mutatePackageJson(projectDir, mutate) {
     const packageJsonPath = path.join(projectDir, "package.json");
     const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, "utf8"));
@@ -38,6 +40,13 @@ function injectBefore(source, needle, insertion) {
     }
     return source.replace(needle, `${insertion}\n${needle}`);
 }
+function injectAfterBlockMetadataImport(source, insertion) {
+    let nextSource = injectAfter(source, BLOCK_METADATA_IMPORT_LINE, insertion);
+    if (nextSource !== source) {
+        return nextSource;
+    }
+    return injectAfter(source, LEGACY_BLOCK_JSON_IMPORT_LINE, insertion);
+}
 function buildMigrationBlocks(templateId, variables) {
     if (templateId === "compound") {
         return [
@@ -74,11 +83,11 @@ async function applySingleBlockPatches(projectDir, variables) {
     const editPath = path.join(projectDir, "src", "edit.tsx");
     const indexPath = path.join(projectDir, "src", "index.tsx");
     const deprecatedImport = `import { deprecated } from './migrations/generated/${variables.slugKebabCase}/deprecated';`;
-    const deprecatedLine = `  deprecated: deprecated as NonNullable<BlockConfiguration<${variables.pascalCase}Attributes>['deprecated']>,`;
+    const deprecatedLine = "  deprecated,";
     const dashboardImport = `import { MigrationDashboard } from './admin/migration-dashboard';`;
     const migrationPanel = `\n        <PanelBody title={__('Migration Manager', '${variables.textDomain}')}>\n          <MigrationDashboard />\n        </PanelBody>\n      </InspectorControls>`;
     await patchFile(indexPath, (source) => {
-        let nextSource = injectAfter(source, "import metadata from './block.json';", deprecatedImport);
+        let nextSource = injectAfterBlockMetadataImport(source, deprecatedImport);
         nextSource = injectBefore(nextSource, "  edit: Edit,", deprecatedLine);
         return nextSource;
     });
@@ -94,13 +103,13 @@ async function applyCompoundPatches(projectDir, variables) {
     const childIndexPath = path.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`, "index.tsx");
     const addChildScriptPath = path.join(projectDir, "scripts", "add-compound-child.ts");
     await patchFile(parentIndexPath, (source) => {
-        let nextSource = injectAfter(source, "import metadata from './block.json';", `import { deprecated } from '../../migrations/generated/${variables.slugKebabCase}/deprecated';`);
-        nextSource = injectBefore(nextSource, "\tedit: Edit,", `\tdeprecated: deprecated as NonNullable<BlockConfiguration< ${variables.pascalCase}Attributes >['deprecated']>,`);
+        let nextSource = injectAfterBlockMetadataImport(source, `import { deprecated } from '../../migrations/generated/${variables.slugKebabCase}/deprecated';`);
+        nextSource = injectBefore(nextSource, "\tedit: Edit,", "\tdeprecated,");
         return nextSource;
     });
     await patchFile(childIndexPath, (source) => {
-        let nextSource = injectAfter(source, "import metadata from './block.json';", `import { deprecated } from '../../migrations/generated/${variables.slugKebabCase}-item/deprecated';`);
-        nextSource = injectBefore(nextSource, "\tedit: Edit,", `\tdeprecated: deprecated as NonNullable<BlockConfiguration< ${variables.pascalCase}ItemAttributes >['deprecated']>,`);
+        let nextSource = injectAfterBlockMetadataImport(source, `import { deprecated } from '../../migrations/generated/${variables.slugKebabCase}-item/deprecated';`);
+        nextSource = injectBefore(nextSource, "\tedit: Edit,", "\tdeprecated,");
         return nextSource;
     });
     await patchFile(parentEditPath, (source) => {
@@ -110,8 +119,8 @@ async function applyCompoundPatches(projectDir, variables) {
     });
     await patchFile(addChildScriptPath, (source) => {
         let nextSource = injectAfter(source, "const PROJECT_ROOT = process.cwd();", "const MIGRATION_CONFIG_FILE = path.join( PROJECT_ROOT, 'src', 'migrations', 'config.ts' );");
-        nextSource = nextSource.replace("import metadata from './block.json';\nimport '${ PARENT_STYLE_IMPORT }';", "import metadata from './block.json';\nimport { deprecated } from '../../migrations/generated/${ childFolderSlug }/deprecated';\nimport '${ PARENT_STYLE_IMPORT }';");
-        nextSource = nextSource.replace("\tedit: Edit,\n\tsave: Save,", "\tdeprecated: deprecated as NonNullable<BlockConfiguration< ${ childTypeName } >['deprecated']>,\n\tedit: Edit,\n\tsave: Save,");
+        nextSource = injectAfterBlockMetadataImport(nextSource, "import { deprecated } from '../../migrations/generated/${ childFolderSlug }/deprecated';");
+        nextSource = nextSource.replace("\\t\\tedit: Edit,\n\\t\\tsave: Save,", "\\t\\tdeprecated,\n\\t\\tedit: Edit,\n\\t\\tsave: Save,");
         nextSource = injectAfter(nextSource, "function insertBeforeMarker( filePath: string, marker: string, insertionLines: string[] ) {", "");
         if (!nextSource.includes("function appendMigrationBlockConfig")) {
             const appendMigrationHelper = [

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

@@ -1,8 +1,9 @@
-import type { JsonValue, ManifestAttribute, JsonObject } from "./migration-types.js";
-export { cloneJsonValue } from "./json-utils.js";
-export declare function getValueAtPath(input: Record<string, unknown>, pathLabel: string): unknown;
-export declare function setValueAtPath(input: Record<string, unknown>, pathLabel: string, value: unknown): void;
-export declare function deleteValueAtPath(input: Record<string, unknown>, pathLabel: string): void;
+import type { JsonValue, ManifestAttribute, JsonObject } from './migration-types.js';
+import { type UnknownRecord } from './object-utils.js';
+export { cloneJsonValue } from './json-utils.js';
+export declare function getValueAtPath<TRecord extends UnknownRecord>(input: TRecord, pathLabel: string): unknown;
+export declare function setValueAtPath<TRecord extends UnknownRecord>(input: TRecord, pathLabel: string, value: unknown): TRecord;
+export declare function deleteValueAtPath<TRecord extends UnknownRecord>(input: TRecord, pathLabel: string): TRecord;
 export declare function createFixtureScalarValue(pathLabel: string): JsonValue;
 export declare function createTransformFixtureValue(attribute: ManifestAttribute | null | undefined, pathLabel: string): JsonValue;
 export declare function readJson<T = unknown>(filePath: string): T;
@@ -11,7 +12,7 @@ export declare function copyFile(sourcePath: string, targetPath: string): void;
 export declare function sanitizeSaveSnapshotSource(source: string): string;
 export declare function sanitizeSnapshotBlockJson(blockJson: JsonObject): JsonObject;
 export declare function runProjectScriptIfPresent(projectDir: string, scriptName: string): void;
-export declare function detectPackageManagerId(projectDir: string): "bun" | "npm" | "pnpm" | "yarn";
+export declare function detectPackageManagerId(projectDir: string): 'bun' | 'npm' | 'pnpm' | 'yarn';
 export declare function getLocalTsxBinary(projectDir: string): string;
 /**
  * Returns whether isInteractiveTerminal() is running with both stdin and stdout

package/dist/runtime/migration-utils.js

@@ -1,96 +1,99 @@
-import fs from "node:fs";
-import path from "node:path";
-import { execSync } from "node:child_process";
-import { formatRunScript } from "./package-managers.js";
-export { cloneJsonValue } from "./json-utils.js";
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { formatRunScript } from './package-managers.js';
+import { isPlainObject } from './object-utils.js';
+export { cloneJsonValue } from './json-utils.js';
 const MIGRATION_VERSION_LABEL_PATTERN = /^v([1-9]\d*)$/;
 const LEGACY_SEMVER_MIGRATION_VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
 export function getValueAtPath(input, pathLabel) {
     return String(pathLabel)
-        .split(".")
-        .reduce((value, segment) => value && typeof value === "object" ? value[segment] : undefined, input);
+        .split('.')
+        .reduce((value, segment) => (isPlainObject(value) ? value[segment] : undefined), input);
 }
 export function setValueAtPath(input, pathLabel, value) {
-    const segments = String(pathLabel).split(".");
+    const segments = String(pathLabel).split('.');
     let target = input;
     while (segments.length > 1) {
         const segment = segments.shift();
         if (!segment) {
             continue;
         }
-        if (!target[segment] || typeof target[segment] !== "object" || Array.isArray(target[segment])) {
+        if (!isPlainObject(target[segment])) {
             target[segment] = {};
         }
         target = target[segment];
     }
     target[segments[0]] = value;
+    return input;
 }
 export function deleteValueAtPath(input, pathLabel) {
-    const segments = String(pathLabel).split(".");
+    const segments = String(pathLabel).split('.');
     let target = input;
     while (segments.length > 1) {
         const segment = segments.shift();
-        if (!segment || !target[segment] || typeof target[segment] !== "object") {
-            return;
+        if (!segment || !isPlainObject(target[segment])) {
+            return input;
         }
         target = target[segment];
     }
     delete target[segments[0]];
+    return input;
 }
 export function createFixtureScalarValue(pathLabel) {
     const normalized = String(pathLabel).toLowerCase();
-    if (normalized.includes("id")) {
-        return "00000000-0000-4000-8000-000000000000";
+    if (normalized.includes('id')) {
+        return '00000000-0000-4000-8000-000000000000';
     }
-    if (normalized.includes("count") || normalized.includes("number")) {
+    if (normalized.includes('count') || normalized.includes('number')) {
         return 1;
     }
-    if (normalized.includes("visible") || normalized.startsWith("is")) {
+    if (normalized.includes('visible') || normalized.startsWith('is')) {
         return true;
     }
     return `legacy:${pathLabel}`;
 }
 export function createTransformFixtureValue(attribute, pathLabel) {
     switch (attribute?.ts?.kind) {
-        case "number":
-            return "42";
-        case "boolean":
-            return "1";
-        case "union":
-            return { kind: "unknown" };
+        case 'number':
+            return '42';
+        case 'boolean':
+            return '1';
+        case 'union':
+            return { kind: 'unknown' };
         default:
             return createFixtureScalarValue(pathLabel);
     }
 }
 export function readJson(filePath) {
-    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
 }
 export function renderPhpValue(value, indentLevel) {
-    const indent = "\t".repeat(indentLevel);
-    const nestedIndent = "\t".repeat(indentLevel + 1);
+    const indent = '\t'.repeat(indentLevel);
+    const nestedIndent = '\t'.repeat(indentLevel + 1);
     if (value === null) {
-        return "null";
+        return 'null';
     }
-    if (typeof value === "string") {
-        return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+    if (typeof value === 'string') {
+        return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
     }
-    if (typeof value === "number" || typeof value === "boolean") {
+    if (typeof value === 'number' || typeof value === 'boolean') {
         return String(value);
     }
     if (Array.isArray(value)) {
         if (value.length === 0) {
-            return "[]";
+            return '[]';
         }
         const items = value.map((item) => `${nestedIndent}${renderPhpValue(item, indentLevel + 1)}`);
-        return `[\n${items.join(",\n")}\n${indent}]`;
+        return `[\n${items.join(',\n')}\n${indent}]`;
     }
-    if (typeof value === "object") {
+    if (typeof value === 'object') {
         const entries = Object.entries(value);
         if (entries.length === 0) {
-            return "[]";
+            return '[]';
         }
-        const items = entries.map(([key, item]) => `${nestedIndent}'${String(key).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}' => ${renderPhpValue(item, indentLevel + 1)}`);
-        return `[\n${items.join(",\n")}\n${indent}]`;
+        const items = entries.map(([key, item]) => `${nestedIndent}'${String(key).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}' => ${renderPhpValue(item, indentLevel + 1)}`);
+        return `[\n${items.join(',\n')}\n${indent}]`;
     }
     throw new Error(`Unable to encode PHP migration registry value for ${String(value)}`);
 }
@@ -100,60 +103,60 @@ export function copyFile(sourcePath, targetPath) {
 }
 export function sanitizeSaveSnapshotSource(source) {
     return source
-        .replace(/^import\s+\{[^}]+\}\s+from\s+['"]\.\/types['"];?\n?/gm, "")
-        .replace(/^interface\s+SaveProps\s*\{[\s\S]*?\}\n?/m, "")
-        .replace(/: SaveProps/g, ": { attributes: any }")
-        .replace(/attributes:\s*[A-Za-z0-9_<>{}\[\]|&,\s]+;/g, "attributes: any;")
-        .replace(/\(\{\s*attributes\s*\}:\s*\{\s*attributes:\s*any\s*\}\)/g, "({ attributes }: { attributes: any })")
-        .replace(/\n{3,}/g, "\n\n")
+        .replace(/^import\s+\{[^}]+\}\s+from\s+['"]\.\/types['"];?\n?/gm, '')
+        .replace(/^interface\s+SaveProps\s*\{[\s\S]*?\}\n?/m, '')
+        .replace(/: SaveProps/g, ': { attributes: any }')
+        .replace(/attributes:\s*[A-Za-z0-9_<>{}\[\]|&,\s]+;/g, 'attributes: any;')
+        .replace(/\(\{\s*attributes\s*\}:\s*\{\s*attributes:\s*any\s*\}\)/g, '({ attributes }: { attributes: any })')
+        .replace(/\n{3,}/g, '\n\n')
         .trimEnd()
-        .concat("\n");
+        .concat('\n');
 }
 export function sanitizeSnapshotBlockJson(blockJson) {
     const snapshot = { ...blockJson };
     for (const key of [
-        "editorScript",
-        "script",
-        "scriptModule",
-        "viewScript",
-        "viewScriptModule",
-        "style",
-        "editorStyle",
-        "render",
+        'editorScript',
+        'script',
+        'scriptModule',
+        'viewScript',
+        'viewScriptModule',
+        'style',
+        'editorStyle',
+        'render',
     ]) {
         delete snapshot[key];
     }
     return snapshot;
 }
 export function runProjectScriptIfPresent(projectDir, scriptName) {
-    const packageJson = readJson(path.join(projectDir, "package.json"));
+    const packageJson = readJson(path.join(projectDir, 'package.json'));
     if (!packageJson.scripts?.[scriptName]) {
         return;
     }
     const packageManagerId = detectPackageManagerId(projectDir);
     execSync(formatRunScript(packageManagerId, scriptName), {
         cwd: projectDir,
-        stdio: "inherit",
+        stdio: 'inherit',
     });
 }
 export function detectPackageManagerId(projectDir) {
-    const packageJson = readJson(path.join(projectDir, "package.json"));
-    const field = String(packageJson.packageManager ?? "");
-    if (field.startsWith("bun@"))
-        return "bun";
-    if (field.startsWith("npm@"))
-        return "npm";
-    if (field.startsWith("pnpm@"))
-        return "pnpm";
-    if (field.startsWith("yarn@"))
-        return "yarn";
-    return "bun";
+    const packageJson = readJson(path.join(projectDir, 'package.json'));
+    const field = String(packageJson.packageManager ?? '');
+    if (field.startsWith('bun@'))
+        return 'bun';
+    if (field.startsWith('npm@'))
+        return 'npm';
+    if (field.startsWith('pnpm@'))
+        return 'pnpm';
+    if (field.startsWith('yarn@'))
+        return 'yarn';
+    return 'bun';
 }
 export function getLocalTsxBinary(projectDir) {
-    const filename = process.platform === "win32" ? "tsx.cmd" : "tsx";
-    const binaryPath = path.join(projectDir, "node_modules", ".bin", filename);
+    const filename = process.platform === 'win32' ? 'tsx.cmd' : 'tsx';
+    const binaryPath = path.join(projectDir, 'node_modules', '.bin', filename);
     if (!fs.existsSync(binaryPath)) {
-        throw new Error("Local tsx binary was not found. Install project dependencies before running migration verification.");
+        throw new Error('Local tsx binary was not found. Install project dependencies before running migration verification.');
     }
     return binaryPath;
 }
@@ -172,7 +175,7 @@ export function isInteractiveTerminal() {
  * @returns The concrete migration version label that should be used.
  */
 export function resolveTargetMigrationVersion(currentMigrationVersion, value) {
-    return value === "current" ? currentMigrationVersion : value;
+    return value === 'current' ? currentMigrationVersion : value;
 }
 /**
  * Returns whether a value matches the canonical `vN` migration label format.
@@ -230,17 +233,17 @@ export function compareMigrationVersionLabels(left, right) {
  */
 export function formatLegacyMigrationWorkspaceResetGuidance(reason) {
     return [
-        reason ? `${reason} ` : "",
-        "Back up `src/migrations/` if needed, remove or reset the existing migration workspace, ",
-        "then rerun `wp-typia migrate init --current-migration-version v1`.",
-    ].join("");
+        reason ? `${reason} ` : '',
+        'Back up `src/migrations/` if needed, remove or reset the existing migration workspace, ',
+        'then rerun `wp-typia migrate init --current-migration-version v1`.',
+    ].join('');
 }
 export function escapeForCode(value) {
-    return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
 }
 export function renderObjectKey(key) {
     return JSON.stringify(String(key));
 }
 export function isNumber(value) {
-    return typeof value === "number" && Number.isFinite(value);
+    return typeof value === 'number' && Number.isFinite(value);
 }

package/dist/runtime/migrations.js

@@ -667,7 +667,7 @@ export function doctorProjectMigrations(projectDir, { all = false, fromMigration
             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(entries));
+            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));
         }
@@ -942,7 +942,7 @@ function regenerateGeneratedArtifacts(projectDir) {
         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(entries), "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");
     }

package/dist/runtime/object-utils.d.ts

@@ -1,7 +1,7 @@
 /**
  * Generic record type used for JSON-like plain-object inspection.
  */
-export type UnknownRecord = Record<string, unknown>;
+export type UnknownRecord<TValue = unknown> = Record<string, TValue>;
 /**
  * Delegate plain-object detection to the shared runtime primitive owner.
  *
@@ -10,3 +10,10 @@ export type UnknownRecord = Record<string, unknown>;
  * `Object.prototype` or `null` prototype.
  */
 export declare function isPlainObject(value: unknown): value is UnknownRecord;
+/**
+ * Serialize JSON-like values with deterministic plain-object key ordering.
+ *
+ * Arrays preserve their declared order, while plain objects are normalized by
+ * sorting keys recursively before calling `JSON.stringify`.
+ */
+export declare function stableJsonStringify(value: unknown): string;

package/dist/runtime/object-utils.js

@@ -1,4 +1,4 @@
-import { isPlainObject as isSharedPlainObject } from "@wp-typia/api-client/runtime-primitives";
+import { isPlainObject as isSharedPlainObject } from '@wp-typia/api-client/runtime-primitives';
 /**
  * Delegate plain-object detection to the shared runtime primitive owner.
  *
@@ -9,3 +9,23 @@ import { isPlainObject as isSharedPlainObject } from "@wp-typia/api-client/runti
 export function isPlainObject(value) {
     return isSharedPlainObject(value);
 }
+function toStableJsonValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => toStableJsonValue(entry));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.keys(value)
+            .sort((left, right) => left < right ? -1 : left > right ? 1 : 0)
+            .map((key) => [key, toStableJsonValue(value[key])]));
+    }
+    return value;
+}
+/**
+ * Serialize JSON-like values with deterministic plain-object key ordering.
+ *
+ * Arrays preserve their declared order, while plain objects are normalized by
+ * sorting keys recursively before calling `JSON.stringify`.
+ */
+export function stableJsonStringify(value) {
+    return JSON.stringify(toStableJsonValue(value));
+}

package/dist/runtime/scaffold-apply-utils.d.ts

@@ -24,11 +24,22 @@ export declare function seedBuiltInPersistenceArtifacts(targetDir: string, templ
 export declare function normalizePackageManagerFiles(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
 export declare function normalizePackageJson(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
 export declare function removeUnexpectedLockfiles(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
-export declare function replaceTextRecursively(targetDir: string, packageManagerId: PackageManagerId): Promise<void>;
+/**
+ * Recursively normalizes generated text files for the selected package manager
+ * and repository reference.
+ */
+export declare function replaceTextRecursively(targetDir: string, packageManagerId: PackageManagerId, { repositoryManifestPaths, repositoryReference, }?: {
+    repositoryManifestPaths?: readonly string[];
+    repositoryReference?: string;
+}): Promise<void>;
 export declare function defaultInstallDependencies({ projectDir, packageManager, }: InstallDependenciesOptions): Promise<void>;
 export declare function isOfficialWorkspaceProject(projectDir: string): boolean;
 export declare function applyWorkspaceMigrationCapability(projectDir: string, packageManager: PackageManagerId): Promise<void>;
-export declare function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir, templateId, variables, artifacts, codeArtifacts, readmeContent, gitignoreContent, allowExistingDir, packageManager, withMigrationUi, withTestPreset, withWpEnv, noInstall, installDependencies, }: {
+/**
+ * Applies a built-in scaffold into the target directory, including generated
+ * code artifacts, starter manifests, preset files, and placeholder rewrites.
+ */
+export declare function applyBuiltInScaffoldProjectFiles({ projectDir, templateDir, templateId, variables, artifacts, codeArtifacts, readmeContent, gitignoreContent, allowExistingDir, packageManager, withMigrationUi, withTestPreset, withWpEnv, noInstall, installDependencies, repositoryReference, }: {
     projectDir: string;
     templateDir: string;
     templateId: BuiltInTemplateId;
@@ -44,4 +55,5 @@ export declare function applyBuiltInScaffoldProjectFiles({ projectDir, templateD
     withWpEnv?: boolean;
     noInstall?: boolean;
     installDependencies?: ((options: InstallDependenciesOptions) => Promise<void>) | undefined;
+    repositoryReference?: string;
 }): Promise<void>;