wp-typia 0.22.6 → 0.22.7

package/dist-bunli/.bunli/commands.gen.js

@@ -36417,8 +36417,35 @@ function isFileNotFoundError(error48) {
 }
 var init_cli_add_filesystem = () => {};
 
+// ../wp-typia-project-tools/src/runtime/fs-async.ts
+import { promises as fsp4 } from "fs";
+async function pathExists(filePath) {
+  try {
+    await fsp4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readOptionalUtf8File(filePath) {
+  try {
+    return await fsp4.readFile(filePath, "utf8");
+  } catch (error48) {
+    if (isFileNotFoundError2(error48)) {
+      return null;
+    }
+    throw error48;
+  }
+}
+function getNodeErrorCode(error48) {
+  return typeof error48 === "object" && error48 !== null && "code" in error48 ? String(error48.code) : "";
+}
+function isFileNotFoundError2(error48) {
+  return getNodeErrorCode(error48) === "ENOENT";
+}
+var init_fs_async = () => {};
+
 // ../wp-typia-project-tools/src/runtime/cli-add-block-json.ts
-import fs8 from "fs";
 import path13 from "path";
 import { parseScaffoldBlockMetadata } from "@wp-typia/block-runtime/blocks";
 function resolveWorkspaceBlock(inventory, blockSlug) {
@@ -36428,14 +36455,15 @@ function resolveWorkspaceBlock(inventory, blockSlug) {
   }
   return block;
 }
-function readWorkspaceBlockJson(projectDir, blockSlug) {
+async function readWorkspaceBlockJson(projectDir, blockSlug) {
   const blockJsonPath = path13.join(projectDir, "src", "blocks", blockSlug, "block.json");
-  if (!fs8.existsSync(blockJsonPath)) {
+  const source = await readOptionalUtf8File(blockJsonPath);
+  if (source === null) {
     throw new Error(`Missing ${path13.relative(projectDir, blockJsonPath)} for workspace block "${blockSlug}".`);
   }
   let blockJson;
   try {
-    blockJson = parseScaffoldBlockMetadata(JSON.parse(fs8.readFileSync(blockJsonPath, "utf8")));
+    blockJson = parseScaffoldBlockMetadata(JSON.parse(source));
   } catch (error48) {
     throw new Error(error48 instanceof Error ? `Failed to parse ${path13.relative(projectDir, blockJsonPath)}: ${error48.message}` : `Failed to parse ${path13.relative(projectDir, blockJsonPath)}.`);
   }
@@ -36456,15 +36484,17 @@ function getMutableBlockHooks(blockJson, blockJsonRelativePath) {
   }
   return blockHooks;
 }
-var init_cli_add_block_json = () => {};
+var init_cli_add_block_json = __esm(() => {
+  init_fs_async();
+});
 
 // ../wp-typia-project-tools/src/runtime/cli-add-collision.ts
-import fs9 from "fs";
+import fs8 from "fs";
 import path14 from "path";
 function assertScaffoldDoesNotExist(options) {
   for (const collision of options.filesystemCollisions) {
     const targetPath = path14.join(options.projectDir, collision.relativePath);
-    if (fs9.existsSync(targetPath)) {
+    if (fs8.existsSync(targetPath)) {
       throw new Error(`${collision.label} already exists at ${path14.relative(options.projectDir, targetPath)}. Choose a different name.`);
     }
   }
@@ -36797,7 +36827,7 @@ var init_json_utils = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-utils.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import path15 from "path";
 import { execSync } from "child_process";
 function getValueAtPath(input, pathLabel) {
@@ -36858,7 +36888,7 @@ function createTransformFixtureValue(attribute, pathLabel) {
   }
 }
 function readJson(filePath) {
-  return JSON.parse(fs10.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs9.readFileSync(filePath, "utf8"));
 }
 function renderPhpValue(value2, indentLevel) {
   const indent = "\t".repeat(indentLevel);
@@ -36896,8 +36926,8 @@ ${indent}]`;
   throw new Error(`Unable to encode PHP migration registry value for ${String(value2)}`);
 }
 function copyFile(sourcePath, targetPath) {
-  fs10.mkdirSync(path15.dirname(targetPath), { recursive: true });
-  fs10.copyFileSync(sourcePath, targetPath);
+  fs9.mkdirSync(path15.dirname(targetPath), { recursive: true });
+  fs9.copyFileSync(sourcePath, targetPath);
 }
 function sanitizeSaveSnapshotSource(source) {
   return source.replace(/^import\s+\{[^}]+\}\s+from\s+['"]\.\/types['"];?\n?/gm, "").replace(/^interface\s+SaveProps\s*\{[\s\S]*?\}\n?/m, "").replace(/: SaveProps/g, ": { attributes: any }").replace(/attributes:\s*[A-Za-z0-9_<>{}\[\]|&,\s]+;/g, "attributes: any;").replace(/\(\{\s*attributes\s*\}:\s*\{\s*attributes:\s*any\s*\}\)/g, "({ attributes }: { attributes: any })").replace(/\n{3,}/g, `
@@ -36939,7 +36969,7 @@ function detectPackageManagerId(projectDir) {
 function getLocalTsxBinary(projectDir) {
   const filename = process.platform === "win32" ? "tsx.cmd" : "tsx";
   const binaryPath = path15.join(projectDir, "node_modules", ".bin", filename);
-  if (!fs10.existsSync(binaryPath)) {
+  if (!fs9.existsSync(binaryPath)) {
     throw new Error("Local tsx binary was not found. Install project dependencies before running migration verification.");
   }
   return binaryPath;
@@ -37430,14 +37460,14 @@ var init_migration_constants = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-project-layout-discovery.ts
-import fs11 from "fs";
+import fs10 from "fs";
 import path17 from "path";
 function readSingleBlockTarget(projectDir, {
   blockJsonFile,
   manifestFile
 }) {
   const requiredFiles = [blockJsonFile, ROOT_SAVE_FILE, ROOT_TYPES_FILE];
-  if (requiredFiles.some((relativePath) => !fs11.existsSync(path17.join(projectDir, relativePath)))) {
+  if (requiredFiles.some((relativePath) => !fs10.existsSync(path17.join(projectDir, relativePath)))) {
     return null;
   }
   const blockName = readJson(path17.join(projectDir, blockJsonFile))?.name;
@@ -37457,10 +37487,10 @@ function collectSingleBlockCandidates(projectDir) {
   return SINGLE_BLOCK_LAYOUT_CANDIDATES.filter(({ blockJsonFile }) => hasSingleBlockLayoutFiles(projectDir, blockJsonFile));
 }
 function hasSingleBlockLayoutFiles(projectDir, blockJsonFile) {
-  return [blockJsonFile, ROOT_SAVE_FILE, ROOT_TYPES_FILE].every((relativePath) => fs11.existsSync(path17.join(projectDir, relativePath)));
+  return [blockJsonFile, ROOT_SAVE_FILE, ROOT_TYPES_FILE].every((relativePath) => fs10.existsSync(path17.join(projectDir, relativePath)));
 }
 function orderSingleBlockCandidates(projectDir, candidates) {
-  const candidatesWithManifest = candidates.filter(({ manifestFile }) => fs11.existsSync(path17.join(projectDir, manifestFile)));
+  const candidatesWithManifest = candidates.filter(({ manifestFile }) => fs10.existsSync(path17.join(projectDir, manifestFile)));
   return [
     ...candidatesWithManifest,
     ...candidates.filter((candidate) => !candidatesWithManifest.includes(candidate))
@@ -37471,7 +37501,7 @@ function createImplicitLegacyBlock(projectDir, blockName) {
     try {
       const rootTarget = readSingleBlockTarget(projectDir, LEGACY_ROOT_SINGLE_BLOCK_LAYOUT);
       const srcTarget = readSingleBlockTarget(projectDir, SINGLE_BLOCK_LAYOUT_CANDIDATES[0]);
-      const hasSrcManifest = fs11.existsSync(path17.join(projectDir, SRC_MANIFEST));
+      const hasSrcManifest = fs10.existsSync(path17.join(projectDir, SRC_MANIFEST));
       if (rootTarget?.blockName === blockName && (!srcTarget || srcTarget.blockName !== blockName || !hasSrcManifest)) {
         return {
           ...rootTarget,
@@ -37497,8 +37527,8 @@ function getRequiredProjectFiles(projectDir, blocks) {
     ];
   }
   const configPath = path17.join(projectDir, CONFIG_FILE);
-  if (fs11.existsSync(configPath)) {
-    const config2 = parseMigrationConfig(fs11.readFileSync(configPath, "utf8"));
+  if (fs10.existsSync(configPath)) {
+    const config2 = parseMigrationConfig(fs10.readFileSync(configPath, "utf8"));
     const configuredBlocks = config2.blocks ?? [createImplicitLegacyBlock(projectDir, config2.blockName)];
     return [
       "package.json",
@@ -37523,7 +37553,7 @@ function getRequiredProjectFiles(projectDir, blocks) {
   return SUPPORTED_PROJECT_FILES;
 }
 function ensureAdvancedMigrationProject(projectDir, blocks) {
-  const missing = getRequiredProjectFiles(projectDir, blocks).filter((relativePath) => !fs11.existsSync(path17.join(projectDir, relativePath)));
+  const missing = getRequiredProjectFiles(projectDir, blocks).filter((relativePath) => !fs10.existsSync(path17.join(projectDir, relativePath)));
   if (missing.length > 0) {
     throw new Error(`This directory is not a supported migration-capable project. Missing: ${missing.join(", ")}`);
   }
@@ -37536,7 +37566,7 @@ function createBlockTarget(projectDir, {
   typesFile
 }) {
   const requiredFiles = [blockJsonFile, saveFile, typesFile];
-  if (requiredFiles.some((relativePath) => !fs11.existsSync(path17.join(projectDir, relativePath)))) {
+  if (requiredFiles.some((relativePath) => !fs10.existsSync(path17.join(projectDir, relativePath)))) {
     return null;
   }
   const blockName = readJson(path17.join(projectDir, blockJsonFile))?.name;
@@ -37608,14 +37638,14 @@ function discoverSingleBlockTarget(projectDir, preferredBlockName) {
 function discoverMigrationLayout(projectDir) {
   const blocksRoot = path17.join(projectDir, "src", "blocks");
   let firstMultiBlockError = null;
-  if (fs11.existsSync(blocksRoot) && fs11.statSync(blocksRoot).isDirectory()) {
-    const blockDirectories = fs11.readdirSync(blocksRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    const candidateDirectories = blockDirectories.filter((directory) => fs11.existsSync(path17.join(blocksRoot, directory, "block.json")));
+  if (fs10.existsSync(blocksRoot) && fs10.statSync(blocksRoot).isDirectory()) {
+    const blockDirectories = fs10.readdirSync(blocksRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    const candidateDirectories = blockDirectories.filter((directory) => fs10.existsSync(path17.join(blocksRoot, directory, "block.json")));
     if (candidateDirectories.length > 0) {
       const blocks = candidateDirectories.flatMap((directory) => {
         const saveFile = path17.join("src", "blocks", directory, "save.tsx");
         const typesFile = path17.join("src", "blocks", directory, "types.ts");
-        const missingFiles = [saveFile, typesFile].filter((relativePath) => !fs11.existsSync(path17.join(projectDir, relativePath)));
+        const missingFiles = [saveFile, typesFile].filter((relativePath) => !fs10.existsSync(path17.join(projectDir, relativePath)));
         if (missingFiles.length > 0) {
           firstMultiBlockError ??= createMalformedMultiBlockTargetError(directory, `the block target is missing ${missingFiles.join(", ")}`);
           return [];
@@ -37718,7 +37748,7 @@ var init_migration_project_layout_discovery = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-project-layout-paths.ts
-import fs12 from "fs";
+import fs11 from "fs";
 import path18 from "path";
 function toImportPath(fromDir, targetPath, stripExtension = false) {
   let relativePath = normalizeRelativePath(path18.relative(fromDir, targetPath));
@@ -37752,7 +37782,7 @@ function getSnapshotManifestPath(projectDir, block, version2) {
   return path18.join(getSnapshotRoot(projectDir, block, version2), ROOT_MANIFEST);
 }
 function getAvailableSnapshotVersionsForBlock(projectDir, supportedMigrationVersions, block) {
-  return supportedMigrationVersions.filter((version2) => fs12.existsSync(getSnapshotManifestPath(projectDir, block, version2))).sort(compareMigrationVersionLabels);
+  return supportedMigrationVersions.filter((version2) => fs11.existsSync(getSnapshotManifestPath(projectDir, block, version2))).sort(compareMigrationVersionLabels);
 }
 function createMissingBlockSnapshotMessage(blockName, fromVersion, availableSnapshotVersions) {
   return availableSnapshotVersions.length === 0 ? `Snapshot manifest for ${blockName} @ ${fromVersion} does not exist. ` + `No snapshots exist yet for ${blockName}. Run \`wp-typia migrate snapshot --migration-version ${fromVersion}\` first.` : `Snapshot manifest for ${blockName} @ ${fromVersion} does not exist. ` + `Available snapshot versions for ${blockName}: ${availableSnapshotVersions.join(", ")}. ` + `Run \`wp-typia migrate snapshot --migration-version ${fromVersion}\` first if you want to preserve that release.`;
@@ -37784,17 +37814,17 @@ function getValidatorsImportPath(projectDir, block, fromDir) {
 }
 function ensureMigrationDirectories(projectDir, blocks) {
   const paths = getProjectPaths(projectDir);
-  fs12.mkdirSync(paths.fixturesDir, { recursive: true });
-  fs12.mkdirSync(paths.generatedDir, { recursive: true });
-  fs12.mkdirSync(paths.rulesDir, { recursive: true });
-  fs12.mkdirSync(paths.snapshotDir, { recursive: true });
+  fs11.mkdirSync(paths.fixturesDir, { recursive: true });
+  fs11.mkdirSync(paths.generatedDir, { recursive: true });
+  fs11.mkdirSync(paths.rulesDir, { recursive: true });
+  fs11.mkdirSync(paths.snapshotDir, { recursive: true });
   if (!Array.isArray(blocks) || blocks.length === 0) {
     return;
   }
   for (const block of blocks) {
-    fs12.mkdirSync(path18.join(paths.fixturesDir, block.key), { recursive: true });
-    fs12.mkdirSync(path18.join(paths.generatedDir, block.key), { recursive: true });
-    fs12.mkdirSync(path18.join(paths.rulesDir, block.key), { recursive: true });
+    fs11.mkdirSync(path18.join(paths.fixturesDir, block.key), { recursive: true });
+    fs11.mkdirSync(path18.join(paths.generatedDir, block.key), { recursive: true });
+    fs11.mkdirSync(path18.join(paths.rulesDir, block.key), { recursive: true });
   }
 }
 function discoverMigrationEntries(state) {
@@ -37810,7 +37840,7 @@ function discoverMigrationEntries(state) {
       const blockJsonPath = getSnapshotBlockJsonPath(state.projectDir, block, version2);
       const savePath = getSnapshotSavePath(state.projectDir, block, version2);
       const rulePath = getRuleFilePath(state.paths, block, version2, currentVersion);
-      if (!fs12.existsSync(manifestPath) || !fs12.existsSync(blockJsonPath) || !fs12.existsSync(savePath) || !fs12.existsSync(rulePath)) {
+      if (!fs11.existsSync(manifestPath) || !fs11.existsSync(blockJsonPath) || !fs11.existsSync(savePath) || !fs11.existsSync(rulePath)) {
         continue;
       }
       entries.push({
@@ -37838,16 +37868,16 @@ function discoverMigrationEntries(state) {
 }
 function assertRuleHasNoTodos(projectDir, block, fromMigrationVersion, toMigrationVersion) {
   const rulePath = getRuleFilePath(getProjectPaths(projectDir), block, fromMigrationVersion, toMigrationVersion);
-  if (!fs12.existsSync(rulePath)) {
+  if (!fs11.existsSync(rulePath)) {
     throw new Error(`Missing migration rule: ${path18.relative(projectDir, rulePath)}`);
   }
-  const source = fs12.readFileSync(rulePath, "utf8");
+  const source = fs11.readFileSync(rulePath, "utf8");
   if (source.includes(MIGRATION_TODO_PREFIX)) {
     throw new Error(`Migration rule still contains ${MIGRATION_TODO_PREFIX} markers: ${path18.relative(projectDir, rulePath)}`);
   }
 }
 function readRuleMetadata(rulePath) {
-  const source = fs12.readFileSync(rulePath, "utf8");
+  const source = fs11.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]*?)\};/);
@@ -37872,7 +37902,7 @@ var init_migration_project_layout = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-project-workspace.ts
-import fs13 from "fs";
+import fs12 from "fs";
 import path19 from "path";
 function createEmptyMigrationProjectBlockJson() {
   return {};
@@ -37901,8 +37931,8 @@ Generated fixtures are used by verify to assert migrations.
 `]
   ];
   for (const [targetPath, content] of readmeFiles) {
-    if (!fs13.existsSync(targetPath)) {
-      fs13.writeFileSync(targetPath, content, "utf8");
+    if (!fs12.existsSync(targetPath)) {
+      fs12.writeFileSync(targetPath, content, "utf8");
     }
   }
   if (!Array.isArray(blocks) || blocks.length === 0) {
@@ -37920,9 +37950,9 @@ Generated fixtures for ${block.blockName} are stored in this directory.
 `]
     ];
     for (const [targetPath, content] of scopedReadmes) {
-      if (!fs13.existsSync(targetPath)) {
-        fs13.mkdirSync(path19.dirname(targetPath), { recursive: true });
-        fs13.writeFileSync(targetPath, content, "utf8");
+      if (!fs12.existsSync(targetPath)) {
+        fs12.mkdirSync(path19.dirname(targetPath), { recursive: true });
+        fs12.writeFileSync(targetPath, content, "utf8");
       }
     }
   }
@@ -37930,19 +37960,19 @@ Generated fixtures for ${block.blockName} are stored in this directory.
 function findLegacySemverMigrationArtifacts(projectDir) {
   const paths = getProjectPaths(projectDir);
   const matches = [];
-  if (fs13.existsSync(paths.snapshotDir)) {
-    for (const entry of fs13.readdirSync(paths.snapshotDir, { withFileTypes: true })) {
+  if (fs12.existsSync(paths.snapshotDir)) {
+    for (const entry of fs12.readdirSync(paths.snapshotDir, { withFileTypes: true })) {
       if (entry.isDirectory() && isLegacySemverMigrationVersion(entry.name)) {
         matches.push(normalizeRelativePath(path19.join(SNAPSHOT_DIR, entry.name)));
       }
     }
   }
   const scanEdgeDir = (directory, relativeRoot) => {
-    if (!fs13.existsSync(directory)) {
+    if (!fs12.existsSync(directory)) {
       return;
     }
     const walk = (currentDir, currentRelativeDir) => {
-      for (const entry of fs13.readdirSync(currentDir, { withFileTypes: true })) {
+      for (const entry of fs12.readdirSync(currentDir, { withFileTypes: true })) {
         if (entry.isDirectory()) {
           walk(path19.join(currentDir, entry.name), path19.join(currentRelativeDir, entry.name));
           continue;
@@ -37960,8 +37990,8 @@ function findLegacySemverMigrationArtifacts(projectDir) {
 }
 function assertNoLegacySemverMigrationWorkspace(projectDir) {
   const paths = getProjectPaths(projectDir);
-  if (fs13.existsSync(paths.configFile)) {
-    const source = fs13.readFileSync(paths.configFile, "utf8");
+  if (fs12.existsSync(paths.configFile)) {
+    const source = fs12.readFileSync(paths.configFile, "utf8");
     if (hasLegacyConfigKeys(source)) {
       throw createLegacyMigrationWorkspaceResetError("Detected legacy config keys `currentVersion` / `supportedVersions` in `src/migrations/config.ts`.");
     }
@@ -37978,20 +38008,20 @@ function loadMigrationProject(projectDir, {
   assertNoLegacySemverMigrationWorkspace(projectDir);
   ensureAdvancedMigrationProject(projectDir);
   const paths = getProjectPaths(projectDir);
-  const config2 = allowMissingConfig && !fs13.existsSync(paths.configFile) ? {
+  const config2 = allowMissingConfig && !fs12.existsSync(paths.configFile) ? {
     blocks: [createImplicitLegacyBlock(projectDir)],
     currentMigrationVersion: "v1",
     snapshotDir: SNAPSHOT_DIR.replace(/\\/g, "/"),
     supportedMigrationVersions: []
-  } : parseMigrationConfig(fs13.readFileSync(paths.configFile, "utf8"));
+  } : parseMigrationConfig(fs12.readFileSync(paths.configFile, "utf8"));
   const configuredBlocks = config2.blocks === undefined ? [createImplicitLegacyBlock(projectDir, config2.blockName)] : config2.blocks;
-  const missingManifestFiles = configuredBlocks.filter((block) => !fs13.existsSync(path19.join(projectDir, block.manifestFile))).map((block) => block.manifestFile);
+  const missingManifestFiles = configuredBlocks.filter((block) => !fs12.existsSync(path19.join(projectDir, block.manifestFile))).map((block) => block.manifestFile);
   if (missingManifestFiles.length > 0) {
     if (!allowSyncTypes) {
       throw new Error("Migration planning is read-only and cannot run `sync-types` automatically. " + `Missing current manifest file(s): ${missingManifestFiles.join(", ")}. ` + "Run your project's `sync-types` script in the project root first, then rerun the planning command.");
     }
     runProjectScriptIfPresent(projectDir, "sync-types");
-    const remainingManifestFiles = configuredBlocks.filter((block) => !fs13.existsSync(path19.join(projectDir, block.manifestFile))).map((block) => block.manifestFile);
+    const remainingManifestFiles = configuredBlocks.filter((block) => !fs12.existsSync(path19.join(projectDir, block.manifestFile))).map((block) => block.manifestFile);
     if (remainingManifestFiles.length > 0) {
       throw new Error(`Missing current manifest file(s): ${remainingManifestFiles.join(", ")}. ` + "Run your project's `sync-types` script in the project root first, then retry.");
     }
@@ -38008,9 +38038,9 @@ function loadMigrationProject(projectDir, {
 }
 function writeMigrationConfig(projectDir, config2) {
   const paths = getProjectPaths(projectDir);
-  fs13.mkdirSync(path19.dirname(paths.configFile), { recursive: true });
+  fs12.mkdirSync(path19.dirname(paths.configFile), { recursive: true });
   if (!Array.isArray(config2.blocks)) {
-    fs13.writeFileSync(paths.configFile, `export const migrationConfig = {
+    fs12.writeFileSync(paths.configFile, `export const migrationConfig = {
 	blockName: '${config2.blockName ?? readProjectBlockName(projectDir)}',
 	currentMigrationVersion: '${config2.currentMigrationVersion}',
 	supportedMigrationVersions: [ ${config2.supportedMigrationVersions.map((version2) => `'${version2}'`).join(", ")} ],
@@ -38030,7 +38060,7 @@ export default migrationConfig;
 			typesFile: '${normalizeRelativePath(block.typesFile)}',
 		},`).join(`
 `);
-  fs13.writeFileSync(paths.configFile, `export const migrationConfig = {
+  fs12.writeFileSync(paths.configFile, `export const migrationConfig = {
 	currentMigrationVersion: '${config2.currentMigrationVersion}',
 	supportedMigrationVersions: [ ${config2.supportedMigrationVersions.map((version2) => `'${version2}'`).join(", ")} ],
 	snapshotDir: '${config2.snapshotDir}',
@@ -38844,7 +38874,7 @@ function buildTransformBodyLines(attribute, legacyPath) {
 var init_migration_diff_transform = () => {};
 
 // ../wp-typia-project-tools/src/runtime/migration-diff.ts
-import fs14 from "fs";
+import fs13 from "fs";
 function createMigrationDiff(state, blockOrFromVersion, fromVersionOrToVersion, maybeToVersion) {
   if (typeof blockOrFromVersion === "string" && state.blocks.length > 1) {
     throw new Error("A block key is required when diffing a multi-block migration project.");
@@ -38856,7 +38886,7 @@ function createMigrationDiff(state, blockOrFromVersion, fromVersionOrToVersion,
     throw new Error(typeof blockOrFromVersion === "string" ? "No migration block targets are configured for this project." : `Unknown migration block key: ${blockOrFromVersion.key}`);
   }
   const snapshotManifestPath = getSnapshotManifestPath(state.projectDir, block, fromVersion);
-  if (!fs14.existsSync(snapshotManifestPath)) {
+  if (!fs13.existsSync(snapshotManifestPath)) {
     throw new Error(createMissingBlockSnapshotMessage(block.blockName, fromVersion, getAvailableSnapshotVersionsForBlock(state.projectDir, state.config.supportedMigrationVersions, block)));
   }
   const targetManifest = toVersion === state.config.currentMigrationVersion ? block.currentManifest : readJson(getSnapshotManifestPath(state.projectDir, block, toVersion));
@@ -39078,16 +39108,16 @@ var init_migration_diff = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-fixtures.ts
-import fs15 from "fs";
+import fs14 from "fs";
 import path21 from "path";
 function ensureEdgeFixtureFile(projectDir, block, fromVersion, toVersion, diff, { force = false } = {}) {
   const fixturePath = getFixtureFilePath(getProjectPaths(projectDir), block, fromVersion, toVersion);
-  fs15.mkdirSync(path21.dirname(fixturePath), { recursive: true });
-  if (!force && fs15.existsSync(fixturePath)) {
+  fs14.mkdirSync(path21.dirname(fixturePath), { recursive: true });
+  if (!force && fs14.existsSync(fixturePath)) {
     return { fixturePath, written: false };
   }
   const fixtureDocument = createEdgeFixtureDocument(projectDir, block, fromVersion, toVersion, diff);
-  fs15.writeFileSync(fixturePath, `${JSON.stringify(fixtureDocument, null, "\t")}
+  fs14.writeFileSync(fixturePath, `${JSON.stringify(fixtureDocument, null, "\t")}
 `, "utf8");
   return { fixturePath, written: true };
 }
@@ -39415,7 +39445,7 @@ var init_migration_render_diff_rule = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-render-generated.ts
-import fs16 from "fs";
+import fs15 from "fs";
 import path24 from "path";
 function renderMigrationRegistryFile(state, blockKey, entries) {
   const block = state.blocks.find((entry) => entry.key === blockKey);
@@ -39427,7 +39457,7 @@ function renderMigrationRegistryFile(state, blockKey, entries) {
     block.manifestFile.replace(/typia\.manifest\.json$/u, "manifest-document.ts"),
     path24.join(path24.dirname(block.typesFile), "manifest-document.ts")
   ].filter((candidate, index, allCandidates) => candidate !== block.manifestFile && allCandidates.indexOf(candidate) === index);
-  const currentManifestWrapperFile = currentManifestWrapperCandidates.find((candidate) => fs16.existsSync(path24.join(state.projectDir, candidate))) ?? null;
+  const currentManifestWrapperFile = currentManifestWrapperCandidates.find((candidate) => fs15.existsSync(path24.join(state.projectDir, candidate))) ?? null;
   const currentManifestSourceFile = currentManifestWrapperFile ?? block.manifestFile;
   const currentManifestImport = normalizeImportPath(path24.relative(generatedDir, path24.join(state.projectDir, currentManifestSourceFile)), currentManifestWrapperFile !== null);
   const imports = [
@@ -39572,12 +39602,12 @@ function renderPhpMigrationRegistryFile(state, entries) {
       return [
         version2,
         {
-          blockJson: fs16.existsSync(blockJsonPath) ? {
+          blockJson: fs15.existsSync(blockJsonPath) ? {
             attributeNames: Object.keys(readJson(blockJsonPath).attributes ?? {}),
             name: readJson(blockJsonPath).name ?? null
           } : null,
-          hasSaveSnapshot: fs16.existsSync(savePath),
-          manifest: fs16.existsSync(manifestPath) ? summarizeManifest(readJson(manifestPath)) : null
+          hasSaveSnapshot: fs15.existsSync(savePath),
+          manifest: fs15.existsSync(manifestPath) ? summarizeManifest(readJson(manifestPath)) : null
         }
       ];
     }));
@@ -40067,7 +40097,7 @@ var init_migration_render = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-generated-artifacts.ts
-import fs17 from "fs";
+import fs16 from "fs";
 import path25 from "path";
 function collectGeneratedMigrationEntries(state) {
   return discoverMigrationEntries(state).map((entry) => {
@@ -40092,14 +40122,14 @@ function regenerateGeneratedArtifacts(projectDir) {
     const blockGeneratedEntries = generatedEntries.filter(({ entry }) => entry.block.key === block.key);
     const entries = blockGeneratedEntries.map(({ entry }) => entry);
     const generatedDir = getGeneratedDirForBlock(state.paths, block);
-    fs17.mkdirSync(generatedDir, { recursive: true });
-    fs17.writeFileSync(path25.join(generatedDir, "registry.ts"), renderMigrationRegistryFile(state, block.key, blockGeneratedEntries), "utf8");
-    fs17.writeFileSync(path25.join(generatedDir, "deprecated.ts"), renderGeneratedDeprecatedFile(state, block.key, entries), "utf8");
-    fs17.writeFileSync(path25.join(generatedDir, "verify.ts"), renderVerifyFile(state, block.key, entries), "utf8");
-    fs17.writeFileSync(path25.join(generatedDir, "fuzz.ts"), renderFuzzFile(state, block.key, blockGeneratedEntries), "utf8");
+    fs16.mkdirSync(generatedDir, { recursive: true });
+    fs16.writeFileSync(path25.join(generatedDir, "registry.ts"), renderMigrationRegistryFile(state, block.key, blockGeneratedEntries), "utf8");
+    fs16.writeFileSync(path25.join(generatedDir, "deprecated.ts"), renderGeneratedDeprecatedFile(state, block.key, entries), "utf8");
+    fs16.writeFileSync(path25.join(generatedDir, "verify.ts"), renderVerifyFile(state, block.key, entries), "utf8");
+    fs16.writeFileSync(path25.join(generatedDir, "fuzz.ts"), renderFuzzFile(state, block.key, blockGeneratedEntries), "utf8");
   }
-  fs17.writeFileSync(path25.join(state.paths.generatedDir, "index.ts"), renderGeneratedMigrationIndexFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
-  fs17.writeFileSync(path25.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
+  fs16.writeFileSync(path25.join(state.paths.generatedDir, "index.ts"), renderGeneratedMigrationIndexFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
+  fs16.writeFileSync(path25.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, generatedEntries.map(({ entry }) => entry)), "utf8");
 }
 var init_migration_generated_artifacts = __esm(() => {
   init_migration_constants();
@@ -40111,9 +40141,9 @@ var init_migration_generated_artifacts = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-planning.ts
-import fs18 from "fs";
+import fs17 from "fs";
 function hasSnapshotForVersion(state, block, version2) {
-  return fs18.existsSync(getSnapshotManifestPath(state.projectDir, block, version2));
+  return fs17.existsSync(getSnapshotManifestPath(state.projectDir, block, version2));
 }
 function listConfiguredLegacyVersions(state) {
   return state.config.supportedMigrationVersions.filter((version2) => version2 !== state.config.currentMigrationVersion).sort(compareMigrationVersionLabels);
@@ -41945,11 +41975,11 @@ var require_buffer_from = __commonJS((exports, module2) => {
 var require_source_map_support = __commonJS((exports, module2) => {
   var SourceMapConsumer = require_source_map().SourceMapConsumer;
   var path7 = __require("path");
-  var fs19;
+  var fs18;
   try {
-    fs19 = __require("fs");
-    if (!fs19.existsSync || !fs19.readFileSync) {
-      fs19 = null;
+    fs18 = __require("fs");
+    if (!fs18.existsSync || !fs18.readFileSync) {
+      fs18 = null;
     }
   } catch (err2) {}
   var bufferFrom = require_buffer_from();
@@ -42016,15 +42046,15 @@ var require_source_map_support = __commonJS((exports, module2) => {
     }
     var contents = "";
     try {
-      if (!fs19) {
+      if (!fs18) {
         var xhr = new XMLHttpRequest;
         xhr.open("GET", path26, false);
         xhr.send(null);
         if (xhr.readyState === 4 && xhr.status === 200) {
           contents = xhr.responseText;
         }
-      } else if (fs19.existsSync(path26)) {
-        contents = fs19.readFileSync(path26, "utf8");
+      } else if (fs18.existsSync(path26)) {
+        contents = fs18.readFileSync(path26, "utf8");
       }
     } catch (er) {}
     return fileContentsCache[path26] = contents;
@@ -42288,9 +42318,9 @@ var require_source_map_support = __commonJS((exports, module2) => {
       var line = +match3[2];
       var column = +match3[3];
       var contents = fileContentsCache[source];
-      if (!contents && fs19 && fs19.existsSync(source)) {
+      if (!contents && fs18 && fs18.existsSync(source)) {
         try {
-          contents = fs19.readFileSync(source, "utf8");
+          contents = fs18.readFileSync(source, "utf8");
         } catch (er) {
           contents = "";
         }
@@ -46086,10 +46116,10 @@ var require_typescript = __commonJS((exports, module2) => {
     function and(f, g2) {
       return (arg) => f(arg) && g2(arg);
     }
-    function or(...fs19) {
+    function or(...fs18) {
       return (...args) => {
         let lastResult;
-        for (const f of fs19) {
+        for (const f of fs18) {
           lastResult = f(...args);
           if (lastResult) {
             return lastResult;
@@ -47543,7 +47573,7 @@ ${lanes.join(`
     var tracing;
     var tracingEnabled;
     ((tracingEnabled2) => {
-      let fs19;
+      let fs18;
       let traceCount = 0;
       let traceFd = 0;
       let mode;
@@ -47552,9 +47582,9 @@ ${lanes.join(`
       const legend = [];
       function startTracing2(tracingMode, traceDir, configFilePath) {
         Debug.assert(!tracing, "Tracing already started");
-        if (fs19 === undefined) {
+        if (fs18 === undefined) {
           try {
-            fs19 = __require("fs");
+            fs18 = __require("fs");
           } catch (e) {
             throw new Error(`tracing requires having fs
 (original error: ${e.message || e})`);
@@ -47565,8 +47595,8 @@ ${lanes.join(`
         if (legendPath === undefined) {
           legendPath = combinePaths(traceDir, "legend.json");
         }
-        if (!fs19.existsSync(traceDir)) {
-          fs19.mkdirSync(traceDir, { recursive: true });
+        if (!fs18.existsSync(traceDir)) {
+          fs18.mkdirSync(traceDir, { recursive: true });
         }
         const countPart = mode === "build" ? `.${process.pid}-${++traceCount}` : mode === "server" ? `.${process.pid}` : ``;
         const tracePath = combinePaths(traceDir, `trace${countPart}.json`);
@@ -47576,10 +47606,10 @@ ${lanes.join(`
           tracePath,
           typesPath
         });
-        traceFd = fs19.openSync(tracePath, "w");
+        traceFd = fs18.openSync(tracePath, "w");
         tracing = tracingEnabled2;
         const meta4 = { cat: "__metadata", ph: "M", ts: 1000 * timestamp(), pid: 1, tid: 1 };
-        fs19.writeSync(traceFd, `[
+        fs18.writeSync(traceFd, `[
 ` + [{ name: "process_name", args: { name: "tsc" }, ...meta4 }, { name: "thread_name", args: { name: "Main" }, ...meta4 }, { name: "TracingStartedInBrowser", ...meta4, cat: "disabled-by-default-devtools.timeline" }].map((v2) => JSON.stringify(v2)).join(`,
 `));
       }
@@ -47587,10 +47617,10 @@ ${lanes.join(`
       function stopTracing() {
         Debug.assert(tracing, "Tracing is not in progress");
         Debug.assert(!!typeCatalog.length === (mode !== "server"));
-        fs19.writeSync(traceFd, `
+        fs18.writeSync(traceFd, `
 ]
 `);
-        fs19.closeSync(traceFd);
+        fs18.closeSync(traceFd);
         tracing = undefined;
         if (typeCatalog.length) {
           dumpTypes(typeCatalog);
@@ -47655,13 +47685,13 @@ ${lanes.join(`
         if (mode === "server" && phase === "checkTypes")
           return;
         mark("beginTracing");
-        fs19.writeSync(traceFd, `,
+        fs18.writeSync(traceFd, `,
 {"pid":1,"tid":1,"ph":"${eventType}","cat":"${phase}","ts":${time3},"name":"${name2}"`);
         if (extras)
-          fs19.writeSync(traceFd, `,${extras}`);
+          fs18.writeSync(traceFd, `,${extras}`);
         if (args)
-          fs19.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
-        fs19.writeSync(traceFd, `}`);
+          fs18.writeSync(traceFd, `,"args":${JSON.stringify(args)}`);
+        fs18.writeSync(traceFd, `}`);
         mark("endTracing");
         measure("Tracing", "beginTracing", "endTracing");
       }
@@ -47683,9 +47713,9 @@ ${lanes.join(`
         var _a2, _b, _c, _d, _e2, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r2, _s;
         mark("beginDumpTypes");
         const typesPath = legend[legend.length - 1].typesPath;
-        const typesFd = fs19.openSync(typesPath, "w");
+        const typesFd = fs18.openSync(typesPath, "w");
         const recursionIdentityMap = /* @__PURE__ */ new Map;
-        fs19.writeSync(typesFd, "[");
+        fs18.writeSync(typesFd, "[");
         const numTypes = types.length;
         for (let i = 0;i < numTypes; i++) {
           const type = types[i];
@@ -47781,15 +47811,15 @@ ${lanes.join(`
             flags: Debug.formatTypeFlags(type.flags).split("|"),
             display
           };
-          fs19.writeSync(typesFd, JSON.stringify(descriptor));
+          fs18.writeSync(typesFd, JSON.stringify(descriptor));
           if (i < numTypes - 1) {
-            fs19.writeSync(typesFd, `,
+            fs18.writeSync(typesFd, `,
 `);
           }
         }
-        fs19.writeSync(typesFd, `]
+        fs18.writeSync(typesFd, `]
 `);
-        fs19.closeSync(typesFd);
+        fs18.closeSync(typesFd);
         mark("endDumpTypes");
         measure("Dump types", "beginDumpTypes", "endDumpTypes");
       }
@@ -47797,7 +47827,7 @@ ${lanes.join(`
         if (!legendPath) {
           return;
         }
-        fs19.writeFileSync(legendPath, JSON.stringify(legend));
+        fs18.writeFileSync(legendPath, JSON.stringify(legend));
       }
       tracingEnabled2.dumpLegend = dumpLegend;
     })(tracingEnabled || (tracingEnabled = {}));
@@ -211264,90 +211294,97 @@ function matchesPhpFunctionCallAt(source, index, functionName) {
   const callStart = skipPhpCallTrivia(source, cursor);
   return callStart !== null && source[callStart] === "(";
 }
-function hasPhpFunctionCall(source, functionName) {
-  let mode = "code";
-  let heredocDelimiter = "";
-  let index = 0;
-  while (index < source.length) {
-    const character = source[index];
-    if (mode === "heredoc") {
-      const closingEnd = findPhpHeredocClosingEnd(source, index, heredocDelimiter);
-      if (closingEnd !== null) {
-        mode = "code";
-        heredocDelimiter = "";
-        index = closingEnd;
-        continue;
-      }
-      const nextLineStart = findPhpLineBoundary(source, index).nextStart;
-      if (nextLineStart <= index) {
-        return false;
-      }
-      index = nextLineStart;
-      continue;
+function createPhpScannerState() {
+  return {
+    heredocDelimiter: "",
+    mode: "code"
+  };
+}
+function advancePhpScanner(source, index, state) {
+  const character = source[index];
+  if (state.mode === "heredoc") {
+    const closingEnd = findPhpHeredocClosingEnd(source, index, state.heredocDelimiter);
+    if (closingEnd !== null) {
+      state.mode = "code";
+      state.heredocDelimiter = "";
+      return { ambiguous: false, inCode: false, index: closingEnd };
     }
-    if (mode === "single-quoted" || mode === "double-quoted") {
-      const quote = mode === "single-quoted" ? "'" : '"';
-      if (character === "\\") {
-        index += 2;
-        continue;
-      }
-      if (character === quote) {
-        mode = "code";
-      }
-      index += 1;
-      continue;
+    const nextLineStart = findPhpLineBoundary(source, index).nextStart;
+    if (nextLineStart <= index) {
+      return { ambiguous: true, inCode: false, index };
     }
-    if (mode === "line-comment") {
-      if (character === "\r" || character === `
-`) {
-        mode = "code";
-      }
-      index += 1;
-      continue;
+    return { ambiguous: false, inCode: false, index: nextLineStart };
+  }
+  if (state.mode === "single-quoted" || state.mode === "double-quoted") {
+    const quote = state.mode === "single-quoted" ? "'" : '"';
+    if (character === "\\") {
+      return { ambiguous: false, inCode: false, index: index + 2 };
     }
-    if (mode === "block-comment") {
-      if (character === "*" && source[index + 1] === "/") {
-        mode = "code";
-        index += 2;
-        continue;
-      }
-      index += 1;
-      continue;
+    if (character === quote) {
+      state.mode = "code";
     }
-    if (character === "'") {
-      mode = "single-quoted";
-      index += 1;
-      continue;
+    return { ambiguous: false, inCode: false, index: index + 1 };
+  }
+  if (state.mode === "line-comment") {
+    if (character === "\r" || character === `
+`) {
+      state.mode = "code";
     }
-    if (character === '"') {
-      mode = "double-quoted";
-      index += 1;
-      continue;
+    return { ambiguous: false, inCode: false, index: index + 1 };
+  }
+  if (state.mode === "block-comment") {
+    if (character === "*" && source[index + 1] === "/") {
+      state.mode = "code";
+      return { ambiguous: false, inCode: false, index: index + 2 };
     }
-    if (character === "/" && source[index + 1] === "/") {
-      mode = "line-comment";
-      index += 2;
-      continue;
+    return { ambiguous: false, inCode: false, index: index + 1 };
+  }
+  if (character === "'") {
+    state.mode = "single-quoted";
+    return { ambiguous: false, inCode: false, index: index + 1 };
+  }
+  if (character === '"') {
+    state.mode = "double-quoted";
+    return { ambiguous: false, inCode: false, index: index + 1 };
+  }
+  if (character === "/" && source[index + 1] === "/") {
+    state.mode = "line-comment";
+    return { ambiguous: false, inCode: false, index: index + 2 };
+  }
+  if (character === "#" && source[index + 1] !== "[") {
+    state.mode = "line-comment";
+    return { ambiguous: false, inCode: false, index: index + 1 };
+  }
+  if (character === "/" && source[index + 1] === "*") {
+    state.mode = "block-comment";
+    return { ambiguous: false, inCode: false, index: index + 2 };
+  }
+  if (character === "<") {
+    const heredocStart = parsePhpHeredocStart(source, index);
+    if (heredocStart) {
+      state.mode = "heredoc";
+      state.heredocDelimiter = heredocStart.delimiter;
+      return {
+        ambiguous: false,
+        inCode: false,
+        index: heredocStart.contentStart
+      };
     }
-    if (character === "#" && source[index + 1] !== "[") {
-      mode = "line-comment";
-      index += 1;
-      continue;
+  }
+  return { ambiguous: false, inCode: true, index };
+}
+function hasPhpFunctionCall(source, functionName) {
+  const scanner = createPhpScannerState();
+  let index = 0;
+  while (index < source.length) {
+    const scan = advancePhpScanner(source, index, scanner);
+    if (scan.ambiguous) {
+      return false;
     }
-    if (character === "/" && source[index + 1] === "*") {
-      mode = "block-comment";
-      index += 2;
+    if (!scan.inCode) {
+      index = scan.index;
       continue;
     }
-    if (character === "<") {
-      const heredocStart = parsePhpHeredocStart(source, index);
-      if (heredocStart) {
-        mode = "heredoc";
-        heredocDelimiter = heredocStart.delimiter;
-        index = heredocStart.contentStart;
-        continue;
-      }
-    }
     if (matchesPhpFunctionCallAt(source, index, functionName)) {
       return true;
     }
@@ -211368,89 +211405,18 @@ function findPhpFunctionRange(source, functionName, options = {}) {
   }
   const openBraceIndex = functionStart + openBraceOffset;
   let depth = 0;
-  let mode = "code";
-  let heredocDelimiter = "";
+  const scanner = createPhpScannerState();
   let index = openBraceIndex;
   while (index < source.length) {
-    const character = source[index];
-    if (mode === "heredoc") {
-      const closingEnd = findPhpHeredocClosingEnd(source, index, heredocDelimiter);
-      if (closingEnd !== null) {
-        mode = "code";
-        heredocDelimiter = "";
-        index = closingEnd;
-        continue;
-      }
-      const nextLineStart = findPhpLineBoundary(source, index).nextStart;
-      if (nextLineStart <= index) {
-        return null;
-      }
-      index = nextLineStart;
-      continue;
-    }
-    if (mode === "single-quoted" || mode === "double-quoted") {
-      const quote = mode === "single-quoted" ? "'" : '"';
-      if (character === "\\") {
-        index += 2;
-        continue;
-      }
-      if (character === quote) {
-        mode = "code";
-      }
-      index += 1;
-      continue;
-    }
-    if (mode === "line-comment") {
-      if (character === "\r" || character === `
-`) {
-        mode = "code";
-      }
-      index += 1;
-      continue;
-    }
-    if (mode === "block-comment") {
-      if (character === "*" && source[index + 1] === "/") {
-        mode = "code";
-        index += 2;
-        continue;
-      }
-      index += 1;
-      continue;
-    }
-    if (character === "'") {
-      mode = "single-quoted";
-      index += 1;
-      continue;
-    }
-    if (character === '"') {
-      mode = "double-quoted";
-      index += 1;
-      continue;
-    }
-    if (character === "/" && source[index + 1] === "/") {
-      mode = "line-comment";
-      index += 2;
-      continue;
+    const scan = advancePhpScanner(source, index, scanner);
+    if (scan.ambiguous) {
+      return null;
     }
-    if (character === "#" && source[index + 1] !== "[") {
-      mode = "line-comment";
-      index += 1;
+    if (!scan.inCode) {
+      index = scan.index;
       continue;
     }
-    if (character === "/" && source[index + 1] === "*") {
-      mode = "block-comment";
-      index += 2;
-      continue;
-    }
-    if (character === "<") {
-      const heredocStart = parsePhpHeredocStart(source, index);
-      if (heredocStart) {
-        mode = "heredoc";
-        heredocDelimiter = heredocStart.delimiter;
-        index = heredocStart.contentStart;
-        continue;
-      }
-    }
+    const character = source[index];
     if (character === "{") {
       depth += 1;
       index += 1;
@@ -211491,7 +211457,7 @@ function replacePhpFunctionDefinition(source, functionName, replacement, options
 }
 
 // ../wp-typia-project-tools/src/runtime/workspace-inventory.ts
-import fs19 from "fs";
+import fs18 from "fs";
 import path26 from "path";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 function defineInventoryEntryParser(descriptor) {
@@ -211670,7 +211636,7 @@ function readWorkspaceInventory(projectDir) {
   const blockConfigPath = path26.join(projectDir, "scripts", "block-config.ts");
   let source;
   try {
-    source = fs19.readFileSync(blockConfigPath, "utf8");
+    source = fs18.readFileSync(blockConfigPath, "utf8");
   } catch (error48) {
     if (typeof error48 === "object" && error48 !== null && "code" in error48 && error48.code === "ENOENT") {
       throw new Error(`Workspace inventory file is missing at ${blockConfigPath}. Expected scripts/block-config.ts to exist.`);
@@ -212289,7 +212255,7 @@ ${WORKSPACE_COMPATIBILITY_CONFIG_FIELD}	dataFile: string;
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-maintenance-verify.ts
-import fs20 from "fs";
+import fs19 from "fs";
 import path27 from "path";
 import { execFileSync } from "child_process";
 function verifyProjectMigrations(projectDir, {
@@ -212315,7 +212281,7 @@ function verifyProjectMigrations(projectDir, {
       assertRuleHasNoTodos(projectDir, block, entry.fromVersion, state.config.currentMigrationVersion);
     }
     const verifyScriptPath = path27.join(getGeneratedDirForBlock(state.paths, block), "verify.ts");
-    if (!fs20.existsSync(verifyScriptPath)) {
+    if (!fs19.existsSync(verifyScriptPath)) {
       const selectedVersionsForBlock2 = entries.map((entry) => entry.fromVersion);
       throw new Error(`Generated verify script is missing for ${block.blockName} (${selectedVersionsForBlock2.join(", ")}). ` + `Run \`${formatScaffoldCommand(selectedVersionsForBlock2)}\` first, then \`wp-typia migrate doctor --all\` if the workspace should already be scaffolded.`);
     }
@@ -212391,14 +212357,14 @@ function doctorProjectMigrations(projectDir, {
       const blockJsonPath = getSnapshotBlockJsonPath(projectDir, block, version2);
       const manifestPath = getSnapshotManifestPath(projectDir, block, version2);
       const savePath = getSnapshotSavePath(projectDir, block, version2);
-      const hasSnapshot = fs20.existsSync(snapshotRoot);
+      const hasSnapshot = fs19.existsSync(snapshotRoot);
       const snapshotIsOptional = !hasSnapshot && isSnapshotOptionalForBlockVersion(state, block, version2);
       recordCheck(hasSnapshot || snapshotIsOptional ? "pass" : "fail", legacySingleBlock ? `Snapshot ${version2}` : `Snapshot ${block.blockName} @ ${version2}`, hasSnapshot ? path27.relative(projectDir, snapshotRoot) : "Not present for this version");
       if (!hasSnapshot) {
         continue;
       }
       for (const targetPath of [blockJsonPath, manifestPath, savePath]) {
-        recordCheck(fs20.existsSync(targetPath) ? "pass" : "fail", legacySingleBlock ? `Snapshot file ${version2}` : `Snapshot file ${block.blockName} @ ${version2}`, fs20.existsSync(targetPath) ? path27.relative(projectDir, targetPath) : `Missing ${path27.relative(projectDir, targetPath)}`);
+        recordCheck(fs19.existsSync(targetPath) ? "pass" : "fail", legacySingleBlock ? `Snapshot file ${version2}` : `Snapshot file ${block.blockName} @ ${version2}`, fs19.existsSync(targetPath) ? path27.relative(projectDir, targetPath) : `Missing ${path27.relative(projectDir, targetPath)}`);
       }
     }
   }
@@ -212417,7 +212383,7 @@ function doctorProjectMigrations(projectDir, {
     expectedGeneratedFiles.set(path27.join(state.paths.generatedDir, "index.ts"), renderGeneratedMigrationIndexFile(state, generatedEntries.map(({ entry }) => entry)));
     expectedGeneratedFiles.set(path27.join(projectDir, ROOT_PHP_MIGRATION_REGISTRY), renderPhpMigrationRegistryFile(state, generatedEntries.map(({ entry }) => entry)));
     for (const [filePath, expectedSource] of expectedGeneratedFiles) {
-      const inSync = fs20.existsSync(filePath) && fs20.readFileSync(filePath, "utf8") === expectedSource;
+      const inSync = fs19.existsSync(filePath) && fs19.readFileSync(filePath, "utf8") === expectedSource;
       recordCheck(inSync ? "pass" : "fail", `Generated ${path27.relative(projectDir, filePath)}`, inSync ? "In sync" : "Run `wp-typia migrate scaffold --from-migration-version <label>` or regenerate artifacts");
     }
   } catch (error48) {
@@ -212431,9 +212397,9 @@ function doctorProjectMigrations(projectDir, {
       }
       const rulePath = getRuleFilePath(state.paths, block, version2, state.config.currentMigrationVersion);
       const fixturePath = getFixtureFilePath(state.paths, block, version2, state.config.currentMigrationVersion);
-      recordCheck(fs20.existsSync(rulePath) ? "pass" : "fail", legacySingleBlock ? `Rule ${version2}` : `Rule ${block.blockName} @ ${version2}`, fs20.existsSync(rulePath) ? path27.relative(projectDir, rulePath) : `Missing ${path27.relative(projectDir, rulePath)}`);
-      recordCheck(fs20.existsSync(fixturePath) ? "pass" : "fail", legacySingleBlock ? `Fixture ${version2}` : `Fixture ${block.blockName} @ ${version2}`, fs20.existsSync(fixturePath) ? path27.relative(projectDir, fixturePath) : `Missing ${path27.relative(projectDir, fixturePath)}`);
-      if (!fs20.existsSync(rulePath) || !fs20.existsSync(fixturePath)) {
+      recordCheck(fs19.existsSync(rulePath) ? "pass" : "fail", legacySingleBlock ? `Rule ${version2}` : `Rule ${block.blockName} @ ${version2}`, fs19.existsSync(rulePath) ? path27.relative(projectDir, rulePath) : `Missing ${path27.relative(projectDir, rulePath)}`);
+      recordCheck(fs19.existsSync(fixturePath) ? "pass" : "fail", legacySingleBlock ? `Fixture ${version2}` : `Fixture ${block.blockName} @ ${version2}`, fs19.existsSync(fixturePath) ? path27.relative(projectDir, fixturePath) : `Missing ${path27.relative(projectDir, fixturePath)}`);
+      if (!fs19.existsSync(rulePath) || !fs19.existsSync(fixturePath)) {
         continue;
       }
       try {
@@ -212486,7 +212452,7 @@ var init_migration_maintenance_verify = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-maintenance-fixtures.ts
-import fs21 from "fs";
+import fs20 from "fs";
 import path28 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 function fixturesProjectMigrations(projectDir, {
@@ -212509,7 +212475,7 @@ function fixturesProjectMigrations(projectDir, {
   const skippedVersions = [];
   const fixtureTargets = collectFixtureTargets(state, targetVersions, targetMigrationVersion);
   if (force) {
-    const overwriteTargets = fixtureTargets.filter(({ fixturePath }) => fs21.existsSync(fixturePath));
+    const overwriteTargets = fixtureTargets.filter(({ fixturePath }) => fs20.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) {
@@ -212522,7 +212488,7 @@ function fixturesProjectMigrations(projectDir, {
     }
   }
   for (const { block, fixturePath, scopedLabel, version: version2 } of fixtureTargets) {
-    const existed = fs21.existsSync(fixturePath);
+    const existed = fs20.existsSync(fixturePath);
     const diff = createMigrationDiff(state, block, version2, targetMigrationVersion);
     const result = ensureEdgeFixtureFile(projectDir, block, version2, targetMigrationVersion, diff, { force });
     if (result.written) {
@@ -212563,7 +212529,7 @@ function fuzzProjectMigrations(projectDir, {
       assertRuleHasNoTodos(projectDir, block, entry.fromVersion, state.config.currentMigrationVersion);
     }
     const fuzzScriptPath = path28.join(getGeneratedDirForBlock(state.paths, block), "fuzz.ts");
-    if (!fs21.existsSync(fuzzScriptPath)) {
+    if (!fs20.existsSync(fuzzScriptPath)) {
       const selectedVersionsForBlock2 = entries.map((entry) => entry.fromVersion);
       throw new Error(`Generated fuzz script is missing for ${block.blockName} (${selectedVersionsForBlock2.join(", ")}). ` + `Run \`${formatScaffoldCommand(selectedVersionsForBlock2)}\` first, then \`wp-typia migrate doctor --all\` if the workspace should already be scaffolded.`);
     }
@@ -212589,7 +212555,7 @@ function promptForConfirmation(message) {
   const buffer = Buffer.alloc(1);
   let answer = "";
   while (true) {
-    const bytesRead = fs21.readSync(process.stdin.fd, buffer, 0, 1, null);
+    const bytesRead = fs20.readSync(process.stdin.fd, buffer, 0, 1, null);
     if (bytesRead === 0) {
       break;
     }
@@ -212636,7 +212602,7 @@ __export(exports_migrations, {
   doctorProjectMigrations: () => doctorProjectMigrations,
   diffProjectMigrations: () => diffProjectMigrations
 });
-import fs22 from "fs";
+import fs21 from "fs";
 import path29 from "path";
 function runMigrationCommand(command, cwd, { prompt, renderLine = console.log } = {}) {
   switch (command.command) {
@@ -212854,11 +212820,11 @@ function snapshotProjectVersion(projectDir, migrationVersion, {
   const state = loadMigrationProject(projectDir, { allowMissingConfig: skipConfigUpdate });
   for (const block of state.blocks) {
     const snapshotRoot = getSnapshotRoot(projectDir, block, migrationVersion);
-    fs22.mkdirSync(snapshotRoot, { recursive: true });
-    fs22.writeFileSync(getSnapshotBlockJsonPath(projectDir, block, migrationVersion), `${JSON.stringify(sanitizeSnapshotBlockJson(readJson(path29.join(projectDir, block.blockJsonFile))), null, "\t")}
+    fs21.mkdirSync(snapshotRoot, { recursive: true });
+    fs21.writeFileSync(getSnapshotBlockJsonPath(projectDir, block, migrationVersion), `${JSON.stringify(sanitizeSnapshotBlockJson(readJson(path29.join(projectDir, block.blockJsonFile))), null, "\t")}
 `, "utf8");
     copyFile(path29.join(projectDir, block.manifestFile), getSnapshotManifestPath(projectDir, block, migrationVersion));
-    fs22.writeFileSync(getSnapshotSavePath(projectDir, block, migrationVersion), sanitizeSaveSnapshotSource(fs22.readFileSync(path29.join(projectDir, block.saveFile), "utf8")), "utf8");
+    fs21.writeFileSync(getSnapshotSavePath(projectDir, block, migrationVersion), sanitizeSaveSnapshotSource(fs21.readFileSync(path29.join(projectDir, block.saveFile), "utf8")), "utf8");
   }
   if (!skipConfigUpdate) {
     const nextSupported = [
@@ -212921,9 +212887,9 @@ function scaffoldProjectMigrations(projectDir, {
     eligibleBlocks += 1;
     const diff = createMigrationDiff(state, block, fromMigrationVersion, targetMigrationVersion);
     const rulePath = getRuleFilePath(paths, block, fromMigrationVersion, targetMigrationVersion);
-    if (!fs22.existsSync(rulePath)) {
-      fs22.mkdirSync(path29.dirname(rulePath), { recursive: true });
-      fs22.writeFileSync(rulePath, renderMigrationRuleFile({
+    if (!fs21.existsSync(rulePath)) {
+      fs21.mkdirSync(path29.dirname(rulePath), { recursive: true });
+      fs21.writeFileSync(rulePath, renderMigrationRuleFile({
         block,
         currentAttributes: block.currentManifest.attributes ?? {},
         currentTypeName: block.currentManifest.sourceType,
@@ -213025,16 +212991,16 @@ var init_template_defaults = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/template-registry.ts
-import fs23 from "fs";
+import fs22 from "fs";
 import path30 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveValidProjectToolsPackageRoot(candidateRoot) {
   const packageJsonPath = path30.join(candidateRoot, "package.json");
-  if (!fs23.existsSync(packageJsonPath)) {
+  if (!fs22.existsSync(packageJsonPath)) {
     return;
   }
   try {
-    const packageJson = JSON.parse(fs23.readFileSync(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(fs22.readFileSync(packageJsonPath, "utf8"));
     return packageJson.name === PROJECT_TOOLS_PACKAGE_NAME ? candidateRoot : undefined;
   } catch {
     return;
@@ -213052,9 +213018,9 @@ function resolvePackageRoot(startDir) {
   let currentDir = startDir;
   while (true) {
     const packageJsonPath = path30.join(currentDir, "package.json");
-    if (fs23.existsSync(packageJsonPath)) {
+    if (fs22.existsSync(packageJsonPath)) {
       try {
-        const packageJson = JSON.parse(fs23.readFileSync(packageJsonPath, "utf8"));
+        const packageJson = JSON.parse(fs22.readFileSync(packageJsonPath, "utf8"));
         if (packageJson.name === PROJECT_TOOLS_PACKAGE_NAME) {
           return currentDir;
         }
@@ -213636,7 +213602,7 @@ var init_mustache = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/template-render.ts
-import { promises as fsp4 } from "fs";
+import { promises as fsp5 } from "fs";
 import path31 from "path";
 function renderMustacheTemplateString(template, view) {
   const mustacheModule = mustache_default;
@@ -213683,7 +213649,7 @@ async function traverseTemplateDirectory({
   view,
   visitFile
 }) {
-  const entries = await fsp4.readdir(sourceDir, { withFileTypes: true });
+  const entries = await fsp5.readdir(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
     const sourcePath = path31.join(sourceDir, entry.name);
     const destinationName = renderTemplateDestinationName(entry.name, view, renderString);
@@ -213717,30 +213683,30 @@ async function copyTemplateDirectory({
   targetDir,
   view
 }) {
-  await fsp4.mkdir(targetDir, { recursive: true });
+  await fsp5.mkdir(targetDir, { recursive: true });
   await traverseTemplateDirectory({
     filter,
     prepareDirectory: async (directoryPath) => {
-      await fsp4.mkdir(directoryPath, { recursive: true });
+      await fsp5.mkdir(directoryPath, { recursive: true });
     },
     renderString,
     sourceDir,
     targetDir,
     view,
     visitFile: async ({ destinationPath, sourcePath }) => {
-      await fsp4.mkdir(path31.dirname(destinationPath), { recursive: true });
+      await fsp5.mkdir(path31.dirname(destinationPath), { recursive: true });
       if (isBinaryTemplateFile(sourcePath)) {
-        await fsp4.copyFile(sourcePath, destinationPath);
+        await fsp5.copyFile(sourcePath, destinationPath);
         return;
       }
-      const content = await fsp4.readFile(sourcePath, "utf8");
-      await fsp4.writeFile(destinationPath, renderString(content, view), "utf8");
+      const content = await fsp5.readFile(sourcePath, "utf8");
+      await fsp5.writeFile(destinationPath, renderString(content, view), "utf8");
     }
   });
 }
 async function copyRawDirectory(sourceDir, targetDir, options = {}) {
-  await fsp4.mkdir(targetDir, { recursive: true });
-  for (const entry of await fsp4.readdir(sourceDir, { withFileTypes: true })) {
+  await fsp5.mkdir(targetDir, { recursive: true });
+  for (const entry of await fsp5.readdir(sourceDir, { withFileTypes: true })) {
     const sourcePath = path31.join(sourceDir, entry.name);
     const targetPath = path31.join(targetDir, entry.name);
     if (options.filter && !await options.filter(sourcePath, targetPath, entry)) {
@@ -213750,8 +213716,8 @@ async function copyRawDirectory(sourceDir, targetDir, options = {}) {
       await copyRawDirectory(sourcePath, targetPath, options);
       continue;
     }
-    await fsp4.mkdir(path31.dirname(targetPath), { recursive: true });
-    await fsp4.copyFile(sourcePath, targetPath);
+    await fsp5.mkdir(path31.dirname(targetPath), { recursive: true });
+    await fsp5.copyFile(sourcePath, targetPath);
   }
 }
 async function copyRenderedDirectory(sourceDir, targetDir, view, options = {}) {
@@ -213807,8 +213773,8 @@ var init_template_render = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/local-dev-presets.ts
-import fs24 from "fs";
-import { promises as fsp5 } from "fs";
+import fs23 from "fs";
+import { promises as fsp6 } from "fs";
 import path32 from "path";
 function templateHasPersistenceSync(templateId, compoundPersistenceEnabled) {
   return templateId === "persistence" || templateId === "compound" && compoundPersistenceEnabled;
@@ -213849,9 +213815,9 @@ function getDevScript(packageManager, compoundPersistenceEnabled, templateId) {
 }
 async function mutatePackageJson(projectDir, mutate) {
   const packageJsonPath = path32.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp5.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fsp6.readFile(packageJsonPath, "utf8"));
   mutate(packageJson);
-  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp6.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function appendGitignoreLines(projectDir, lines) {
@@ -213859,7 +213825,7 @@ async function appendGitignoreLines(projectDir, lines) {
     return;
   }
   const gitignorePath = path32.join(projectDir, ".gitignore");
-  const current = fs24.existsSync(gitignorePath) ? await fsp5.readFile(gitignorePath, "utf8") : "";
+  const current = fs23.existsSync(gitignorePath) ? await fsp6.readFile(gitignorePath, "utf8") : "";
   const missingLines = lines.filter((line) => !current.includes(`${line}
 `) && !current.endsWith(line));
   if (missingLines.length === 0) {
@@ -213868,7 +213834,7 @@ async function appendGitignoreLines(projectDir, lines) {
   const suffix = current.endsWith(`
 `) ? "" : `
 `;
-  await fsp5.writeFile(gitignorePath, `${current}${suffix}${missingLines.join(`
+  await fsp6.writeFile(gitignorePath, `${current}${suffix}${missingLines.join(`
 `)}
 `, "utf8");
 }
@@ -213948,7 +213914,7 @@ var init_local_dev_presets = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/package-versions.ts
-import fs25 from "fs";
+import fs24 from "fs";
 import { createRequire } from "module";
 import path33 from "path";
 function getErrorCode(error48) {
@@ -213988,8 +213954,8 @@ function createContentFingerprint(source) {
 }
 function resolvePackageManifestLocation(packageJsonPath) {
   try {
-    const stats = fs25.statSync(packageJsonPath);
-    const source = fs25.readFileSync(packageJsonPath, "utf8");
+    const stats = fs24.statSync(packageJsonPath);
+    const source = fs24.readFileSync(packageJsonPath, "utf8");
     return {
       cacheKey: `file:${packageJsonPath}:${stats.ino}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.size}:${createContentFingerprint(source)}`,
       packageJsonPath,
@@ -214104,29 +214070,29 @@ function getPackageVersions() {
   };
   return versions2;
 }
-var require2, DEFAULT_VERSION_RANGE = "^0.0.0", DEFAULT_EXACT_VERSION = "0.0.0", DEFAULT_TSX_PACKAGE_VERSION = "^4.20.5", DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = "^12.0.1", DEFAULT_WORDPRESS_ABILITIES_VERSION = "^0.10.0", DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = "^0.9.0", DEFAULT_WORDPRESS_CORE_DATA_VERSION = "^7.44.0", DEFAULT_WORDPRESS_DATA_VERSION = "^9.28.0", DEFAULT_WORDPRESS_DATAVIEWS_VERSION = "^14.1.0", DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = "^0.1.0", cachedPackageVersions = null;
+var require2, DEFAULT_VERSION_RANGE = "^0.0.0", DEFAULT_EXACT_VERSION = "0.0.0", DEFAULT_TSX_PACKAGE_VERSION = "^4.20.5", DEFAULT_TYPIA_UNPLUGIN_PACKAGE_VERSION = "^12.0.1", DEFAULT_WORDPRESS_ABILITIES_VERSION = "^0.10.0", DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION = "^0.9.0", DEFAULT_WORDPRESS_CORE_DATA_VERSION = "^7.44.0", DEFAULT_WORDPRESS_DATA_VERSION = "^9.28.0", DEFAULT_WORDPRESS_DATAVIEWS_VERSION = "^14.1.0", DEFAULT_WP_TYPIA_DATAVIEWS_VERSION = "^0.1.1", cachedPackageVersions = null;
 var init_package_versions = __esm(() => {
   init_template_registry();
   require2 = createRequire(import.meta.url);
 });
 
 // ../wp-typia-project-tools/src/runtime/migration-ui-capability.ts
-import { promises as fsp6 } from "fs";
+import { promises as fsp7 } from "fs";
 import path34 from "path";
 async function mutatePackageJson2(projectDir, mutate) {
   const packageJsonPath = path34.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp6.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fsp7.readFile(packageJsonPath, "utf8"));
   mutate(packageJson);
-  await fsp6.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp7.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function patchFile2(filePath, transform2) {
-  const source = await fsp6.readFile(filePath, "utf8");
+  const source = await fsp7.readFile(filePath, "utf8");
   const nextSource = transform2(source);
   if (nextSource === source) {
     throw new Error(`Unable to apply migration UI patch for ${filePath}`);
   }
-  await fsp6.writeFile(filePath, nextSource, "utf8");
+  await fsp7.writeFile(filePath, nextSource, "utf8");
 }
 function injectAfter(source, needle, insertion) {
   if (source.includes(insertion)) {
@@ -215798,36 +215764,8 @@ var init_starter_manifests = __esm(() => {
   init_built_in_block_artifacts();
 });
 
-// ../wp-typia-project-tools/src/runtime/fs-async.ts
-import { promises as fsp7 } from "fs";
-async function pathExists(filePath) {
-  try {
-    await fsp7.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function readOptionalUtf8File(filePath) {
-  try {
-    return await fsp7.readFile(filePath, "utf8");
-  } catch (error48) {
-    if (isFileNotFoundError2(error48)) {
-      return null;
-    }
-    throw error48;
-  }
-}
-function getNodeErrorCode(error48) {
-  return typeof error48 === "object" && error48 !== null && "code" in error48 ? String(error48.code) : "";
-}
-function isFileNotFoundError2(error48) {
-  return getNodeErrorCode(error48) === "ENOENT";
-}
-var init_fs_async = () => {};
-
 // ../wp-typia-project-tools/src/runtime/scaffold-bootstrap.ts
-import fs26 from "fs";
+import fs25 from "fs";
 import { promises as fsp8 } from "fs";
 import path35 from "path";
 async function ensureScaffoldDirectory(targetDir, allowExisting = false) {
@@ -215842,10 +215780,10 @@ async function ensureScaffoldDirectory(targetDir, allowExisting = false) {
 }
 function readGeneratedPackageJson(projectDir) {
   const packageJsonPath = path35.join(projectDir, "package.json");
-  if (!fs26.existsSync(packageJsonPath)) {
+  if (!fs25.existsSync(packageJsonPath)) {
     return null;
   }
-  return JSON.parse(fs26.readFileSync(packageJsonPath, "utf8"));
+  return JSON.parse(fs25.readFileSync(packageJsonPath, "utf8"));
 }
 function formatNonEmptyTargetDirectoryError(targetDir) {
   return `Target directory is not empty: ${targetDir}. Choose a new project directory, or empty this directory before rerunning the scaffold.`;
@@ -216024,7 +215962,7 @@ var init_scaffold_package_manager_files = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/scaffold-repository-reference.ts
-import fs27 from "fs";
+import fs26 from "fs";
 import { createRequire as createRequire2 } from "module";
 import path37 from "path";
 function getErrorCode2(error48) {
@@ -216032,7 +215970,7 @@ function getErrorCode2(error48) {
 }
 function readRepositoryPackageManifest(packageJsonPath) {
   try {
-    return JSON.parse(fs27.readFileSync(packageJsonPath, "utf8"));
+    return JSON.parse(fs26.readFileSync(packageJsonPath, "utf8"));
   } catch (error48) {
     if (getErrorCode2(error48) === "ENOENT") {
       return null;
@@ -216416,7 +216354,7 @@ var init_scaffold_apply_utils = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/template-builtins.ts
-import fs28 from "fs";
+import fs27 from "fs";
 import path39 from "path";
 import { promises as fsp11 } from "fs";
 function isBuiltInSharedTemplateLayerId(layerId) {
@@ -216468,7 +216406,7 @@ function isOmittableBuiltInTemplateLayerDir(templateId, layerDir) {
 }
 function resolveMaterializedTemplateLayerDirs(templateId, layerDirs) {
   return layerDirs.flatMap((layerDir) => {
-    if (fs28.existsSync(layerDir)) {
+    if (fs27.existsSync(layerDir)) {
       return [layerDir];
     }
     if (isOmittableBuiltInTemplateLayerDir(templateId, layerDir)) {
@@ -220176,7 +220114,7 @@ var init_template_source_locators = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/template-layers.ts
-import fs29 from "fs";
+import fs28 from "fs";
 import path41 from "path";
 import { promises as fsp12 } from "fs";
 function resolveLayerPath(sourceRoot, relativePath) {
@@ -220226,7 +220164,7 @@ function parseLayerDefinition(layerId, value2) {
 }
 async function loadExternalTemplateLayerManifest(sourceRoot) {
   const manifestPath = path41.join(sourceRoot, TEMPLATE_LAYER_MANIFEST_FILENAME);
-  if (!fs29.existsSync(manifestPath)) {
+  if (!fs28.existsSync(manifestPath)) {
     return null;
   }
   const raw = JSON.parse(await fsp12.readFile(manifestPath, "utf8"));
@@ -220367,7 +220305,7 @@ var init_template_layers = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/external-template-guards.ts
-import fs30 from "fs";
+import fs29 from "fs";
 function parsePositiveIntegerEnv(value2, fallback) {
   if (typeof value2 !== "string" || value2.trim().length === 0) {
     return fallback;
@@ -220402,7 +220340,7 @@ function createExternalTemplateTooLargeError(label, maxBytes) {
   return createTemplateGuardError(TEMPLATE_SOURCE_TOO_LARGE_CODE, `${label} exceeded the external template size limit (${maxBytes} bytes).`);
 }
 function assertExternalTemplateFileSize(filePath, options) {
-  const stats = fs30.statSync(filePath);
+  const stats = fs29.statSync(filePath);
   if (stats.size > options.maxBytes) {
     throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
   }
@@ -220496,7 +220434,7 @@ var init_external_template_guards = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/template-source-external.ts
-import fs31 from "fs";
+import fs30 from "fs";
 import { promises as fsp13 } from "fs";
 import path42 from "path";
 import { pathToFileURL } from "url";
@@ -220643,7 +220581,7 @@ async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVa
     await copyRenderedDirectory(blockTemplateDir, blockDir, view, {
       filter: (sourcePath, _destinationPath, entry) => {
         const mustacheVariantPath = path42.join(path42.dirname(sourcePath), `${entry.name}.mustache`);
-        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs31.existsSync(mustacheVariantPath));
+        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs30.existsSync(mustacheVariantPath));
       }
     });
     const assetsPath = typeof variantConfig.assetsPath === "string" ? variantConfig.assetsPath : config2.assetsPath;
@@ -220681,7 +220619,7 @@ var init_template_source_external = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/template-source-remote.ts
-import fs32 from "fs";
+import fs31 from "fs";
 import { promises as fsp14 } from "fs";
 import path43 from "path";
 async function cleanupSeedRootPair(cleanup, seedCleanup) {
@@ -220768,7 +220706,7 @@ async function normalizeWpTypiaTemplateSeed(seed) {
     await copyRawDirectory(seed.blockDir, normalizedDir, {
       filter: (sourcePath, _targetPath, entry) => {
         const mustacheVariantPath = path43.join(path43.dirname(sourcePath), `${entry.name}.mustache`);
-        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs32.existsSync(mustacheVariantPath));
+        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs31.existsSync(mustacheVariantPath));
       }
     });
     if (seed.assetsDir && await pathExists(seed.assetsDir)) {
@@ -221486,7 +221424,7 @@ var kr, vr = (s, t2) => {
 }, Gn = (s3, t2) => {
   let e = new Et(s3);
   return hr(e, t2).catch((i) => e.emit("error", i)), e;
-}, Zn, Yn, fr, dr, ar, ur, mr, pr, Kn, Vn, $n, lr, cs, fs33 = (s3, t2, e) => {
+}, Zn, Yn, fr, dr, ar, ur, mr, pr, Kn, Vn, $n, lr, cs, fs32 = (s3, t2, e) => {
   try {
     return mi.lchownSync(s3, t2, e);
   } catch (i) {
@@ -221531,7 +221469,7 @@ var kr, vr = (s, t2) => {
       Xn(s3, l, t2, e, a);
   });
 }, qn = (s3, t2, e, i) => {
-  t2.isDirectory() && us(Ee2.resolve(s3, t2.name), e, i), fs33(Ee2.resolve(s3, t2.name), e, i);
+  t2.isDirectory() && us(Ee2.resolve(s3, t2.name), e, i), fs32(Ee2.resolve(s3, t2.name), e, i);
 }, us = (s3, t2, e) => {
   let i;
   try {
@@ -221541,12 +221479,12 @@ var kr, vr = (s, t2) => {
     if (n?.code === "ENOENT")
       return;
     if (n?.code === "ENOTDIR" || n?.code === "ENOTSUP")
-      return fs33(s3, t2, e);
+      return fs32(s3, t2, e);
     throw n;
   }
   for (let r of i)
     qn(s3, r, t2, e);
-  return fs33(s3, t2, e);
+  return fs32(s3, t2, e);
 }, we2, wt, Qn = (s3, t2) => {
   k2.stat(s3, (e, i) => {
     (e || !i.isDirectory()) && (e = new we2(s3, e?.code || "ENOTDIR")), t2(e);
@@ -224149,7 +224087,7 @@ var init_index_min = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/template-source-cache.ts
 import { createHash } from "crypto";
-import fs34 from "fs";
+import fs33 from "fs";
 import { promises as fsp15 } from "fs";
 import os4 from "os";
 import path45 from "path";
@@ -224212,7 +224150,7 @@ function createExternalTemplateCacheKey(keyParts) {
 }
 async function pathExists2(filePath) {
   try {
-    await fsp15.access(filePath, fs34.constants.F_OK);
+    await fsp15.access(filePath, fs33.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -224715,7 +224653,7 @@ var init_template_source_cache = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/template-source-seeds.ts
-import fs35 from "fs";
+import fs34 from "fs";
 import { promises as fsp16 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path46 from "path";
@@ -224881,8 +224819,8 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
     return null;
   }
   const workspacePackagesRoot = path46.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..");
-  if (fs35.existsSync(workspacePackagesRoot)) {
-    for (const entry of fs35.readdirSync(workspacePackagesRoot, {
+  if (fs34.existsSync(workspacePackagesRoot)) {
+    for (const entry of fs34.readdirSync(workspacePackagesRoot, {
       withFileTypes: true
     })) {
       if (!entry.isDirectory()) {
@@ -224890,10 +224828,10 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
       }
       const packageDir = path46.join(workspacePackagesRoot, entry.name);
       const packageJsonPath = path46.join(packageDir, "package.json");
-      if (!fs35.existsSync(packageJsonPath)) {
+      if (!fs34.existsSync(packageJsonPath)) {
         continue;
       }
-      const manifest = JSON.parse(fs35.readFileSync(packageJsonPath, "utf8"));
+      const manifest = JSON.parse(fs34.readFileSync(packageJsonPath, "utf8"));
       if (manifest.name === locator.name) {
         return {
           blockDir: packageDir,
@@ -224904,7 +224842,7 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
   }
   const workspaceRequire = createRequire3(path46.join(path46.resolve(cwd), "__wp_typia_template_resolver__.cjs"));
   try {
-    const packageJsonPath = fs35.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
+    const packageJsonPath = fs34.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
     const sourceDir = path46.dirname(packageJsonPath);
     return {
       blockDir: sourceDir,
@@ -224915,10 +224853,10 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
     if (errorCode === "MODULE_NOT_FOUND" || errorCode === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
       for (const basePath of workspaceRequire.resolve.paths(locator.name) ?? []) {
         const packageJsonPath = path46.join(basePath, locator.name, "package.json");
-        if (!fs35.existsSync(packageJsonPath)) {
+        if (!fs34.existsSync(packageJsonPath)) {
           continue;
         }
-        const sourceDir = path46.dirname(fs35.realpathSync(packageJsonPath));
+        const sourceDir = path46.dirname(fs34.realpathSync(packageJsonPath));
         return {
           blockDir: sourceDir,
           rootDir: sourceDir
@@ -224931,11 +224869,11 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
 }
 function isOfficialWorkspaceTemplateSeed(seed) {
   const packageJsonPath = path46.join(seed.rootDir, "package.json");
-  if (!fs35.existsSync(packageJsonPath)) {
+  if (!fs34.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson = JSON.parse(fs35.readFileSync(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(fs34.readFileSync(packageJsonPath, "utf8"));
     return packageJson.name === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE;
   } catch {
     return false;
@@ -224984,7 +224922,7 @@ function resolveGitHubTemplateDirectory(checkoutDir, locator) {
   if (relativeSourceDir.startsWith("..") || path46.isAbsolute(relativeSourceDir)) {
     throw new Error("GitHub template path must stay within the cloned repository.");
   }
-  if (!fs35.existsSync(sourceDir)) {
+  if (!fs34.existsSync(sourceDir)) {
     throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
   }
   return sourceDir;
@@ -225188,7 +225126,7 @@ async function resolveGitHubTemplateSource(locator) {
 async function resolveTemplateSeed(locator, cwd) {
   if (locator.kind === "path") {
     const sourceDir = path46.resolve(cwd, locator.templatePath);
-    if (!fs35.existsSync(sourceDir)) {
+    if (!fs34.existsSync(sourceDir)) {
       throw new Error(`Template path does not exist: ${sourceDir}`);
     }
     await assertNoSymlinks2(sourceDir);
@@ -225224,7 +225162,7 @@ var init_template_source_seeds = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-validation.ts
-import fs36 from "fs";
+import fs35 from "fs";
 import path47 from "path";
 function normalizeOptionalCliString(value2) {
   if (typeof value2 !== "string") {
@@ -225242,7 +225180,7 @@ function resolveLocalCliPathOption(options) {
     return normalizedValue;
   }
   const resolvedPath = path47.resolve(options.cwd, normalizedValue);
-  if (!fs36.existsSync(resolvedPath)) {
+  if (!fs35.existsSync(resolvedPath)) {
     throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `\`${options.label}\` path does not exist: ${resolvedPath}. Check the path relative to ${options.cwd}.`);
   }
   return resolvedPath;
@@ -230857,7 +230795,7 @@ var init_scaffold_answer_resolution = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
-import fs37 from "fs";
+import fs36 from "fs";
 import { promises as fsp17 } from "fs";
 import path49 from "path";
 function isDataStorageMode(value2) {
@@ -231006,7 +230944,7 @@ async function scaffoldProject({
     title: "Finalizing scaffold output"
   });
   const readmePath = path49.join(projectDir, "README.md");
-  if (!fs37.existsSync(readmePath)) {
+  if (!fs36.existsSync(readmePath)) {
     await fsp17.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
       withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
       withTestPreset: isBuiltInTemplate ? withTestPreset : false,
@@ -231014,7 +230952,7 @@ async function scaffoldProject({
     }), "utf8");
   }
   const gitignorePath = path49.join(projectDir, ".gitignore");
-  const existingGitignore = fs37.existsSync(gitignorePath) ? await fsp17.readFile(gitignorePath, "utf8") : "";
+  const existingGitignore = fs36.existsSync(gitignorePath) ? await fsp17.readFile(gitignorePath, "utf8") : "";
   await fsp17.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
   await normalizePackageJson(projectDir, resolvedPackageManager);
   if (isBuiltInTemplate) {
@@ -231228,7 +231166,7 @@ var init_cli_add_block_config = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-block-legacy-validator.ts
-import fs38 from "fs";
+import fs37 from "fs";
 import { promises as fsp18 } from "fs";
 import path51 from "path";
 function ensureBlockConfigCanAddRestManifests(source) {
@@ -231335,14 +231273,14 @@ async function ensureLegacyCompoundValidatorManifestDefaultsWrapper(validatorPat
   const validatorDir = path51.dirname(validatorPath);
   const wrapperPath = path51.join(validatorDir, "manifest-defaults-document.ts");
   const manifestPath = path51.join(validatorDir, "typia.manifest.json");
-  if (fs38.existsSync(wrapperPath) || !fs38.existsSync(manifestPath)) {
+  if (fs37.existsSync(wrapperPath) || !fs37.existsSync(manifestPath)) {
     return;
   }
   await fsp18.writeFile(wrapperPath, renderLegacyManifestDefaultsWrapperSource(), "utf8");
 }
 async function collectLegacyCompoundValidatorPaths(projectDir) {
   const blocksDir = path51.join(projectDir, "src", "blocks");
-  if (!fs38.existsSync(blocksDir)) {
+  if (!fs37.existsSync(blocksDir)) {
     return [];
   }
   const blockEntries = await fsp18.readdir(blocksDir, { withFileTypes: true });
@@ -231356,7 +231294,7 @@ async function collectLegacyCompoundValidatorPaths(projectDir) {
 async function ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths) {
   for (const fileName of COMPOUND_SHARED_SUPPORT_FILES) {
     const sourcePath = path51.join(tempProjectDir, "src", fileName);
-    if (!fs38.existsSync(sourcePath)) {
+    if (!fs37.existsSync(sourcePath)) {
       continue;
     }
     const targetPath = path51.join(projectDir, "src", fileName);
@@ -233042,7 +232980,7 @@ var init_cli_add_workspace_mutation = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
-import fs39 from "fs";
+import fs38 from "fs";
 import { promises as fsp20 } from "fs";
 import path54 from "path";
 function detectJsonIndent(source) {
@@ -233206,13 +233144,13 @@ function resolveAdminViewRegistryPath(projectDir) {
   return [
     path54.join(adminViewsDir, "index.ts"),
     path54.join(adminViewsDir, "index.js")
-  ].find((candidatePath) => fs39.existsSync(candidatePath)) ?? path54.join(adminViewsDir, "index.ts");
+  ].find((candidatePath) => fs38.existsSync(candidatePath)) ?? path54.join(adminViewsDir, "index.ts");
 }
 function readAdminViewRegistrySlugs(registryPath) {
-  if (!fs39.existsSync(registryPath)) {
+  if (!fs38.existsSync(registryPath)) {
     return [];
   }
-  const source = fs39.readFileSync(registryPath, "utf8");
+  const source = fs38.readFileSync(registryPath, "utf8");
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeAdminViewRegistry(projectDir, adminViewSlug) {
@@ -233324,7 +233262,7 @@ var init_cli_add_workspace_admin_view = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
-import fs40 from "fs";
+import fs39 from "fs";
 import { promises as fsp21 } from "fs";
 import path55 from "path";
 import {
@@ -234055,13 +233993,13 @@ async function ensureEditorPluginWebpackAnchors(workspace) {
 }
 function resolveBindingSourceRegistryPath(projectDir) {
   const bindingsDir = path55.join(projectDir, "src", "bindings");
-  return [path55.join(bindingsDir, "index.ts"), path55.join(bindingsDir, "index.js")].find((candidatePath) => fs40.existsSync(candidatePath)) ?? path55.join(bindingsDir, "index.ts");
+  return [path55.join(bindingsDir, "index.ts"), path55.join(bindingsDir, "index.js")].find((candidatePath) => fs39.existsSync(candidatePath)) ?? path55.join(bindingsDir, "index.ts");
 }
 async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
   const bindingsDir = path55.join(projectDir, "src", "bindings");
   const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
   await fsp21.mkdir(bindingsDir, { recursive: true });
-  const existingBindingSourceSlugs = fs40.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const existingBindingSourceSlugs = fs39.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   const nextBindingSourceSlugs = Array.from(new Set([...existingBindingSourceSlugs, bindingSourceSlug])).sort();
   await fsp21.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
 }
@@ -234070,13 +234008,13 @@ function resolveEditorPluginRegistryPath(projectDir) {
   return [
     path55.join(editorPluginsDir, "index.ts"),
     path55.join(editorPluginsDir, "index.js")
-  ].find((candidatePath) => fs40.existsSync(candidatePath)) ?? path55.join(editorPluginsDir, "index.ts");
+  ].find((candidatePath) => fs39.existsSync(candidatePath)) ?? path55.join(editorPluginsDir, "index.ts");
 }
 function readEditorPluginRegistrySlugs(registryPath) {
-  if (!fs40.existsSync(registryPath)) {
+  if (!fs39.existsSync(registryPath)) {
     return [];
   }
-  const source = fs40.readFileSync(registryPath, "utf8");
+  const source = fs39.readFileSync(registryPath, "utf8");
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
@@ -235947,7 +235885,7 @@ var init_cli_add_workspace_ability_templates = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
-import fs41 from "fs";
+import fs40 from "fs";
 import { promises as fsp23 } from "fs";
 import path59 from "path";
 import { syncTypeSchemas as syncTypeSchemas3 } from "@wp-typia/block-runtime/metadata-core";
@@ -235964,13 +235902,13 @@ function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
 }
 function resolveAbilityRegistryPath(projectDir) {
   const abilitiesDir = path59.join(projectDir, "src", "abilities");
-  return [path59.join(abilitiesDir, "index.ts"), path59.join(abilitiesDir, "index.js")].find((candidatePath) => fs41.existsSync(candidatePath)) ?? path59.join(abilitiesDir, "index.ts");
+  return [path59.join(abilitiesDir, "index.ts"), path59.join(abilitiesDir, "index.js")].find((candidatePath) => fs40.existsSync(candidatePath)) ?? path59.join(abilitiesDir, "index.ts");
 }
 function readAbilityRegistrySlugs(registryPath) {
-  if (!fs41.existsSync(registryPath)) {
+  if (!fs40.existsSync(registryPath)) {
     return [];
   }
-  const source = fs41.readFileSync(registryPath, "utf8");
+  const source = fs40.readFileSync(registryPath, "utf8");
   return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeAbilityRegistry(projectDir, abilitySlug) {
@@ -235981,7 +235919,7 @@ async function writeAbilityRegistry(projectDir, abilitySlug) {
   const existingRegistrySlugs = readAbilityRegistrySlugs(registryPath);
   const nextAbilitySlugs = Array.from(new Set([...existingAbilitySlugs, ...existingRegistrySlugs, abilitySlug])).sort();
   const generatedSection = buildAbilityRegistrySource(nextAbilitySlugs);
-  const existingSource = fs41.existsSync(registryPath) ? fs41.readFileSync(registryPath, "utf8") : "";
+  const existingSource = fs40.existsSync(registryPath) ? fs40.readFileSync(registryPath, "utf8") : "";
   const generatedSectionPattern = new RegExp(`${escapeRegex2(ABILITY_REGISTRY_START_MARKER)}[\\s\\S]*?${escapeRegex2(ABILITY_REGISTRY_END_MARKER)}\\n?`, "u");
   const nextSource = existingSource ? generatedSectionPattern.test(existingSource) ? existingSource.replace(generatedSectionPattern, generatedSection) : `${existingSource.trimEnd()}
 
@@ -237947,7 +237885,6 @@ var init_cli_add_workspace_ai = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
-import fs42 from "fs";
 import { promises as fsp26 } from "fs";
 import path63 from "path";
 function isIdentifierBoundary(source, index) {
@@ -238322,7 +238259,7 @@ async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
   const variationsDir = path63.join(projectDir, "src", "blocks", blockSlug, "variations");
   const variationsIndexPath = path63.join(variationsDir, "index.ts");
   await fsp26.mkdir(variationsDir, { recursive: true });
-  const existingVariationSlugs = fs42.readdirSync(variationsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const existingVariationSlugs = (await fsp26.readdir(variationsDir)).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
   await fsp26.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
@@ -238330,7 +238267,7 @@ async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
   const stylesDir = path63.join(projectDir, "src", "blocks", blockSlug, "styles");
   const stylesIndexPath = path63.join(stylesDir, "index.ts");
   await fsp26.mkdir(stylesDir, { recursive: true });
-  const existingStyleSlugs = fs42.readdirSync(stylesDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const existingStyleSlugs = (await fsp26.readdir(stylesDir)).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextStyleSlugs = Array.from(new Set([...existingStyleSlugs, styleSlug])).sort();
   await fsp26.writeFile(stylesIndexPath, buildBlockStyleIndexSource(nextStyleSlugs), "utf8");
 }
@@ -238338,7 +238275,7 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
   const transformsDir = path63.join(projectDir, "src", "blocks", blockSlug, "transforms");
   const transformsIndexPath = path63.join(transformsDir, "index.ts");
   await fsp26.mkdir(transformsDir, { recursive: true });
-  const existingTransformSlugs = fs42.readdirSync(transformsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const existingTransformSlugs = (await fsp26.readdir(transformsDir)).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
   await fsp26.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
@@ -238387,7 +238324,7 @@ async function runAddVariationCommand({
   const variationsDir = path63.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
   const variationFilePath = path63.join(variationsDir, `${variationSlug}.ts`);
   const variationsIndexPath = path63.join(variationsDir, "index.ts");
-  const shouldRemoveVariationsDirOnRollback = !fs42.existsSync(variationsDir);
+  const shouldRemoveVariationsDirOnRollback = !await pathExists(variationsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -238434,7 +238371,7 @@ async function runAddBlockStyleCommand({
   const stylesDir = path63.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
   const styleFilePath = path63.join(stylesDir, `${styleSlug}.ts`);
   const stylesIndexPath = path63.join(stylesDir, "index.ts");
-  const shouldRemoveStylesDirOnRollback = !fs42.existsSync(stylesDir);
+  const shouldRemoveStylesDirOnRollback = !await pathExists(stylesDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -238483,7 +238420,7 @@ async function runAddBlockTransformCommand({
   const transformsDir = path63.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
   const transformFilePath = path63.join(transformsDir, `${transformSlug}.ts`);
   const transformsIndexPath = path63.join(transformsDir, "index.ts");
-  const shouldRemoveTransformsDirOnRollback = !fs42.existsSync(transformsDir);
+  const shouldRemoveTransformsDirOnRollback = !await pathExists(transformsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -238543,7 +238480,7 @@ async function runAddHookedBlockCommand({
   if (resolvedAnchorBlockName === selfHookAnchor) {
     throw new Error("`wp-typia add hooked-block` cannot hook a block relative to its own block name.");
   }
-  const { blockJson, blockJsonPath } = readWorkspaceBlockJson(workspace.projectDir, blockSlug);
+  const { blockJson, blockJsonPath } = await readWorkspaceBlockJson(workspace.projectDir, blockSlug);
   const blockJsonRelativePath = path63.relative(workspace.projectDir, blockJsonPath);
   const blockHooks = getMutableBlockHooks(blockJson, blockJsonRelativePath);
   if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {
@@ -238570,6 +238507,7 @@ async function runAddHookedBlockCommand({
 }
 var VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';", VARIATIONS_IMPORT_PATTERN, VARIATIONS_CALL_LINE = "registerWorkspaceVariations();", VARIATIONS_CALL_PATTERN, BLOCK_STYLES_IMPORT_LINE = "import { registerWorkspaceBlockStyles } from './styles';", BLOCK_STYLES_IMPORT_PATTERN, BLOCK_STYLES_CALL_LINE = "registerWorkspaceBlockStyles();", BLOCK_STYLES_CALL_PATTERN, BLOCK_TRANSFORMS_IMPORT_LINE = "import { applyWorkspaceBlockTransforms } from './transforms';", BLOCK_TRANSFORMS_IMPORT_PATTERN, BLOCK_TRANSFORMS_CALL_LINE = "applyWorkspaceBlockTransforms(registration.settings);", BLOCK_TRANSFORMS_CALL_PATTERN, SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN, FULL_BLOCK_NAME_PATTERN;
 var init_cli_add_workspace = __esm(() => {
+  init_fs_async();
   init_workspace_project();
   init_workspace_inventory();
   init_string_case();
@@ -238622,7 +238560,7 @@ var init_cli_add = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-doctor-environment.ts
 import { execFileSync as execFileSync3 } from "child_process";
 import { access, constants as fsConstants, rm as rm2, writeFile as writeFile6 } from "fs/promises";
-import fs43 from "fs";
+import fs41 from "fs";
 import os5 from "os";
 import path64 from "path";
 function readCommandVersion(command, args = ["--version"]) {
@@ -238664,8 +238602,8 @@ function getTemplateDoctorChecks() {
   const checks3 = [];
   for (const template of listTemplates()) {
     if (!isBuiltInTemplateId(template.id)) {
-      const templateDirExists = fs43.existsSync(template.templateDir);
-      const hasAssets2 = templateDirExists && fs43.existsSync(path64.join(template.templateDir, "package.json.mustache"));
+      const templateDirExists = fs41.existsSync(template.templateDir);
+      const hasAssets2 = templateDirExists && fs41.existsSync(path64.join(template.templateDir, "package.json.mustache"));
       checks3.push({
         status: !templateDirExists || hasAssets2 ? "pass" : "fail",
         label: `Template ${template.id}`,
@@ -238688,9 +238626,9 @@ function getTemplateDoctorChecks() {
         persistencePolicy: "public"
       })
     ])) : getBuiltInTemplateLayerDirs(builtInTemplateId);
-    const missingRequiredLayer = layerDirs.some((layerDir) => !fs43.existsSync(layerDir) && !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
-    const existingLayerDirs = layerDirs.filter((layerDir) => fs43.existsSync(layerDir));
-    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs43.existsSync(path64.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs43.existsSync(path64.join(layerDir, "src")));
+    const missingRequiredLayer = layerDirs.some((layerDir) => !fs41.existsSync(layerDir) && !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
+    const existingLayerDirs = layerDirs.filter((layerDir) => fs41.existsSync(layerDir));
+    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs41.existsSync(path64.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs41.existsSync(path64.join(layerDir, "src")));
     checks3.push({
       status: hasAssets ? "pass" : "fail",
       label: `Template ${template.id}`,
@@ -238720,7 +238658,7 @@ var init_cli_doctor_environment = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-shared.ts
-import fs44 from "fs";
+import fs42 from "fs";
 import path65 from "path";
 function createDoctorCheck2(label, status, detail, code) {
   return code ? { code, detail, label, status } : { detail, label, status };
@@ -238735,7 +238673,7 @@ function resolveWorkspaceBootstrapPath(projectDir, packageName) {
   return path65.join(projectDir, getWorkspaceBootstrapRelativePath(packageName));
 }
 function checkExistingFiles(projectDir, label, filePaths) {
-  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs44.existsSync(path65.join(projectDir, filePath)));
+  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs42.existsSync(path65.join(projectDir, filePath)));
   return createDoctorCheck2(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
 }
 var WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php", WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js", WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php", WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php", WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php", WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php", WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php", WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js", WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php", WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css", WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js", WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php", WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css", WORKSPACE_GENERATED_BLOCK_ARTIFACTS, WORKSPACE_FULL_BLOCK_NAME_PATTERN;
@@ -238751,15 +238689,15 @@ var init_cli_doctor_workspace_shared = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-bindings.ts
-import fs45 from "fs";
+import fs43 from "fs";
 import path66 from "path";
 import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata2 } from "@wp-typia/block-runtime/blocks";
 function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-  if (!fs45.existsSync(bootstrapPath)) {
+  if (!fs43.existsSync(bootstrapPath)) {
     return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path66.basename(bootstrapPath)}`);
   }
-  const source = fs45.readFileSync(bootstrapPath, "utf8");
+  const source = fs43.readFileSync(bootstrapPath, "utf8");
   const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
   const hasEditorEnqueueHook = source.includes("enqueue_block_editor_assets");
   const hasEditorScript = source.includes(WORKSPACE_BINDING_EDITOR_SCRIPT);
@@ -238767,12 +238705,12 @@ function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   return createDoctorCheck2("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "Binding source PHP and editor bootstrap hooks are present" : "Missing binding source PHP require glob or editor enqueue hook");
 }
 function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
-  const indexRelativePath = [path66.join("src", "bindings", "index.ts"), path66.join("src", "bindings", "index.js")].find((relativePath) => fs45.existsSync(path66.join(projectDir, relativePath)));
+  const indexRelativePath = [path66.join("src", "bindings", "index.ts"), path66.join("src", "bindings", "index.js")].find((relativePath) => fs43.existsSync(path66.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
   }
   const indexPath = path66.join(projectDir, indexRelativePath);
-  const source = fs45.readFileSync(indexPath, "utf8");
+  const source = fs43.readFileSync(indexPath, "utf8");
   const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
   return createDoctorCheck2("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Binding source editor registrations are aggregated" : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
@@ -238792,7 +238730,7 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   const blockJsonPath = path66.join(projectDir, blockJsonRelativePath);
   const issues = [];
   try {
-    const blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs45.readFileSync(blockJsonPath, "utf8")));
+    const blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs43.readFileSync(blockJsonPath, "utf8")));
     const attributes = blockJson.attributes;
     if (!attributes || typeof attributes !== "object" || Array.isArray(attributes)) {
       issues.push(`${blockJsonRelativePath} must define an attributes object`);
@@ -238806,8 +238744,8 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
     issues.push(error48 instanceof Error ? `Unable to read ${blockJsonRelativePath}: ${error48.message}` : `Unable to read ${blockJsonRelativePath}.`);
   }
   const serverPath = path66.join(projectDir, bindingSource.serverFile);
-  if (fs45.existsSync(serverPath)) {
-    const serverSource = fs45.readFileSync(serverPath, "utf8");
+  if (fs43.existsSync(serverPath)) {
+    const serverSource = fs43.readFileSync(serverPath, "utf8");
     const supportedAttributesFilter = `block_bindings_supported_attributes_${workspace.workspace.namespace}/${bindingSource.block}`;
     if (!serverSource.includes(supportedAttributesFilter)) {
       issues.push(`${bindingSource.serverFile} must register ${supportedAttributesFilter}`);
@@ -238819,8 +238757,8 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
     issues.push(`Missing ${bindingSource.serverFile}`);
   }
   const editorPath = path66.join(projectDir, bindingSource.editorFile);
-  if (fs45.existsSync(editorPath)) {
-    const editorSource = fs45.readFileSync(editorPath, "utf8");
+  if (fs43.existsSync(editorPath)) {
+    const editorSource = fs43.readFileSync(editorPath, "utf8");
     const blockName = `${workspace.workspace.namespace}/${bindingSource.block}`;
     const bindingSourceTargetMatch = editorSource.match(/export\s+const\s+BINDING_SOURCE_TARGET\s*=\s*\{([\s\S]*?)\}\s+as\s+const\s*;/u);
     if (!bindingSourceTargetMatch) {
@@ -238865,7 +238803,7 @@ var init_cli_doctor_workspace_bindings = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-blocks.ts
-import fs46 from "fs";
+import fs44 from "fs";
 import path67 from "path";
 import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata3 } from "@wp-typia/block-runtime/blocks";
 function normalizePathSeparators(relativePath) {
@@ -238883,14 +238821,14 @@ function hasRegisteredBlockAsset(value2) {
 function readWorkspaceBlockIframeMetadata(projectDir, blockSlug) {
   const blockJsonRelativePath = path67.join("src", "blocks", blockSlug, "block.json");
   const blockJsonPath = path67.join(projectDir, blockJsonRelativePath);
-  if (!fs46.existsSync(blockJsonPath)) {
+  if (!fs44.existsSync(blockJsonPath)) {
     return {
       blockJsonRelativePath,
       error: `Missing ${blockJsonRelativePath}`
     };
   }
   try {
-    const document2 = parseScaffoldBlockMetadata3(JSON.parse(fs46.readFileSync(blockJsonPath, "utf8")));
+    const document2 = parseScaffoldBlockMetadata3(JSON.parse(fs44.readFileSync(blockJsonPath, "utf8")));
     return {
       blockJsonRelativePath,
       document: document2
@@ -238921,7 +238859,7 @@ function isWorkspaceBlockSaveSource(relativePath) {
 }
 function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
   const blockDir = path67.join(projectDir, "src", "blocks", blockSlug);
-  if (!fs46.existsSync(blockDir)) {
+  if (!fs44.existsSync(blockDir)) {
     return [];
   }
   const collected = [];
@@ -238931,7 +238869,7 @@ function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
     if (!currentDir) {
       continue;
     }
-    for (const entry of fs46.readdirSync(currentDir, { withFileTypes: true })) {
+    for (const entry of fs44.readdirSync(currentDir, { withFileTypes: true })) {
       const absolutePath = path67.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         queue.push(absolutePath);
@@ -238946,7 +238884,7 @@ function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
       }
       collected.push({
         relativePath: normalizePathSeparators(relativePath),
-        source: fs46.readFileSync(absolutePath, "utf8")
+        source: fs44.readFileSync(absolutePath, "utf8")
       });
     }
   }
@@ -239017,12 +238955,12 @@ function getWorkspaceBlockRequiredFiles(block) {
 function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
   const blockJsonRelativePath = path67.join("src", "blocks", block.slug, "block.json");
   const blockJsonPath = path67.join(projectDir, blockJsonRelativePath);
-  if (!fs46.existsSync(blockJsonPath)) {
+  if (!fs44.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
   let blockJson;
   try {
-    blockJson = parseScaffoldBlockMetadata3(JSON.parse(fs46.readFileSync(blockJsonPath, "utf8")));
+    blockJson = parseScaffoldBlockMetadata3(JSON.parse(fs44.readFileSync(blockJsonPath, "utf8")));
   } catch (error48) {
     return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", error48 instanceof Error ? error48.message : String(error48));
   }
@@ -239039,12 +238977,12 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
 function checkWorkspaceBlockHooks(projectDir, blockSlug) {
   const blockJsonRelativePath = path67.join("src", "blocks", blockSlug, "block.json");
   const blockJsonPath = path67.join(projectDir, blockJsonRelativePath);
-  if (!fs46.existsSync(blockJsonPath)) {
+  if (!fs44.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
   let blockJson;
   try {
-    blockJson = parseScaffoldBlockMetadata3(JSON.parse(fs46.readFileSync(blockJsonPath, "utf8")));
+    blockJson = parseScaffoldBlockMetadata3(JSON.parse(fs44.readFileSync(blockJsonPath, "utf8")));
   } catch (error48) {
     return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", error48 instanceof Error ? error48.message : String(error48));
   }
@@ -239062,10 +239000,10 @@ function checkWorkspaceBlockHooks(projectDir, blockSlug) {
 function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
   const entryRelativePath = path67.join("src", "blocks", blockSlug, "index.tsx");
   const entryPath = path67.join(projectDir, entryRelativePath);
-  if (!fs46.existsSync(entryPath)) {
+  if (!fs44.existsSync(entryPath)) {
     return createDoctorCheck2(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
   }
-  const source = fs46.readFileSync(entryPath, "utf8");
+  const source = fs44.readFileSync(entryPath, "utf8");
   const hasCollectionImport = WORKSPACE_COLLECTION_IMPORT_PATTERN.test(source);
   return createDoctorCheck2(`Block collection ${blockSlug}`, hasCollectionImport ? "pass" : "fail", hasCollectionImport ? "Shared block collection import is present" : `Missing a shared collection import like ${WORKSPACE_COLLECTION_IMPORT_LINE}`);
 }
@@ -239079,7 +239017,7 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
   const blockJson = metadataResult.document;
   const apiVersion = typeof blockJson.apiVersion === "number" && Number.isFinite(blockJson.apiVersion) ? blockJson.apiVersion : null;
   const blockDir = path67.join(projectDir, "src", "blocks", blockSlug);
-  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs46.existsSync(path67.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path67.join("src", "blocks", blockSlug, fileName)));
+  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs44.existsSync(path67.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path67.join("src", "blocks", blockSlug, fileName)));
   const hasRegisteredEditorStyles = hasRegisteredBlockAsset(blockJson.style) || hasRegisteredBlockAsset(blockJson.editorStyle);
   const editorSources = collectWorkspaceBlockEditorSources(projectDir, blockSlug);
   const editorWrapperSources = editorSources.filter((source) => !isWorkspaceBlockSaveSource(source.relativePath));
@@ -239097,40 +239035,40 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
 }
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-  if (!fs46.existsSync(bootstrapPath)) {
+  if (!fs44.existsSync(bootstrapPath)) {
     return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path67.basename(bootstrapPath)}`);
   }
-  const source = fs46.readFileSync(bootstrapPath, "utf8");
+  const source = fs44.readFileSync(bootstrapPath, "utf8");
   const hasCategoryAnchor = source.includes("register_block_pattern_category");
   const hasPatternGlob = source.includes("/src/patterns/*.php");
   return createDoctorCheck2("Pattern bootstrap", hasCategoryAnchor && hasPatternGlob ? "pass" : "fail", hasCategoryAnchor && hasPatternGlob ? "Pattern category and loader hooks are present" : "Missing pattern category registration or src/patterns loader hook");
 }
 function checkVariationEntrypoint(projectDir, blockSlug) {
   const entryPath = path67.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
-  if (!fs46.existsSync(entryPath)) {
+  if (!fs44.existsSync(entryPath)) {
     return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path67.relative(projectDir, entryPath)}`);
   }
-  const source = fs46.readFileSync(entryPath, "utf8");
+  const source = fs44.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern(source, WORKSPACE_VARIATIONS_IMPORT_PATTERN);
   const hasCall = hasExecutablePattern(source, WORKSPACE_VARIATIONS_CALL_PATTERN);
   return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Variations registration hook is present" : "Missing ./variations import or registerWorkspaceVariations() call");
 }
 function checkBlockStyleEntrypoint(projectDir, blockSlug) {
   const entryPath = path67.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
-  if (!fs46.existsSync(entryPath)) {
+  if (!fs44.existsSync(entryPath)) {
     return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path67.relative(projectDir, entryPath)}`);
   }
-  const source = fs46.readFileSync(entryPath, "utf8");
+  const source = fs44.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern(source, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN);
   const hasCall = hasExecutablePattern(source, WORKSPACE_BLOCK_STYLES_CALL_PATTERN);
   return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block style registration hook is present" : "Missing ./styles import or registerWorkspaceBlockStyles() call");
 }
 function checkBlockTransformEntrypoint(projectDir, blockSlug) {
   const entryPath = path67.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
-  if (!fs46.existsSync(entryPath)) {
+  if (!fs44.existsSync(entryPath)) {
     return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path67.relative(projectDir, entryPath)}`);
   }
-  const source = fs46.readFileSync(entryPath, "utf8");
+  const source = fs44.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern(source, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN);
   const hasCall = hasExecutablePattern(source, WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN);
   return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block transform registration hook is present" : "Missing ./transforms import or applyWorkspaceBlockTransforms(registration.settings) call");
@@ -239199,7 +239137,7 @@ function getWorkspaceBlockDoctorChecks(workspace, inventory) {
     ]));
     checks3.push(checkBlockTransformEntrypoint(workspace.projectDir, blockSlug));
   }
-  const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs46.existsSync(path67.join(workspace.projectDir, "src", "patterns"));
+  const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs44.existsSync(path67.join(workspace.projectDir, "src", "patterns"));
   if (shouldCheckPatternBootstrap) {
     checks3.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
   }
@@ -239250,7 +239188,7 @@ var init_cli_doctor_workspace_blocks = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-features.ts
-import fs47 from "fs";
+import fs45 from "fs";
 import path68 from "path";
 function getWorkspaceRestResourceRequiredFiles(restResource) {
   const schemaNames = new Set;
@@ -239293,10 +239231,10 @@ function checkWorkspaceRestResourceConfig(restResource) {
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-  if (!fs47.existsSync(bootstrapPath)) {
+  if (!fs45.existsSync(bootstrapPath)) {
     return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path68.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs45.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_rest_resources`;
   const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
   const hasServerGlob = source.includes(WORKSPACE_REST_RESOURCE_GLOB);
@@ -239316,11 +239254,11 @@ function getWorkspaceAbilityRequiredFiles(ability) {
 }
 function checkWorkspaceAbilityConfig(projectDir, ability) {
   const configPath = path68.join(projectDir, ability.configFile);
-  if (!fs47.existsSync(configPath)) {
+  if (!fs45.existsSync(configPath)) {
     return createDoctorCheck2(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
   }
   try {
-    const config2 = JSON.parse(fs47.readFileSync(configPath, "utf8"));
+    const config2 = JSON.parse(fs45.readFileSync(configPath, "utf8"));
     const abilityId = typeof config2.abilityId === "string" ? config2.abilityId.trim() : "";
     const categorySlug = typeof config2.category?.slug === "string" ? config2.category.slug.trim() : "";
     const hasValidAbilityId = /^[a-z0-9-]+\/[a-z0-9-]+$/u.test(abilityId);
@@ -239332,10 +239270,10 @@ function checkWorkspaceAbilityConfig(projectDir, ability) {
 }
 function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-  if (!fs47.existsSync(bootstrapPath)) {
+  if (!fs45.existsSync(bootstrapPath)) {
     return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path68.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs45.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
   const enqueueFunctionName = `${phpPrefix}_enqueue_workflow_abilities`;
   const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
@@ -239354,12 +239292,12 @@ function checkWorkspaceAbilityIndex(projectDir, abilities) {
   const indexRelativePath = [
     path68.join("src", "abilities", "index.ts"),
     path68.join("src", "abilities", "index.js")
-  ].find((relativePath) => fs47.existsSync(path68.join(projectDir, relativePath)));
+  ].find((relativePath) => fs45.existsSync(path68.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
   }
   const indexPath = path68.join(projectDir, indexRelativePath);
-  const source = fs47.readFileSync(indexPath, "utf8");
+  const source = fs45.readFileSync(indexPath, "utf8");
   const missingExports = abilities.filter((ability) => {
     const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex2(ability.slug)}\\/client['"\`]`, "mu");
     return !exportPattern.test(source);
@@ -239387,10 +239325,10 @@ function checkWorkspaceAiFeatureConfig(aiFeature) {
 }
 function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-  if (!fs47.existsSync(bootstrapPath)) {
+  if (!fs45.existsSync(bootstrapPath)) {
     return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path68.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs45.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_ai_features`;
   const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
   const hasServerGlob = source.includes(WORKSPACE_AI_FEATURE_GLOB);
@@ -239415,10 +239353,10 @@ function checkWorkspaceEditorPluginConfig(editorPlugin) {
 }
 function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-  if (!fs47.existsSync(bootstrapPath)) {
+  if (!fs45.existsSync(bootstrapPath)) {
     return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path68.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs45.readFileSync(bootstrapPath, "utf8");
   const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
   const enqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
   const hasEditorEnqueueHook = source.includes(enqueueHook);
@@ -239431,12 +239369,12 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   const indexRelativePath = [
     path68.join("src", "editor-plugins", "index.ts"),
     path68.join("src", "editor-plugins", "index.js")
-  ].find((relativePath) => fs47.existsSync(path68.join(projectDir, relativePath)));
+  ].find((relativePath) => fs45.existsSync(path68.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
   }
   const indexPath = path68.join(projectDir, indexRelativePath);
-  const source = fs47.readFileSync(indexPath, "utf8");
+  const source = fs45.readFileSync(indexPath, "utf8");
   const missingImports = editorPlugins.filter((editorPlugin) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
     return !importPattern.test(source);
@@ -239469,10 +239407,10 @@ function checkWorkspaceAdminViewConfig(adminView, inventory) {
 }
 function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
   const bootstrapPath = resolveWorkspaceBootstrapPath(projectDir, packageName);
-  if (!fs47.existsSync(bootstrapPath)) {
+  if (!fs45.existsSync(bootstrapPath)) {
     return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path68.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs45.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_admin_views`;
   const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
   const hasLoaderHook = source.includes(loadHook);
@@ -239483,12 +239421,12 @@ function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
   const indexRelativePath = [
     path68.join("src", "admin-views", "index.ts"),
     path68.join("src", "admin-views", "index.js")
-  ].find((relativePath) => fs47.existsSync(path68.join(projectDir, relativePath)));
+  ].find((relativePath) => fs45.existsSync(path68.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
   }
   const indexPath = path68.join(projectDir, indexRelativePath);
-  const source = fs47.readFileSync(indexPath, "utf8");
+  const source = fs45.readFileSync(indexPath, "utf8");
   const missingImports = adminViews.filter((adminView) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(adminView.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
     return !importPattern.test(source);
@@ -239497,10 +239435,10 @@ function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
 }
 function checkWorkspaceAdminViewPhp(projectDir, adminView) {
   const phpPath = path68.join(projectDir, adminView.phpFile);
-  if (!fs47.existsSync(phpPath)) {
+  if (!fs45.existsSync(phpPath)) {
     return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
   }
-  const source = fs47.readFileSync(phpPath, "utf8");
+  const source = fs45.readFileSync(phpPath, "utf8");
   const hasAdminMenu = source.includes("add_submenu_page");
   const hasAdminEnqueue = source.includes("admin_enqueue_scripts");
   const hasScript = source.includes(WORKSPACE_ADMIN_VIEW_SCRIPT);
@@ -239558,7 +239496,7 @@ var init_cli_doctor_workspace_features = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-package.ts
-import fs48 from "fs";
+import fs46 from "fs";
 import path69 from "path";
 function getWorkspacePackageMetadataCheck(workspace, packageJson) {
   const issues = [];
@@ -239583,7 +239521,7 @@ function getWorkspacePackageMetadataCheck(workspace, packageJson) {
   if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
     issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
   }
-  if (!fs48.existsSync(path69.join(workspace.projectDir, bootstrapRelativePath))) {
+  if (!fs46.existsSync(path69.join(workspace.projectDir, bootstrapRelativePath))) {
     issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
   }
   return createDoctorCheck2("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}` : issues.join("; "));
@@ -239591,7 +239529,7 @@ function getWorkspacePackageMetadataCheck(workspace, packageJson) {
 function getMigrationWorkspaceHintCheck(workspace, packageJson) {
   const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
   const migrationConfigRelativePath = path69.join("src", "migrations", "config.ts");
-  const hasMigrationConfig = fs48.existsSync(path69.join(workspace.projectDir, migrationConfigRelativePath));
+  const hasMigrationConfig = fs46.existsSync(path69.join(workspace.projectDir, migrationConfigRelativePath));
   if (!hasMigrationScript && !hasMigrationConfig) {
     return null;
   }
@@ -239713,14 +239651,14 @@ var init_cli_doctor = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-init-package-json.ts
-import fs49 from "fs";
+import fs47 from "fs";
 import path70 from "path";
 function readProjectPackageJson(projectDir) {
   const packageJsonPath = path70.join(projectDir, "package.json");
-  if (!fs49.existsSync(packageJsonPath)) {
+  if (!fs47.existsSync(packageJsonPath)) {
     return null;
   }
-  const source = fs49.readFileSync(packageJsonPath, "utf8");
+  const source = fs47.readFileSync(packageJsonPath, "utf8");
   try {
     return JSON.parse(source);
   } catch (error48) {
@@ -239732,13 +239670,13 @@ function inferInitPackageManager(projectDir, packageJson) {
   if (packageJson?.packageManager) {
     return parseWorkspacePackageManagerId(packageJson.packageManager);
   }
-  if (fs49.existsSync(path70.join(projectDir, "bun.lock")) || fs49.existsSync(path70.join(projectDir, "bun.lockb"))) {
+  if (fs47.existsSync(path70.join(projectDir, "bun.lock")) || fs47.existsSync(path70.join(projectDir, "bun.lockb"))) {
     return "bun";
   }
-  if (fs49.existsSync(path70.join(projectDir, "pnpm-lock.yaml"))) {
+  if (fs47.existsSync(path70.join(projectDir, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs49.existsSync(path70.join(projectDir, "yarn.lock")) || fs49.existsSync(path70.join(projectDir, ".yarnrc.yml"))) {
+  if (fs47.existsSync(path70.join(projectDir, "yarn.lock")) || fs47.existsSync(path70.join(projectDir, ".yarnrc.yml"))) {
     return "yarn";
   }
   return "npm";
@@ -239828,7 +239766,7 @@ function hasExistingWpTypiaProjectSurface(projectDir, packageJson) {
     path70.join("scripts", "block-config.ts"),
     path70.join("scripts", "sync-project.ts"),
     path70.join("scripts", "sync-types-to-block-json.ts")
-  ].every((relativePath) => fs49.existsSync(path70.join(projectDir, relativePath)));
+  ].every((relativePath) => fs47.existsSync(path70.join(projectDir, relativePath)));
   const hasRuntimeDeps = typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-runtime") === "string" && typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-types") === "string";
   return hasSyncSurface && hasHelperFiles && hasRuntimeDeps;
 }
@@ -239892,11 +239830,83 @@ var init_cli_init_package_json = __esm(() => {
   ];
 });
 
+// ../wp-typia-project-tools/src/runtime/cli-init-plan-presentation.ts
+function buildInitPlanChangeSummary(changes, options) {
+  const lines = [];
+  for (const dependencyChange of changes.packageChanges.addDevDependencies) {
+    lines.push(`devDependency ${dependencyChange.action} ${dependencyChange.name} -> ${dependencyChange.requiredValue}`);
+  }
+  if (changes.packageChanges.packageManagerField) {
+    lines.push(`packageManager ${changes.packageChanges.packageManagerField.action} -> ${changes.packageChanges.packageManagerField.requiredValue}`);
+  }
+  for (const scriptChange of changes.packageChanges.scripts) {
+    lines.push(`script ${scriptChange.action} ${scriptChange.name} -> ${scriptChange.requiredValue}`);
+  }
+  for (const filePlan of changes.plannedFiles) {
+    lines.push(`file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`);
+  }
+  if (options.includeGeneratedArtifacts) {
+    for (const artifactPath of changes.generatedArtifacts) {
+      lines.push(`generated artifact ${artifactPath}`);
+    }
+  }
+  return lines;
+}
+function buildInitPlanNextSteps(options) {
+  const cliSpecifier = getWpTypiaCliSpecifier();
+  const syncTypesRun = formatRunScript(options.packageManager, "sync-types");
+  const syncRun = formatRunScript(options.packageManager, "sync");
+  const doctorRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "doctor");
+  const migrationInitRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "migrate init --current-migration-version v1");
+  const dependencyInstallCommand = formatAddDevDependenciesCommand(options.packageManager, buildRequiredDevDependencyMapEntries());
+  if (options.layoutKind === "unsupported") {
+    return [
+      "Align the project to one of the supported retrofit layouts listed below, then rerun `wp-typia init`.",
+      dependencyInstallCommand,
+      syncTypesRun,
+      doctorRun
+    ];
+  }
+  if (options.commandMode === "apply") {
+    return [
+      ...options.dependencyChangeCount > 0 ? [
+        "Install or reinstall project dependencies so the retrofit sync scripts and metadata generators are available locally.",
+        dependencyInstallCommand
+      ] : [],
+      syncRun,
+      doctorRun,
+      `Optional migration bootstrap: ${migrationInitRun}`
+    ];
+  }
+  return [
+    ...options.hasPlannedChanges ? [
+      "Re-run `wp-typia init --apply` to write the planned package.json changes and helper files automatically.",
+      ...options.dependencyChangeCount > 0 ? [dependencyInstallCommand] : []
+    ] : [],
+    syncRun,
+    doctorRun,
+    `Optional migration bootstrap: ${migrationInitRun}`
+  ];
+}
+function buildRetrofitPlanSummary(options) {
+  if (options.status === "already-initialized") {
+    return options.commandMode === "apply" ? "This project already exposes the minimum wp-typia retrofit surface. No files were changed." : "This project already exposes the minimum wp-typia retrofit surface.";
+  }
+  if (options.commandMode === "apply") {
+    return "Applied the minimum wp-typia retrofit surface so package.json and helper scripts are ready for the next install and sync run.";
+  }
+  return "This command previews the minimum wp-typia adoption layer for the current project without rewriting it into a full scaffold.";
+}
+var init_cli_init_plan_presentation = __esm(() => {
+  init_package_managers();
+  init_cli_init_package_json();
+});
+
 // ../wp-typia-project-tools/src/runtime/cli-init-types.ts
 var SUPPORTED_RETROFIT_LAYOUT_NOTE = "Supported retrofit layouts currently mirror the migration bootstrap detector: `src/block.json` + `src/types.ts` + `src/save.tsx`, legacy root `block.json` + `src/types.ts` + `src/save.tsx`, or multi-block `src/blocks/*/block.json` workspaces.", RETROFIT_APPLY_PREVIEW_NOTE = "If you rerun with `wp-typia init --apply`, package.json and generated helper files are snapshotted and rolled back automatically if a write fails.", RETROFIT_ROLLBACK_NOTE = "Apply mode writes package.json and generated helper files with rollback-on-failure protection.";
 
 // ../wp-typia-project-tools/src/runtime/cli-init-plan.ts
-import fs50 from "fs";
+import fs48 from "fs";
 import path71 from "path";
 import { analyzeSourceTypes } from "@wp-typia/block-runtime/metadata-parser";
 function normalizeRelativePath2(value2) {
@@ -239931,7 +239941,7 @@ function isObjectLikeSourceType(projectDir, typesFile, sourceTypeName) {
 }
 function inferRetrofitAttributeTypeName(projectDir, block) {
   const typesPath = path71.join(projectDir, block.typesFile);
-  const typesSource = fs50.readFileSync(typesPath, "utf8");
+  const typesSource = fs48.readFileSync(typesPath, "utf8");
   const blockNameSegments = block.blockName.split("/");
   const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
   const candidateNames = collectNamedSourceTypeCandidates(typesSource);
@@ -240023,92 +240033,25 @@ function buildPlannedFiles(projectDir, layoutKind) {
   }
   return [
     {
-      action: fs50.existsSync(path71.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
+      action: fs48.existsSync(path71.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
       path: "scripts/block-config.ts",
       purpose: "Declare the current retrofit block targets so sync-types can regenerate metadata from the existing TypeScript source of truth."
     },
     {
-      action: fs50.existsSync(path71.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
+      action: fs48.existsSync(path71.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
       path: "scripts/sync-types-to-block-json.ts",
       purpose: "Generate block.json and Typia metadata artifacts from the current TypeScript source of truth."
     },
     {
-      action: fs50.existsSync(path71.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
+      action: fs48.existsSync(path71.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
       path: "scripts/sync-project.ts",
       purpose: "Provide one shared sync entrypoint that can grow into sync-rest or workspace-aware refresh steps later."
     }
   ];
 }
-function buildChangeSummary(changes, options) {
-  const lines = [];
-  for (const dependencyChange of changes.packageChanges.addDevDependencies) {
-    lines.push(`devDependency ${dependencyChange.action} ${dependencyChange.name} -> ${dependencyChange.requiredValue}`);
-  }
-  if (changes.packageChanges.packageManagerField) {
-    lines.push(`packageManager ${changes.packageChanges.packageManagerField.action} -> ${changes.packageChanges.packageManagerField.requiredValue}`);
-  }
-  for (const scriptChange of changes.packageChanges.scripts) {
-    lines.push(`script ${scriptChange.action} ${scriptChange.name} -> ${scriptChange.requiredValue}`);
-  }
-  for (const filePlan of changes.plannedFiles) {
-    lines.push(`file ${filePlan.action} ${filePlan.path} (${filePlan.purpose})`);
-  }
-  if (options.includeGeneratedArtifacts) {
-    for (const artifactPath of changes.generatedArtifacts) {
-      lines.push(`generated artifact ${artifactPath}`);
-    }
-  }
-  return lines;
-}
-function buildNextSteps(options) {
-  const cliSpecifier = getWpTypiaCliSpecifier();
-  const syncTypesRun = formatRunScript(options.packageManager, "sync-types");
-  const syncRun = formatRunScript(options.packageManager, "sync");
-  const doctorRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "doctor");
-  const migrationInitRun = formatPackageExecCommand(options.packageManager, cliSpecifier, "migrate init --current-migration-version v1");
-  const dependencyInstallCommand = formatAddDevDependenciesCommand(options.packageManager, buildRequiredDevDependencyMapEntries());
-  if (options.layoutKind === "unsupported") {
-    return [
-      "Align the project to one of the supported retrofit layouts listed below, then rerun `wp-typia init`.",
-      dependencyInstallCommand,
-      syncTypesRun,
-      doctorRun
-    ];
-  }
-  if (options.commandMode === "apply") {
-    return [
-      ...options.dependencyChangeCount > 0 ? [
-        "Install or reinstall project dependencies so the retrofit sync scripts and metadata generators are available locally.",
-        dependencyInstallCommand
-      ] : [],
-      syncRun,
-      doctorRun,
-      `Optional migration bootstrap: ${migrationInitRun}`
-    ];
-  }
-  const steps = [
-    ...options.hasPlannedChanges ? [
-      "Re-run `wp-typia init --apply` to write the planned package.json changes and helper files automatically.",
-      ...options.dependencyChangeCount > 0 ? [dependencyInstallCommand] : []
-    ] : [],
-    syncRun,
-    doctorRun,
-    `Optional migration bootstrap: ${migrationInitRun}`
-  ];
-  return steps;
-}
-function buildRetrofitPlanSummary(options) {
-  if (options.status === "already-initialized") {
-    return options.commandMode === "apply" ? "This project already exposes the minimum wp-typia retrofit surface. No files were changed." : "This project already exposes the minimum wp-typia retrofit surface.";
-  }
-  if (options.commandMode === "apply") {
-    return "Applied the minimum wp-typia retrofit surface so package.json and helper scripts are ready for the next install and sync run.";
-  }
-  return "This command previews the minimum wp-typia adoption layer for the current project without rewriting it into a full scaffold.";
-}
 function createRetrofitPlan(options) {
   const includeGeneratedArtifacts = options.commandMode === "preview-only";
-  const plannedChanges = buildChangeSummary({
+  const plannedChanges = buildInitPlanChangeSummary({
     generatedArtifacts: options.generatedArtifacts,
     packageChanges: options.packageChanges,
     plannedFiles: options.plannedFiles
@@ -240120,7 +240063,7 @@ function createRetrofitPlan(options) {
     commandMode: options.commandMode,
     detectedLayout: options.detectedLayout,
     generatedArtifacts: options.generatedArtifacts,
-    nextSteps: options.nextSteps ?? buildNextSteps({
+    nextSteps: options.nextSteps ?? buildInitPlanNextSteps({
       commandMode: options.commandMode,
       dependencyChangeCount: options.packageChanges.addDevDependencies.length,
       hasPlannedChanges: plannedChanges.length > 0,
@@ -240225,6 +240168,7 @@ var init_cli_init_plan = __esm(() => {
   init_package_managers();
   init_string_case();
   init_cli_init_package_json();
+  init_cli_init_plan_presentation();
   init_workspace_project();
   import_typescript3 = __toESM(require_typescript(), 1);
 });
@@ -240459,12 +240403,12 @@ var init_cli_init_templates = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-init-apply.ts
-import fs51 from "fs";
+import fs49 from "fs";
 import { promises as fsp27 } from "fs";
 import path73 from "path";
 async function createRetrofitMutationSnapshot(projectDir, filePaths) {
   const scriptsDir = path73.join(projectDir, "scripts");
-  const scriptsDirExisted = fs51.existsSync(scriptsDir);
+  const scriptsDirExisted = fs49.existsSync(scriptsDir);
   const fileSources = await snapshotWorkspaceFiles(filePaths);
   const targetPaths = fileSources.filter((entry) => entry.source === null).map((entry) => entry.filePath);
   if (!scriptsDirExisted) {
@@ -240573,7 +240517,7 @@ __export(exports_cli_scaffold, {
   getOptionalOnboarding: () => getOptionalOnboarding,
   getNextSteps: () => getNextSteps
 });
-import fs52 from "fs";
+import fs50 from "fs";
 import { promises as fsp28 } from "fs";
 import path74 from "path";
 async function listRelativeProjectFiles(rootDir) {
@@ -240593,7 +240537,7 @@ async function listRelativeProjectFiles(rootDir) {
   return relativeFiles.sort((left, right) => left.localeCompare(right));
 }
 async function assertDryRunTargetDirectoryReady(projectDir, allowExistingDir) {
-  if (!fs52.existsSync(projectDir) || allowExistingDir) {
+  if (!fs50.existsSync(projectDir) || allowExistingDir) {
     return;
   }
   const entries = await fsp28.readdir(projectDir);
@@ -241038,7 +240982,7 @@ async function runScaffoldFlow({
     let availableScripts;
     if (!dryRun) {
       try {
-        const parsedPackageJson = JSON.parse(fs52.readFileSync(path74.join(projectDir, "package.json"), "utf8"));
+        const parsedPackageJson = JSON.parse(fs50.readFileSync(path74.join(projectDir, "package.json"), "utf8"));
         const scripts = parsedPackageJson.scripts && typeof parsedPackageJson.scripts === "object" && !Array.isArray(parsedPackageJson.scripts) ? parsedPackageJson.scripts : {};
         availableScripts = Object.entries(scripts).filter(([, value2]) => typeof value2 === "string").map(([scriptName]) => scriptName);
       } catch {
@@ -295008,7 +294952,7 @@ async function simulateWorkspaceAddDryRun({
 // package.json
 var package_default2 = {
   name: "wp-typia",
-  version: "0.22.6",
+  version: "0.22.7",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -295078,7 +295022,7 @@ var package_default2 = {
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/project-tools": "0.22.6",
+    "@wp-typia/project-tools": "0.22.7",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -296643,7 +296587,7 @@ var init_default = initCommand;
 init_cli_diagnostics();
 
 // src/mcp.ts
-import fs53 from "fs/promises";
+import fs51 from "fs/promises";
 import path75 from "path";
 
 // ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
@@ -297173,7 +297117,7 @@ function isToolGroup(value2) {
 }
 async function readSchemaSource(cwd, source) {
   const schemaPath = path75.resolve(cwd, source.path);
-  const raw = await fs53.readFile(schemaPath, "utf8");
+  const raw = await fs51.readFile(schemaPath, "utf8");
   const parsed = JSON.parse(raw);
   if (isToolGroup(parsed)) {
     return parsed;
@@ -297211,8 +297155,8 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path75.join(cwd, "
       throw convert.error;
     }
   }
-  await fs53.mkdir(outputDir, { recursive: true });
-  await fs53.writeFile(path75.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
+  await fs51.mkdir(outputDir, { recursive: true });
+  await fs51.writeFile(path75.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
 `, "utf8");
   return {
     commandCount: registry2.reduce((count, group) => count + group.tools.length, 0),
@@ -297531,4 +297475,4 @@ export {
   cli
 };
 
-//# debugId=E20EEF6081D4A11464756E2164756E21
+//# debugId=2EE58DC8E78CAD3164756E2164756E21