wp-typia 0.22.0 → 0.22.1

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

@@ -36061,6 +36061,10 @@ function toSnakeCase(input) {
 function toPascalCase(input) {
   return toKebabCase(input).split("-").filter(Boolean).map(capitalizeSegment).join("");
 }
+function toCamelCase(input) {
+  const pascalCase = toPascalCase(input);
+  return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
+}
 function toSegmentPascalCase(input) {
   return input.replace(/[^A-Za-z0-9]+/g, " ").trim().split(/\s+/).filter(Boolean).map(capitalizeSegment).join("");
 }
@@ -213271,6 +213275,16 @@ function readPackageManifest(location) {
   }
   return JSON.parse(location.source);
 }
+function tryReadPackageManifest(location) {
+  if (!location) {
+    return null;
+  }
+  try {
+    return readPackageManifest(location);
+  } catch {
+    return null;
+  }
+}
 function resolveInstalledPackageManifestLocation(packageName) {
   try {
     return resolvePackageManifestLocation(require2.resolve(`${packageName}/package.json`));
@@ -213288,6 +213302,13 @@ function resolveInstalledPackageManifestLocation(packageName) {
 function composePackageVersionsCacheKey(locations) {
   return locations.map((location) => location.cacheKey).join("|");
 }
+function resolveManagedPackageVersionRange(options) {
+  const workspaceManifestLocation = options.workspacePackageDirName ? resolvePackageManifestLocation(path31.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", options.workspacePackageDirName, "package.json")) : null;
+  const installedManifestLocation = resolveInstalledPackageManifestLocation(options.packageName);
+  const workspaceManifest = tryReadPackageManifest(workspaceManifestLocation);
+  const installedManifest = tryReadPackageManifest(installedManifestLocation);
+  return normalizeVersionRangeWithFallback(workspaceManifest?.version ?? installedManifest?.version, options.fallback);
+}
 function getPackageVersions() {
   const createManifestLocation = resolvePackageManifestLocation(path31.join(PROJECT_TOOLS_PACKAGE_ROOT, "package.json"));
   const monorepoManifestLocation = resolvePackageManifestLocation(path31.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", "..", "package.json"));
@@ -226861,7 +226882,7 @@ type InteractivityActionShape = object;
 type InteractivityCallbackShape = object;
 type InteractivityContextShape = object;
 type InteractivityStateShape = object;
-type InteractivityCallable = Function;
+type InteractivityCallable = CallableFunction;
 type InteractivityKey<T extends object> = Extract<keyof T, string>;
 type InteractivityMethodKey<T extends object> = {
   [Key in InteractivityKey<T>]: T[Key] extends InteractivityCallable ? Key : never;
@@ -226964,7 +226985,7 @@ export function defineInteractivityStore<
   };
 }
 
-type InteractivityActionHandler = Function;
+type InteractivityActionHandler = CallableFunction;
 
 export interface {{pascalCase}}StoreActions {
   handleClick: InteractivityActionHandler;
@@ -230697,32 +230718,30 @@ var init_cli_add_block = __esm(() => {
   WORKSPACE_INSTALL_MARKERS = ["node_modules", ".pnp.cjs", ".pnp.loader.mjs"];
 });
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
-import fs42 from "fs";
-import { promises as fsp18 } from "fs";
-import { createRequire as createRequire4 } from "module";
-import path51 from "path";
-function toCamelCase(input) {
-  const pascalCase = toPascalCase(input);
-  return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-types.ts
+function isAdminViewCoreDataSource(source) {
+  return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
 }
-function normalizeVersionRange2(value2, fallback) {
-  const trimmed = value2?.trim();
-  if (!trimmed || trimmed.startsWith("workspace:")) {
-    return fallback;
-  }
-  return /^[~^<>=]/u.test(trimmed) ? trimmed : `^${trimmed}`;
+function isAdminViewRestResourceSource(source) {
+  return source?.kind === ADMIN_VIEW_REST_SOURCE_KIND;
 }
-function readPackageManifest2(packageJsonPath) {
-  try {
-    return JSON.parse(fs42.readFileSync(packageJsonPath, "utf8"));
-  } catch {
-    return;
+function formatAdminViewSourceLocator(source) {
+  if (isAdminViewCoreDataSource(source)) {
+    return `${source.kind}:${source.entityKind}/${source.entityName}`;
   }
+  return `${source.kind}:${source.slug}`;
 }
-function readPackageManifestVersion(packageJsonPath) {
-  return readPackageManifest2(packageJsonPath)?.version;
-}
+var ADMIN_VIEW_REST_SOURCE_KIND = "rest-resource", ADMIN_VIEW_CORE_DATA_SOURCE_KIND = "core-data", ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS, ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN, ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN, ADMIN_VIEW_SOURCE_USAGE = "wp-typia add admin-view <name> --source <rest-resource:slug|core-data:kind/name>", ADMIN_VIEWS_SCRIPT = "build/admin-views/index.js", ADMIN_VIEWS_ASSET = "build/admin-views/index.asset.php", ADMIN_VIEWS_STYLE = "build/admin-views/style-index.css", ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css", ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php", ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = "WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS", ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false;
+var init_cli_add_workspace_admin_view_types = __esm(() => {
+  ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS = [
+    "postType",
+    "taxonomy"
+  ];
+  ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
+  ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/u;
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-source.ts
 function isAdminViewUnpublishedDataViewsOverrideEnabled() {
   return process.env[ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV]?.trim() === "1";
 }
@@ -230732,36 +230751,6 @@ function assertAdminViewPackageAvailability() {
   }
   throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, "`wp-typia add admin-view` is temporarily unavailable because `@wp-typia/dataviews` is not published to npm for public installs yet.");
 }
-function detectJsonIndent(source) {
-  const indentMatch = /\n([ \t]+)"/u.exec(source);
-  return indentMatch?.[1] ?? 2;
-}
-function resolvePackageVersionRange(packageName, fallback, workspacePackageDirName) {
-  if (workspacePackageDirName) {
-    const workspaceVersion = readPackageManifestVersion(path51.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", workspacePackageDirName, "package.json"));
-    if (workspaceVersion) {
-      return normalizeVersionRange2(workspaceVersion, fallback);
-    }
-  }
-  try {
-    return normalizeVersionRange2(readPackageManifestVersion(require4.resolve(`${packageName}/package.json`)), fallback);
-  } catch {
-    return fallback;
-  }
-}
-function getAdminViewRelativeModuleSpecifier(adminViewSlug, workspaceFile) {
-  const adminViewDir = `src/admin-views/${adminViewSlug}`;
-  const normalizedFile = workspaceFile.replace(/\\/gu, "/");
-  const modulePath = normalizedFile.replace(/\.[cm]?[jt]sx?$/u, "");
-  const relativeModulePath = path51.posix.relative(adminViewDir, modulePath);
-  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
-}
-function isAdminViewCoreDataSource(source) {
-  return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
-}
-function isAdminViewRestResourceSource(source) {
-  return source?.kind === ADMIN_VIEW_REST_SOURCE_KIND;
-}
 function assertValidCoreDataEntitySegment(label, value2) {
   const trimmed = value2.trim();
   if (!trimmed) {
@@ -230789,12 +230778,6 @@ function assertValidCoreDataEntityKind(value2) {
   }
   return normalized;
 }
-function formatAdminViewSourceLocator(source) {
-  if (isAdminViewCoreDataSource(source)) {
-    return `${source.kind}:${source.entityKind}/${source.entityName}`;
-  }
-  return `${source.kind}:${source.slug}`;
-}
 function parseAdminViewSource(source) {
   const trimmed = source?.trim();
   if (!trimmed) {
@@ -230838,6 +230821,24 @@ function resolveRestResourceSource(restResources, source) {
   }
   return restResource;
 }
+function resolveAdminViewCoreDataSource(source) {
+  return isAdminViewCoreDataSource(source) ? source : undefined;
+}
+var init_cli_add_workspace_admin_view_source = __esm(() => {
+  init_cli_add_shared();
+  init_cli_diagnostics();
+  init_cli_add_workspace_admin_view_types();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates.ts
+import path51 from "path";
+function getAdminViewRelativeModuleSpecifier(adminViewSlug, workspaceFile) {
+  const adminViewDir = `src/admin-views/${adminViewSlug}`;
+  const normalizedFile = workspaceFile.replace(/\\/gu, "/");
+  const modulePath = normalizedFile.replace(/\.[cm]?[jt]sx?$/u, "");
+  const relativeModulePath = path51.posix.relative(adminViewDir, modulePath);
+  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
+}
 function buildAdminViewConfigEntry(adminViewSlug, source) {
   return [
     "\t{",
@@ -230970,8 +230971,8 @@ function buildAdminViewConfigSource(adminViewSlug, textDomain, source, restResou
   const camelName = toCamelCase(adminViewSlug);
   const itemTypeName = `${pascalName}AdminViewItem`;
   const dataViewsName = `${camelName}AdminDataViews`;
-  const isCoreDataSource = source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
-  const isTaxonomyCoreDataSource = source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND && source.entityKind === "taxonomy";
+  const isCoreDataSource = isAdminViewCoreDataSource(source);
+  const isTaxonomyCoreDataSource = isAdminViewCoreDataSource(source) && source.entityKind === "taxonomy";
   const defaultViewFields = restResource ? "['id']" : isTaxonomyCoreDataSource ? "['name', 'slug', 'count']" : isCoreDataSource ? "['title', 'slug', 'status', 'updatedAt']" : "['title', 'status', 'updatedAt']";
   const searchEnabled = restResource ? "false" : "true";
   const titleFieldSource = restResource ? "" : isTaxonomyCoreDataSource ? `	titleField: 'name',
@@ -231787,12 +231788,38 @@ add_action( 'admin_menu', '${registerFunctionName}' );
 add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
 `;
 }
+var init_cli_add_workspace_admin_view_templates = __esm(() => {
+  init_cli_add_shared();
+  init_cli_add_workspace_admin_view_types();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
+import fs42 from "fs";
+import { promises as fsp18 } from "fs";
+import path52 from "path";
+function detectJsonIndent(source) {
+  const indentMatch = /\n([ \t]+)"/u.exec(source);
+  return indentMatch?.[1] ?? 2;
+}
 async function ensureAdminViewPackageDependencies(workspace, adminViewSource) {
-  const packageJsonPath = path51.join(workspace.projectDir, "package.json");
-  const wpTypiaDataViewsVersion = resolvePackageVersionRange("@wp-typia/dataviews", DEFAULT_WP_TYPIA_DATAVIEWS_VERSION, "wp-typia-dataviews");
-  const wordpressDataViewsVersion = resolvePackageVersionRange("@wordpress/dataviews", DEFAULT_WORDPRESS_DATAVIEWS_VERSION);
-  const wordpressCoreDataVersion = resolvePackageVersionRange("@wordpress/core-data", DEFAULT_WORDPRESS_CORE_DATA_VERSION);
-  const wordpressDataVersion = resolvePackageVersionRange("@wordpress/data", DEFAULT_WORDPRESS_DATA_VERSION);
+  const packageJsonPath = path52.join(workspace.projectDir, "package.json");
+  const wpTypiaDataViewsVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WP_TYPIA_DATAVIEWS_VERSION,
+    packageName: "@wp-typia/dataviews",
+    workspacePackageDirName: "wp-typia-dataviews"
+  });
+  const wordpressDataViewsVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WORDPRESS_DATAVIEWS_VERSION,
+    packageName: "@wordpress/dataviews"
+  });
+  const wordpressCoreDataVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WORDPRESS_CORE_DATA_VERSION,
+    packageName: "@wordpress/core-data"
+  });
+  const wordpressDataVersion = resolveManagedPackageVersionRange({
+    fallback: DEFAULT_WORDPRESS_DATA_VERSION,
+    packageName: "@wordpress/data"
+  });
   await patchFile(packageJsonPath, (source) => {
     const packageJson = JSON.parse(source);
     const coreDataDependencies = isAdminViewCoreDataSource(adminViewSource) ? {
@@ -231823,6 +231850,7 @@ async function ensureAdminViewBootstrapAnchors(workspace) {
     let nextSource = source;
     const loadFunctionName = `${workspace.workspace.phpPrefix}_load_admin_views`;
     const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
+    const loadHookPattern = new RegExp(`add_action\\(\\s*['"]plugins_loaded['"]\\s*,\\s*['"]${loadFunctionName}['"]\\s*\\)\\s*;`, "u");
     const loadFunction = `
 
 function ${loadFunctionName}() {
@@ -231867,19 +231895,19 @@ ${snippet}
       if (!functionSource.includes(ADMIN_VIEWS_PHP_GLOB)) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, loadFunctionName, loadFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path51.basename(bootstrapPath)} for ${loadFunctionName}.`);
+          throw new Error(`Unable to repair ${path52.basename(bootstrapPath)} for ${loadFunctionName}.`);
         }
         nextSource = replacedSource;
       }
     }
-    if (!nextSource.includes(loadHook)) {
+    if (!loadHookPattern.test(nextSource)) {
       appendPhpSnippet(loadHook);
     }
     return nextSource;
   });
 }
 async function ensureAdminViewBuildScriptAnchors(workspace) {
-  const buildScriptPath = path51.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/admin-views\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -231903,11 +231931,11 @@ async function ensureAdminViewBuildScriptAnchors(workspace) {
     if (nextSource !== source) {
       return nextSource;
     }
-    throw new Error(`Unable to update ${path51.relative(workspace.projectDir, buildScriptPath)} for admin view shared entries.`);
+    throw new Error(`Unable to update ${path52.relative(workspace.projectDir, buildScriptPath)} for admin view shared entries.`);
   });
 }
 async function ensureAdminViewWebpackAnchors(workspace) {
-  const webpackConfigPath = path51.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]admin-views\/index['"]/u.test(source)) {
       return source;
@@ -231948,17 +231976,17 @@ async function ensureAdminViewWebpackAnchors(workspace) {
 	}`;
     nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path51.relative(workspace.projectDir, webpackConfigPath)} for admin view shared entries.`);
+      throw new Error(`Unable to update ${path52.relative(workspace.projectDir, webpackConfigPath)} for admin view shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveAdminViewRegistryPath(projectDir) {
-  const adminViewsDir = path51.join(projectDir, "src", "admin-views");
+  const adminViewsDir = path52.join(projectDir, "src", "admin-views");
   return [
-    path51.join(adminViewsDir, "index.ts"),
-    path51.join(adminViewsDir, "index.js")
-  ].find((candidatePath) => fs42.existsSync(candidatePath)) ?? path51.join(adminViewsDir, "index.ts");
+    path52.join(adminViewsDir, "index.ts"),
+    path52.join(adminViewsDir, "index.js")
+  ].find((candidatePath) => fs42.existsSync(candidatePath)) ?? path52.join(adminViewsDir, "index.ts");
 }
 function readAdminViewRegistrySlugs(registryPath) {
   if (!fs42.existsSync(registryPath)) {
@@ -231968,35 +231996,34 @@ function readAdminViewRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeAdminViewRegistry(projectDir, adminViewSlug) {
-  const adminViewsDir = path51.join(projectDir, "src", "admin-views");
+  const adminViewsDir = path52.join(projectDir, "src", "admin-views");
   const registryPath = resolveAdminViewRegistryPath(projectDir);
   await fsp18.mkdir(adminViewsDir, { recursive: true });
   const existingAdminViewSlugs = readWorkspaceInventory(projectDir).adminViews.map((entry) => entry.slug);
   const existingRegistrySlugs = readAdminViewRegistrySlugs(registryPath);
-  const nextAdminViewSlugs = Array.from(new Set([...existingAdminViewSlugs, ...existingRegistrySlugs, adminViewSlug])).sort();
+  const nextAdminViewSlugs = Array.from(new Set([
+    ...existingAdminViewSlugs,
+    ...existingRegistrySlugs,
+    adminViewSlug
+  ])).sort();
   await fsp18.writeFile(registryPath, buildAdminViewRegistrySource(nextAdminViewSlugs), "utf8");
 }
-async function runAddAdminViewCommand({
-  adminViewName,
-  cwd = process.cwd(),
-  source
-}) {
-  const workspace = resolveWorkspaceProject(cwd);
-  assertAdminViewPackageAvailability();
-  const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]");
-  const parsedSource = parseAdminViewSource(source);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  const restResource = resolveRestResourceSource(inventory.restResources, parsedSource);
-  const coreDataSource = isAdminViewCoreDataSource(parsedSource) ? parsedSource : undefined;
-  assertAdminViewDoesNotExist(workspace.projectDir, adminViewSlug, inventory);
-  const blockConfigPath = path51.join(workspace.projectDir, "scripts", "block-config.ts");
+async function scaffoldAdminViewWorkspace(options) {
+  const {
+    adminViewSlug,
+    coreDataSource,
+    parsedSource,
+    restResource,
+    workspace
+  } = options;
+  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path51.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path51.join(workspace.projectDir, "package.json");
-  const webpackConfigPath = path51.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path52.join(workspace.projectDir, "package.json");
+  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
   const adminViewsIndexPath = resolveAdminViewRegistryPath(workspace.projectDir);
-  const adminViewDir = path51.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
-  const adminViewPhpPath = path51.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
+  const adminViewDir = path52.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
+  const adminViewPhpPath = path52.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       adminViewsIndexPath,
@@ -232011,50 +232038,78 @@ async function runAddAdminViewCommand({
   };
   try {
     await fsp18.mkdir(adminViewDir, { recursive: true });
-    await fsp18.mkdir(path51.dirname(adminViewPhpPath), { recursive: true });
+    await fsp18.mkdir(path52.dirname(adminViewPhpPath), { recursive: true });
     await ensureAdminViewPackageDependencies(workspace, parsedSource);
     await ensureAdminViewBootstrapAnchors(workspace);
     await ensureAdminViewBuildScriptAnchors(workspace);
     await ensureAdminViewWebpackAnchors(workspace);
-    await fsp18.writeFile(path51.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
-    await fsp18.writeFile(path51.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
+    await fsp18.writeFile(path52.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
     await fsp18.writeFile(adminViewPhpPath, buildAdminViewPhpSource(adminViewSlug, workspace), "utf8");
     await writeAdminViewRegistry(workspace.projectDir, adminViewSlug);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
-      adminViewEntries: [buildAdminViewConfigEntry(adminViewSlug, parsedSource)]
+      adminViewEntries: [
+        buildAdminViewConfigEntry(adminViewSlug, parsedSource)
+      ]
     });
-    return {
-      adminViewSlug,
-      projectDir: workspace.projectDir,
-      source: parsedSource ? formatAdminViewSourceLocator(parsedSource) : undefined
-    };
   } catch (error48) {
     await rollbackWorkspaceMutation(mutationSnapshot);
     throw error48;
   }
 }
-var ADMIN_VIEW_REST_SOURCE_KIND = "rest-resource", ADMIN_VIEW_CORE_DATA_SOURCE_KIND = "core-data", ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS, ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN, ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN, ADMIN_VIEW_SOURCE_USAGE = "wp-typia add admin-view <name> --source <rest-resource:slug|core-data:kind/name>", ADMIN_VIEWS_SCRIPT = "build/admin-views/index.js", ADMIN_VIEWS_ASSET = "build/admin-views/index.asset.php", ADMIN_VIEWS_STYLE = "build/admin-views/style-index.css", ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css", ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php", ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = "WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS", ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false, require4;
-var init_cli_add_workspace_admin_view = __esm(() => {
-  init_workspace_project();
+var init_cli_add_workspace_admin_view_scaffold = __esm(() => {
   init_workspace_inventory();
-  init_template_registry();
+  init_cli_add_workspace_admin_view_templates();
+  init_cli_add_workspace_admin_view_types();
   init_cli_add_shared();
-  init_cli_diagnostics();
   init_package_versions();
-  ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS = ["postType", "taxonomy"];
-  ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
-  ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/u;
-  require4 = createRequire4(import.meta.url);
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
+async function runAddAdminViewCommand({
+  adminViewName,
+  cwd = process.cwd(),
+  source
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  assertAdminViewPackageAvailability();
+  const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), ADD_ADMIN_VIEW_USAGE);
+  const parsedSource = parseAdminViewSource(source);
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const restResource = resolveRestResourceSource(inventory.restResources, parsedSource);
+  const coreDataSource = resolveAdminViewCoreDataSource(parsedSource);
+  assertAdminViewDoesNotExist(workspace.projectDir, adminViewSlug, inventory);
+  await scaffoldAdminViewWorkspace({
+    adminViewSlug,
+    coreDataSource,
+    parsedSource,
+    restResource,
+    workspace
+  });
+  return {
+    adminViewSlug,
+    projectDir: workspace.projectDir,
+    source: parsedSource ? formatAdminViewSourceLocator(parsedSource) : undefined
+  };
+}
+var ADD_ADMIN_VIEW_USAGE = "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]";
+var init_cli_add_workspace_admin_view = __esm(() => {
+  init_cli_add_shared();
+  init_cli_add_workspace_admin_view_source();
+  init_cli_add_workspace_admin_view_scaffold();
+  init_cli_add_workspace_admin_view_types();
+  init_workspace_inventory();
+  init_workspace_project();
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
 import fs43 from "fs";
 import { promises as fsp19 } from "fs";
-import path52 from "path";
+import path53 from "path";
 import {
   syncBlockMetadata as syncBlockMetadata2
 } from "@wp-typia/block-runtime/metadata-core";
@@ -232329,7 +232384,7 @@ async function ensureBindingTargetBlockAttributeType(projectDir, block, target)
   if (!block.attributeTypeName) {
     throw new Error(`Workspace block "${block.slug}" must include attributeTypeName in scripts/block-config.ts before it can receive binding-source targets.`);
   }
-  const typesPath = path52.join(projectDir, block.typesFile);
+  const typesPath = path53.join(projectDir, block.typesFile);
   const source = await fsp19.readFile(typesPath, "utf8");
   const targetInterface = getInterfaceDeclaration(source, block.attributeTypeName);
   if (!targetInterface) {
@@ -232341,10 +232396,10 @@ async function ensureBindingTargetBlockAttributeType(projectDir, block, target)
     await fsp19.writeFile(typesPath, nextSource, "utf8");
   }
   await syncBlockMetadata2({
-    blockJsonFile: path52.join("src", "blocks", block.slug, "block.json"),
-    jsonSchemaFile: path52.join("src", "blocks", block.slug, "typia.schema.json"),
-    manifestFile: path52.join("src", "blocks", block.slug, "typia.manifest.json"),
-    openApiFile: path52.join("src", "blocks", block.slug, "typia.openapi.json"),
+    blockJsonFile: path53.join("src", "blocks", block.slug, "block.json"),
+    jsonSchemaFile: path53.join("src", "blocks", block.slug, "typia.schema.json"),
+    manifestFile: path53.join("src", "blocks", block.slug, "typia.manifest.json"),
+    openApiFile: path53.join("src", "blocks", block.slug, "typia.openapi.json"),
     projectRoot: projectDir,
     sourceTypeName: block.attributeTypeName,
     typesFile: block.typesFile
@@ -232583,7 +232638,7 @@ ${patternFunctions}
       }
     }
     if (!nextSource.includes(patternCategoryFunctionName) || !nextSource.includes(patternRegistrationFunctionName)) {
-      throw new Error(`Unable to inject pattern bootstrap functions into ${path52.basename(bootstrapPath)}.`);
+      throw new Error(`Unable to inject pattern bootstrap functions into ${path53.basename(bootstrapPath)}.`);
     }
     if (!nextSource.includes(patternCategoryHook)) {
       nextSource = `${nextSource.trimEnd()}
@@ -232771,7 +232826,7 @@ ${snippet}
       if (missingReferences.length > 0) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path52.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
+          throw new Error(`Unable to repair ${path53.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
         }
         nextSource = replacedSource;
       }
@@ -232783,7 +232838,7 @@ ${snippet}
   });
 }
 async function ensureEditorPluginBuildScriptAnchors(workspace) {
-  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path53.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/editor-plugins\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -232796,13 +232851,13 @@ async function ensureEditorPluginBuildScriptAnchors(workspace) {
 		'src/editor-plugins/index.js',
 	]`);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path52.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path53.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 async function ensureEditorPluginWebpackAnchors(workspace) {
-  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path53.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]editor-plugins\/index['"]/u.test(source)) {
       return source;
@@ -232830,17 +232885,17 @@ async function ensureEditorPluginWebpackAnchors(workspace) {
 	}`;
     const nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path52.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path53.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveBindingSourceRegistryPath(projectDir) {
-  const bindingsDir = path52.join(projectDir, "src", "bindings");
-  return [path52.join(bindingsDir, "index.ts"), path52.join(bindingsDir, "index.js")].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path52.join(bindingsDir, "index.ts");
+  const bindingsDir = path53.join(projectDir, "src", "bindings");
+  return [path53.join(bindingsDir, "index.ts"), path53.join(bindingsDir, "index.js")].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path53.join(bindingsDir, "index.ts");
 }
 async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
-  const bindingsDir = path52.join(projectDir, "src", "bindings");
+  const bindingsDir = path53.join(projectDir, "src", "bindings");
   const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
   await fsp19.mkdir(bindingsDir, { recursive: true });
   const existingBindingSourceSlugs = fs43.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -232848,11 +232903,11 @@ async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
   await fsp19.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
 }
 function resolveEditorPluginRegistryPath(projectDir) {
-  const editorPluginsDir = path52.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path53.join(projectDir, "src", "editor-plugins");
   return [
-    path52.join(editorPluginsDir, "index.ts"),
-    path52.join(editorPluginsDir, "index.js")
-  ].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path52.join(editorPluginsDir, "index.ts");
+    path53.join(editorPluginsDir, "index.ts"),
+    path53.join(editorPluginsDir, "index.js")
+  ].find((candidatePath) => fs43.existsSync(candidatePath)) ?? path53.join(editorPluginsDir, "index.ts");
 }
 function readEditorPluginRegistrySlugs(registryPath) {
   if (!fs43.existsSync(registryPath)) {
@@ -232862,7 +232917,7 @@ function readEditorPluginRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
-  const editorPluginsDir = path52.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path53.join(projectDir, "src", "editor-plugins");
   const registryPath = resolveEditorPluginRegistryPath(projectDir);
   await fsp19.mkdir(editorPluginsDir, { recursive: true });
   const existingEditorPluginSlugs = readWorkspaceInventory(projectDir).editorPlugins.map((entry) => entry.slug);
@@ -232880,17 +232935,17 @@ async function runAddEditorPluginCommand({
   const resolvedSlot = assertValidEditorPluginSlot(slot);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertEditorPluginDoesNotExist(workspace.projectDir, editorPluginSlug, inventory);
-  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path52.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path53.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   const editorPluginsIndexPath = resolveEditorPluginRegistryPath(workspace.projectDir);
-  const webpackConfigPath = path52.join(workspace.projectDir, "webpack.config.js");
-  const editorPluginDir = path52.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
-  const entryFilePath = path52.join(editorPluginDir, "index.tsx");
-  const surfaceFilePath = path52.join(editorPluginDir, "Surface.tsx");
-  const dataFilePath = path52.join(editorPluginDir, "data.ts");
-  const typesFilePath = path52.join(editorPluginDir, "types.ts");
-  const styleFilePath = path52.join(editorPluginDir, "style.scss");
+  const webpackConfigPath = path53.join(workspace.projectDir, "webpack.config.js");
+  const editorPluginDir = path53.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
+  const entryFilePath = path53.join(editorPluginDir, "index.tsx");
+  const surfaceFilePath = path53.join(editorPluginDir, "Surface.tsx");
+  const dataFilePath = path53.join(editorPluginDir, "data.ts");
+  const typesFilePath = path53.join(editorPluginDir, "types.ts");
+  const styleFilePath = path53.join(editorPluginDir, "style.scss");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -232936,16 +232991,16 @@ async function runAddPatternCommand({
   const patternSlug = assertValidGeneratedSlug("Pattern name", normalizeBlockSlug(patternName), "wp-typia add pattern <name>");
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertPatternDoesNotExist(workspace.projectDir, patternSlug, inventory);
-  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const patternFilePath = path52.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
+  const patternFilePath = path53.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath]),
     snapshotDirs: [],
     targetPaths: [patternFilePath]
   };
   try {
-    await fsp19.mkdir(path52.dirname(patternFilePath), { recursive: true });
+    await fsp19.mkdir(path53.dirname(patternFilePath), { recursive: true });
     await ensurePatternBootstrapAnchors(workspace);
     await fsp19.writeFile(patternFilePath, buildPatternSource(patternSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -232975,18 +233030,18 @@ async function runAddBindingSourceCommand({
     blockName
   }, workspace.workspace.namespace);
   const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
-  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
-  const bindingSourceDir = path52.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-  const serverFilePath = path52.join(bindingSourceDir, "server.php");
-  const editorFilePath = path52.join(bindingSourceDir, "editor.ts");
-  const blockJsonPath = target ? path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
+  const bindingSourceDir = path53.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
+  const serverFilePath = path53.join(bindingSourceDir, "server.php");
+  const editorFilePath = path53.join(bindingSourceDir, "editor.ts");
+  const blockJsonPath = target ? path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
   const targetGeneratedMetadataPaths = target ? [
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
-    path52.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
+    path53.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
   ] : [];
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -232994,7 +233049,7 @@ async function runAddBindingSourceCommand({
       bootstrapPath,
       bindingsIndexPath,
       ...blockJsonPath ? [blockJsonPath] : [],
-      ...targetBlock ? [path52.join(workspace.projectDir, targetBlock.typesFile)] : [],
+      ...targetBlock ? [path53.join(workspace.projectDir, targetBlock.typesFile)] : [],
       ...targetGeneratedMetadataPaths
     ]),
     snapshotDirs: [],
@@ -233032,7 +233087,7 @@ var init_cli_add_workspace_assets = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-anchors.ts
-import path53 from "path";
+import path54 from "path";
 async function ensureRestResourceBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   await patchFile(bootstrapPath, (source) => {
@@ -233079,7 +233134,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(REST_RESOURCE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path53.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
+        `Unable to patch ${path54.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
         `The existing ${registerFunctionName}() definition does not include ${REST_RESOURCE_SERVER_GLOB}.`,
         "Restore the generated bootstrap shape or wire the REST resource loader manually before retrying."
       ].join(" "));
@@ -233093,7 +233148,7 @@ ${snippet}
 function assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureRestResourceSyncScriptAnchors could not patch ${path53.basename(syncRestScriptPath)}.`,
+      `ensureRestResourceSyncScriptAnchors could not patch ${path54.basename(syncRestScriptPath)}.`,
       `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
       "Restore the generated template or add the REST_RESOURCES wiring manually before retrying."
     ].join(" "));
@@ -233108,7 +233163,7 @@ function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureRestResourceSyncScriptAnchors(workspace) {
-  const syncRestScriptPath = path53.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path54.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = "import { BLOCKS, type WorkspaceBlockConfig } from './block-config';";
@@ -233230,7 +233285,7 @@ var init_cli_add_workspace_rest_anchors = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/rest-resource-artifacts.ts
-import path54 from "path";
+import path55 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest2,
   syncEndpointClient as syncEndpointClient2,
@@ -233366,8 +233421,8 @@ async function syncRestResourceArtifacts({
   const manifest = buildRestResourceEndpointManifest(variables, methods);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas2({
-      jsonSchemaFile: path54.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path54.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path55.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path55.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -233375,7 +233430,7 @@ async function syncRestResourceArtifacts({
   }
   await syncRestOpenApi2({
     manifest,
-    openApiFile: path54.join(outputDir, "api.openapi.json"),
+    openApiFile: path55.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   });
@@ -233777,7 +233832,7 @@ var init_cli_add_workspace_rest_source_emitters = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
 import { promises as fsp20 } from "fs";
-import path55 from "path";
+import path56 from "path";
 function buildRestResourceRouteRegistrations(restResourceSlug, methods, functions) {
   const collectionRoutes = [];
   const itemRoutes = [];
@@ -234207,15 +234262,15 @@ async function runAddRestResourceCommand({
   const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
-  const blockConfigPath = path55.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path56.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const syncRestScriptPath = path55.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const restResourceDir = path55.join(workspace.projectDir, "src", "rest", restResourceSlug);
-  const typesFilePath = path55.join(restResourceDir, "api-types.ts");
-  const validatorsFilePath = path55.join(restResourceDir, "api-validators.ts");
-  const apiFilePath = path55.join(restResourceDir, "api.ts");
-  const dataFilePath = path55.join(restResourceDir, "data.ts");
-  const phpFilePath = path55.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
+  const syncRestScriptPath = path56.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const restResourceDir = path56.join(workspace.projectDir, "src", "rest", restResourceSlug);
+  const typesFilePath = path56.join(restResourceDir, "api-types.ts");
+  const validatorsFilePath = path56.join(restResourceDir, "api-validators.ts");
+  const apiFilePath = path56.join(restResourceDir, "api.ts");
+  const dataFilePath = path56.join(restResourceDir, "data.ts");
+  const phpFilePath = path56.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -234227,7 +234282,7 @@ async function runAddRestResourceCommand({
   };
   try {
     await fsp20.mkdir(restResourceDir, { recursive: true });
-    await fsp20.mkdir(path55.dirname(phpFilePath), { recursive: true });
+    await fsp20.mkdir(path56.dirname(phpFilePath), { recursive: true });
     await ensureRestResourceBootstrapAnchors(workspace);
     await ensureRestResourceSyncScriptAnchors(workspace);
     await fsp20.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
@@ -234279,7 +234334,7 @@ var init_cli_add_workspace_rest = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
 import fs44 from "fs";
 import { promises as fsp21 } from "fs";
-import path56 from "path";
+import path57 from "path";
 import { syncTypeSchemas as syncTypeSchemas3 } from "@wp-typia/block-runtime/metadata-core";
 function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
   if (!existingVersion) {
@@ -234757,8 +234812,8 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `);
 }
 function resolveAbilityRegistryPath(projectDir) {
-  const abilitiesDir = path56.join(projectDir, "src", "abilities");
-  return [path56.join(abilitiesDir, "index.ts"), path56.join(abilitiesDir, "index.js")].find((candidatePath) => fs44.existsSync(candidatePath)) ?? path56.join(abilitiesDir, "index.ts");
+  const abilitiesDir = path57.join(projectDir, "src", "abilities");
+  return [path57.join(abilitiesDir, "index.ts"), path57.join(abilitiesDir, "index.js")].find((candidatePath) => fs44.existsSync(candidatePath)) ?? path57.join(abilitiesDir, "index.ts");
 }
 function readAbilityRegistrySlugs(registryPath) {
   if (!fs44.existsSync(registryPath)) {
@@ -234768,7 +234823,7 @@ function readAbilityRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeAbilityRegistry(projectDir, abilitySlug) {
-  const abilitiesDir = path56.join(projectDir, "src", "abilities");
+  const abilitiesDir = path57.join(projectDir, "src", "abilities");
   const registryPath = resolveAbilityRegistryPath(projectDir);
   await fsp21.mkdir(abilitiesDir, { recursive: true });
   const existingAbilitySlugs = readWorkspaceInventory(projectDir).abilities.map((entry) => entry.slug);
@@ -234900,7 +234955,7 @@ ${snippet}
   });
 }
 async function ensureAbilityPackageScripts(workspace) {
-  const packageJsonPath = path56.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path57.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp21.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
@@ -234920,7 +234975,7 @@ async function ensureAbilityPackageScripts(workspace) {
 `, "utf8");
 }
 async function ensureAbilitySyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path56.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path57.join(workspace.projectDir, "scripts", "sync-project.ts");
   await patchFile(syncProjectScriptPath, (source) => {
     let nextSource = source;
     const syncRestConst = "const syncRestScriptPath = path.join( 'scripts', 'sync-rest-contracts.ts' );";
@@ -234935,7 +234990,7 @@ async function ensureAbilitySyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAbilitiesConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path56.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path57.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest script constant in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-abilities manually before retrying."
         ].join(" "));
@@ -234946,7 +235001,7 @@ ${syncAbilitiesConst}`);
     if (!nextSource.includes("runSyncScript( syncAbilitiesScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path56.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path57.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest invocation block in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-abilities manually before retrying."
         ].join(" "));
@@ -234959,7 +235014,7 @@ ${syncAbilitiesBlock}`);
   });
 }
 async function ensureAbilityBuildScriptAnchors(workspace) {
-  const buildScriptPath = path56.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path57.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     let nextSource = source;
     if (/['"]src\/abilities\/index\.(?:ts|js)['"]/u.test(nextSource)) {
@@ -234969,7 +235024,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     const match3 = nextSource.match(sharedEntriesPattern);
     if (!match3 || !match3[2].includes("src/bindings/index.ts") || !match3[2].includes("src/editor-plugins/index.ts")) {
       throw new Error([
-        `ensureAbilityBuildScriptAnchors could not patch ${path56.basename(buildScriptPath)}.`,
+        `ensureAbilityBuildScriptAnchors could not patch ${path57.basename(buildScriptPath)}.`,
         "Missing the expected shared editor entries array in scripts/build-workspace.mjs.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
@@ -234986,7 +235041,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
   });
 }
 async function ensureAbilityWebpackAnchors(workspace) {
-  const webpackConfigPath = path56.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path57.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]abilities\/index['"]/u.test(source)) {
       return source;
@@ -235017,7 +235072,7 @@ $2`);
     const match3 = source.match(sharedEntriesPattern);
     if (!match3 || !match3[1].includes("bindings/index") || !match3[1].includes("editor-plugins/index")) {
       throw new Error([
-        `ensureAbilityWebpackAnchors could not patch ${path56.basename(webpackConfigPath)}.`,
+        `ensureAbilityWebpackAnchors could not patch ${path57.basename(webpackConfigPath)}.`,
         "Missing the expected shared editor entries block in webpack.config.js.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
@@ -235047,20 +235102,20 @@ async function runAddAbilityCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
-  const blockConfigPath = path56.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path57.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path56.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path56.join(workspace.projectDir, "package.json");
-  const syncAbilitiesScriptPath = path56.join(workspace.projectDir, "scripts", "sync-abilities.ts");
-  const syncProjectScriptPath = path56.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const webpackConfigPath = path56.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path57.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path57.join(workspace.projectDir, "package.json");
+  const syncAbilitiesScriptPath = path57.join(workspace.projectDir, "scripts", "sync-abilities.ts");
+  const syncProjectScriptPath = path57.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const webpackConfigPath = path57.join(workspace.projectDir, "webpack.config.js");
   const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
-  const abilityDir = path56.join(workspace.projectDir, "src", "abilities", abilitySlug);
-  const configFilePath = path56.join(abilityDir, "ability.config.json");
-  const typesFilePath = path56.join(abilityDir, "types.ts");
-  const dataFilePath = path56.join(abilityDir, "data.ts");
-  const clientFilePath = path56.join(abilityDir, "client.ts");
-  const phpFilePath = path56.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
+  const abilityDir = path57.join(workspace.projectDir, "src", "abilities", abilitySlug);
+  const configFilePath = path57.join(abilityDir, "ability.config.json");
+  const typesFilePath = path57.join(abilityDir, "types.ts");
+  const dataFilePath = path57.join(abilityDir, "data.ts");
+  const clientFilePath = path57.join(abilityDir, "client.ts");
+  const phpFilePath = path57.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -235077,7 +235132,7 @@ async function runAddAbilityCommand({
   };
   try {
     await fsp21.mkdir(abilityDir, { recursive: true });
-    await fsp21.mkdir(path56.dirname(phpFilePath), { recursive: true });
+    await fsp21.mkdir(path57.dirname(phpFilePath), { recursive: true });
     await ensureAbilityBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     await ensureAbilityPackageScripts(workspace);
@@ -235155,7 +235210,7 @@ var init_ai_artifacts = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/ai-feature-artifacts.ts
 import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path57 from "path";
+import path58 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest3,
   syncEndpointClient as syncEndpointClient3,
@@ -235168,7 +235223,7 @@ function normalizeGeneratedArtifactContent(content) {
 }
 async function reconcileGeneratedArtifact(options) {
   if (!options.check) {
-    await mkdir3(path57.dirname(options.filePath), {
+    await mkdir3(path58.dirname(options.filePath), {
       recursive: true
     });
     await writeFile5(options.filePath, options.content, "utf8");
@@ -235240,8 +235295,8 @@ async function syncAiFeatureRestArtifacts({
   const manifest = buildAiFeatureEndpointManifest(variables);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas4({
-      jsonSchemaFile: path57.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path57.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path58.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path58.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -235249,7 +235304,7 @@ async function syncAiFeatureRestArtifacts({
   }
   await syncRestOpenApi3({
     manifest,
-    openApiFile: path57.join(outputDir, "api.openapi.json"),
+    openApiFile: path58.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   }, executionOptions);
@@ -235267,19 +235322,19 @@ async function syncAiFeatureSchemaArtifact({
   outputDir,
   projectDir
 }) {
-  const sourceSchemaPath = path57.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
+  const sourceSchemaPath = path58.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
   const responseSchema = assertJsonObject(JSON.parse(await readFile5(sourceSchemaPath, "utf8")), sourceSchemaPath);
   const aiSchema = projectWordPressAiSchema(responseSchema);
   await reconcileGeneratedArtifact({
     check: check2,
     content: `${JSON.stringify(aiSchema, null, 2)}
 `,
-    filePath: path57.join(projectDir, aiSchemaFile),
+    filePath: path58.join(projectDir, aiSchemaFile),
     label: "AI feature schema"
   });
   return {
     aiSchema,
-    aiSchemaPath: path57.join(projectDir, aiSchemaFile),
+    aiSchemaPath: path58.join(projectDir, aiSchemaFile),
     check: check2,
     sourceSchemaPath
   };
@@ -235611,7 +235666,7 @@ var init_cli_add_workspace_ai_source_emitters = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-anchors.ts
 import { promises as fsp22 } from "fs";
-import path58 from "path";
+import path59 from "path";
 async function ensureAiFeatureBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   await patchFile(bootstrapPath, (source) => {
@@ -235658,7 +235713,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(AI_FEATURE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path58.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
+        `Unable to patch ${path59.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
         `The existing ${registerFunctionName}() definition does not include ${AI_FEATURE_SERVER_GLOB}.`,
         "Restore the generated bootstrap shape or wire the AI feature loader manually before retrying."
       ].join(" "));
@@ -235670,7 +235725,7 @@ ${snippet}
   });
 }
 async function ensureAiFeaturePackageScripts(workspace) {
-  const packageJsonPath = path58.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path59.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp22.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
@@ -235698,7 +235753,7 @@ async function ensureAiFeaturePackageScripts(workspace) {
   };
 }
 async function ensureAiFeatureSyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path58.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path59.join(workspace.projectDir, "scripts", "sync-project.ts");
   await patchFile(syncProjectScriptPath, (source) => {
     let nextSource = source;
     const syncRestConst = "const syncRestScriptPath = path.join( 'scripts', 'sync-rest-contracts.ts' );";
@@ -235713,7 +235768,7 @@ async function ensureAiFeatureSyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAiConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path58.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path59.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest script constant in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-ai manually before retrying."
         ].join(" "));
@@ -235724,7 +235779,7 @@ ${syncAiConst}`);
     if (!nextSource.includes("runSyncScript( syncAiScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path58.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path59.basename(syncProjectScriptPath)}.`,
           "Missing the expected sync-rest invocation block in scripts/sync-project.ts.",
           "Restore the generated template or wire sync-ai manually before retrying."
         ].join(" "));
@@ -235739,7 +235794,7 @@ ${syncAiBlock}`);
 function assertSyncRestAnchor2(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureAiFeatureSyncRestAnchors could not patch ${path58.basename(syncRestScriptPath)}.`,
+      `ensureAiFeatureSyncRestAnchors could not patch ${path59.basename(syncRestScriptPath)}.`,
       `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
       "Restore the generated template or add the AI feature wiring manually before retrying."
     ].join(" "));
@@ -235754,7 +235809,7 @@ function replaceRequiredSyncRestSource2(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureAiFeatureSyncRestAnchors(workspace) {
-  const syncRestScriptPath = path58.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path59.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = [
@@ -235889,7 +235944,7 @@ var init_cli_add_workspace_ai_anchors = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
 import { promises as fsp23 } from "fs";
-import path59 from "path";
+import path60 from "path";
 function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
   const aiFeatureTitle = toTitleCase(aiFeatureSlug);
   const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
@@ -236278,18 +236333,18 @@ async function runAddAiFeatureCommand({
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
-  const blockConfigPath = path59.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const packageJsonPath = path59.join(workspace.projectDir, "package.json");
-  const syncAiScriptPath = path59.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
-  const syncProjectScriptPath = path59.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const syncRestScriptPath = path59.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const aiFeatureDir = path59.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
-  const typesFilePath = path59.join(aiFeatureDir, "api-types.ts");
-  const validatorsFilePath = path59.join(aiFeatureDir, "api-validators.ts");
-  const apiFilePath = path59.join(aiFeatureDir, "api.ts");
-  const dataFilePath = path59.join(aiFeatureDir, "data.ts");
-  const phpFilePath = path59.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
+  const packageJsonPath = path60.join(workspace.projectDir, "package.json");
+  const syncAiScriptPath = path60.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
+  const syncProjectScriptPath = path60.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncRestScriptPath = path60.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const aiFeatureDir = path60.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
+  const typesFilePath = path60.join(aiFeatureDir, "api-types.ts");
+  const validatorsFilePath = path60.join(aiFeatureDir, "api-validators.ts");
+  const apiFilePath = path60.join(aiFeatureDir, "api.ts");
+  const dataFilePath = path60.join(aiFeatureDir, "data.ts");
+  const phpFilePath = path60.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -236304,7 +236359,7 @@ async function runAddAiFeatureCommand({
   };
   try {
     await fsp23.mkdir(aiFeatureDir, { recursive: true });
-    await fsp23.mkdir(path59.dirname(phpFilePath), { recursive: true });
+    await fsp23.mkdir(path60.dirname(phpFilePath), { recursive: true });
     await ensureAiFeatureBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
@@ -236319,7 +236374,7 @@ async function runAddAiFeatureCommand({
     const pascalCase = toPascalCase(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
-      outputDir: path59.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path60.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir,
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
@@ -236332,7 +236387,7 @@ async function runAddAiFeatureCommand({
     });
     await syncAiFeatureSchemaArtifact({
       aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
-      outputDir: path59.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path60.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -236368,7 +236423,7 @@ var init_cli_add_workspace_ai = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
 import fs45 from "fs";
 import { promises as fsp24 } from "fs";
-import path60 from "path";
+import path61 from "path";
 function maskSourceSegment(segment) {
   return segment.replace(/[^\n\r]/gu, " ");
 }
@@ -236752,7 +236807,7 @@ ${VARIATIONS_CALL_LINE}
       }
     }
     if (!hasExecutablePattern(nextSource, VARIATIONS_CALL_PATTERN)) {
-      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path60.basename(blockIndexPath)}.`);
+      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path61.basename(blockIndexPath)}.`);
     }
     return nextSource;
   });
@@ -236782,7 +236837,7 @@ ${BLOCK_STYLES_CALL_LINE}
       }
     }
     if (!hasExecutablePattern(nextSource, BLOCK_STYLES_CALL_PATTERN)) {
-      throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path60.basename(blockIndexPath)}.`);
+      throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path61.basename(blockIndexPath)}.`);
     }
     return nextSource;
   });
@@ -236799,7 +236854,7 @@ ${nextSource}`;
         SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN
       ]);
       if (!callRange) {
-        throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path60.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
+        throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path61.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
       }
       nextSource = [
         nextSource.slice(0, callRange.start),
@@ -236812,42 +236867,42 @@ ${nextSource}`;
   });
 }
 async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
-  const variationsDir = path60.join(projectDir, "src", "blocks", blockSlug, "variations");
-  const variationsIndexPath = path60.join(variationsDir, "index.ts");
+  const variationsDir = path61.join(projectDir, "src", "blocks", blockSlug, "variations");
+  const variationsIndexPath = path61.join(variationsDir, "index.ts");
   await fsp24.mkdir(variationsDir, { recursive: true });
   const existingVariationSlugs = fs45.readdirSync(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 fsp24.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
 async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
-  const stylesDir = path60.join(projectDir, "src", "blocks", blockSlug, "styles");
-  const stylesIndexPath = path60.join(stylesDir, "index.ts");
+  const stylesDir = path61.join(projectDir, "src", "blocks", blockSlug, "styles");
+  const stylesIndexPath = path61.join(stylesDir, "index.ts");
   await fsp24.mkdir(stylesDir, { recursive: true });
   const existingStyleSlugs = fs45.readdirSync(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 fsp24.writeFile(stylesIndexPath, buildBlockStyleIndexSource(nextStyleSlugs), "utf8");
 }
 async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug) {
-  const transformsDir = path60.join(projectDir, "src", "blocks", blockSlug, "transforms");
-  const transformsIndexPath = path60.join(transformsDir, "index.ts");
+  const transformsDir = path61.join(projectDir, "src", "blocks", blockSlug, "transforms");
+  const transformsIndexPath = path61.join(transformsDir, "index.ts");
   await fsp24.mkdir(transformsDir, { recursive: true });
   const existingTransformSlugs = fs45.readdirSync(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 fsp24.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
 function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  const stylePath = path60.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
+  const stylePath = path61.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
   if (fs45.existsSync(stylePath)) {
-    throw new Error(`A block style already exists at ${path60.relative(projectDir, stylePath)}. Choose a different name.`);
+    throw new Error(`A block style already exists at ${path61.relative(projectDir, stylePath)}. Choose a different name.`);
   }
   if (inventory.blockStyles.some((entry) => entry.block === blockSlug && entry.slug === styleSlug)) {
     throw new Error(`A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`);
   }
 }
 function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-  const transformPath = path60.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
+  const transformPath = path61.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
   if (fs45.existsSync(transformPath)) {
-    throw new Error(`A block transform already exists at ${path60.relative(projectDir, transformPath)}. Choose a different name.`);
+    throw new Error(`A block transform already exists at ${path61.relative(projectDir, transformPath)}. Choose a different name.`);
   }
   if (inventory.blockTransforms.some((entry) => entry.block === blockSlug && entry.slug === transformSlug)) {
     throw new Error(`A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`);
@@ -236893,11 +236948,11 @@ async function runAddVariationCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
-  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const variationsDir = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
-  const variationFilePath = path60.join(variationsDir, `${variationSlug}.ts`);
-  const variationsIndexPath = path60.join(variationsDir, "index.ts");
+  const blockConfigPath = path61.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const variationsDir = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
+  const variationFilePath = path61.join(variationsDir, `${variationSlug}.ts`);
+  const variationsIndexPath = path61.join(variationsDir, "index.ts");
   const shouldRemoveVariationsDirOnRollback = !fs45.existsSync(variationsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -236940,11 +236995,11 @@ async function runAddBlockStyleCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertBlockStyleDoesNotExist(workspace.projectDir, blockSlug, styleSlug, inventory);
-  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const stylesDir = path60.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
-  const styleFilePath = path60.join(stylesDir, `${styleSlug}.ts`);
-  const stylesIndexPath = path60.join(stylesDir, "index.ts");
+  const blockConfigPath = path61.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const stylesDir = path61.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
+  const styleFilePath = path61.join(stylesDir, `${styleSlug}.ts`);
+  const stylesIndexPath = path61.join(stylesDir, "index.ts");
   const shouldRemoveStylesDirOnRollback = !fs45.existsSync(stylesDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -236989,11 +237044,11 @@ async function runAddBlockTransformCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, target.blockSlug);
   assertBlockTransformDoesNotExist(workspace.projectDir, target.blockSlug, transformSlug, inventory);
-  const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path60.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
-  const transformsDir = path60.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
-  const transformFilePath = path60.join(transformsDir, `${transformSlug}.ts`);
-  const transformsIndexPath = path60.join(transformsDir, "index.ts");
+  const blockConfigPath = path61.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path61.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
+  const transformsDir = path61.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
+  const transformFilePath = path61.join(transformsDir, `${transformSlug}.ts`);
+  const transformsIndexPath = path61.join(transformsDir, "index.ts");
   const shouldRemoveTransformsDirOnRollback = !fs45.existsSync(transformsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -237055,7 +237110,7 @@ async function runAddHookedBlockCommand({
     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 blockJsonRelativePath = path60.relative(workspace.projectDir, blockJsonPath);
+  const blockJsonRelativePath = path61.relative(workspace.projectDir, blockJsonPath);
   const blockHooks = getMutableBlockHooks(blockJson, blockJsonRelativePath);
   if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {
     throw new Error(`${blockJsonRelativePath} already defines a blockHooks entry for "${resolvedAnchorBlockName}".`);
@@ -237133,7 +237188,7 @@ import { execFileSync as execFileSync3 } from "child_process";
 import { access, constants as fsConstants, rm as rm2, writeFile as writeFile6 } from "fs/promises";
 import fs46 from "fs";
 import os5 from "os";
-import path61 from "path";
+import path62 from "path";
 function readCommandVersion(command, args = ["--version"]) {
   try {
     return execFileSync3(command, args, {
@@ -237157,7 +237212,7 @@ async function checkWritableDirectory(directory) {
   }
 }
 async function checkTempDirectory() {
-  const tempFile = path61.join(os5.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+  const tempFile = path62.join(os5.tmpdir(), `wp-typia-${Date.now()}.tmp`);
   try {
     await writeFile6(tempFile, "ok", "utf8");
     await rm2(tempFile, { force: true });
@@ -237174,7 +237229,7 @@ function getTemplateDoctorChecks() {
   for (const template of listTemplates()) {
     if (!isBuiltInTemplateId(template.id)) {
       const templateDirExists = fs46.existsSync(template.templateDir);
-      const hasAssets2 = templateDirExists && fs46.existsSync(path61.join(template.templateDir, "package.json.mustache"));
+      const hasAssets2 = templateDirExists && fs46.existsSync(path62.join(template.templateDir, "package.json.mustache"));
       checks3.push({
         status: !templateDirExists || hasAssets2 ? "pass" : "fail",
         label: `Template ${template.id}`,
@@ -237199,7 +237254,7 @@ function getTemplateDoctorChecks() {
     ])) : getBuiltInTemplateLayerDirs(builtInTemplateId);
     const missingRequiredLayer = layerDirs.some((layerDir) => !fs46.existsSync(layerDir) && !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
     const existingLayerDirs = layerDirs.filter((layerDir) => fs46.existsSync(layerDir));
-    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs46.existsSync(path61.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs46.existsSync(path61.join(layerDir, "src")));
+    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs46.existsSync(path62.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs46.existsSync(path62.join(layerDir, "src")));
     checks3.push({
       status: hasAssets ? "pass" : "fail",
       label: `Template ${template.id}`,
@@ -237230,7 +237285,7 @@ var init_cli_doctor_environment = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace.ts
 import fs47 from "fs";
-import path62 from "path";
+import path63 from "path";
 import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata2 } from "@wp-typia/block-runtime/blocks";
 function createDoctorCheck2(label, status, detail, code) {
   return code ? { code, detail, label, status } : { detail, label, status };
@@ -237300,7 +237355,7 @@ function hasExecutablePattern2(source, pattern) {
   return pattern.test(maskTypeScriptCommentsAndLiterals2(source));
 }
 function normalizePathSeparators(relativePath) {
-  return relativePath.split(path62.sep).join("/");
+  return relativePath.split(path63.sep).join("/");
 }
 function hasRegisteredBlockAsset(value2) {
   if (typeof value2 === "string") {
@@ -237312,8 +237367,8 @@ function hasRegisteredBlockAsset(value2) {
   return false;
 }
 function readWorkspaceBlockIframeMetadata(projectDir, blockSlug) {
-  const blockJsonRelativePath = path62.join("src", "blocks", blockSlug, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   if (!fs47.existsSync(blockJsonPath)) {
     return {
       blockJsonRelativePath,
@@ -237358,14 +237413,14 @@ function isWorkspaceBlockSaveSource(relativePath) {
   return fileName.replace(/\.[^.]+$/u, "").toLowerCase() === "save";
 }
 function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
-  const blockDir = path62.join(projectDir, "src", "blocks", blockSlug);
+  const blockDir = path63.join(projectDir, "src", "blocks", blockSlug);
   if (!fs47.existsSync(blockDir)) {
     return [];
   }
   const sources = [];
   const visitDirectory = (directory) => {
     for (const entry of fs47.readdirSync(directory, { withFileTypes: true })) {
-      const entryPath = path62.join(directory, entry.name);
+      const entryPath = path63.join(directory, entry.name);
       if (entry.isDirectory()) {
         visitDirectory(entryPath);
         continue;
@@ -237373,8 +237428,8 @@ function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
       if (!entry.isFile()) {
         continue;
       }
-      const relativePath = normalizePathSeparators(path62.relative(projectDir, entryPath));
-      const blockRelativePath = path62.relative(blockDir, entryPath);
+      const relativePath = normalizePathSeparators(path63.relative(projectDir, entryPath));
+      const blockRelativePath = path63.relative(blockDir, entryPath);
       if (!isWorkspaceBlockEditorSource(blockRelativePath)) {
         continue;
       }
@@ -237440,7 +237495,7 @@ function getWorkspaceBootstrapRelativePath(packageName) {
   return `${packageBaseName}.php`;
 }
 function checkExistingFiles(projectDir, label, filePaths) {
-  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs47.existsSync(path62.join(projectDir, filePath)));
+  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs47.existsSync(path63.join(projectDir, filePath)));
   return createDoctorCheck2(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
 }
 function checkWorkspacePackageMetadata(workspace, packageJson) {
@@ -237466,24 +237521,24 @@ function checkWorkspacePackageMetadata(workspace, packageJson) {
   if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
     issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
   }
-  if (!fs47.existsSync(path62.join(workspace.projectDir, bootstrapRelativePath))) {
+  if (!fs47.existsSync(path63.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("; "));
 }
 function getWorkspaceBlockRequiredFiles(block) {
-  const blockDir = path62.join("src", "blocks", block.slug);
+  const blockDir = path63.join("src", "blocks", block.slug);
   return Array.from(new Set([
     block.typesFile,
     block.apiTypesFile,
     block.openApiFile,
-    path62.join(blockDir, "index.tsx"),
-    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path62.join(blockDir, fileName))
+    path63.join(blockDir, "index.tsx"),
+    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path63.join(blockDir, fileName))
   ].filter((filePath) => typeof filePath === "string")));
 }
 function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
-  const blockJsonRelativePath = path62.join("src", "blocks", block.slug, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", block.slug, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   if (!fs47.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
@@ -237504,8 +237559,8 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
   return createDoctorCheck2(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}` : issues.join("; "));
 }
 function checkWorkspaceBlockHooks(projectDir, blockSlug) {
-  const blockJsonRelativePath = path62.join("src", "blocks", blockSlug, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   if (!fs47.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
@@ -237527,8 +237582,8 @@ function checkWorkspaceBlockHooks(projectDir, blockSlug) {
   return createDoctorCheck2(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0 ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0 ? ` (${Object.keys(blockHooks).join(", ")})` : ""}` : `Invalid blockHooks entries: ${invalidEntries.map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`).join(", ")}`);
 }
 function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
-  const entryRelativePath = path62.join("src", "blocks", blockSlug, "index.tsx");
-  const entryPath = path62.join(projectDir, entryRelativePath);
+  const entryRelativePath = path63.join("src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, entryRelativePath);
   if (!fs47.existsSync(entryPath)) {
     return createDoctorCheck2(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
   }
@@ -237545,8 +237600,8 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
   }
   const blockJson = metadataResult.document;
   const apiVersion = typeof blockJson.apiVersion === "number" && Number.isFinite(blockJson.apiVersion) ? blockJson.apiVersion : null;
-  const blockDir = path62.join(projectDir, "src", "blocks", blockSlug);
-  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs47.existsSync(path62.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path62.join("src", "blocks", blockSlug, fileName)));
+  const blockDir = path63.join(projectDir, "src", "blocks", blockSlug);
+  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs47.existsSync(path63.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path63.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));
@@ -237564,9 +237619,9 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
 }
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const hasCategoryAnchor = source.includes("register_block_pattern_category");
@@ -237575,9 +237630,9 @@ function checkWorkspacePatternBootstrap(projectDir, packageName) {
 }
 function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
@@ -237587,11 +237642,11 @@ 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 = [path62.join("src", "bindings", "index.ts"), path62.join("src", "bindings", "index.js")].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+  const indexRelativePath = [path63.join("src", "bindings", "index.ts"), path63.join("src", "bindings", "index.js")].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
   }
-  const indexPath = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.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(", ")}`);
@@ -237608,8 +237663,8 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   if (!registeredBlockSlugs.has(bindingSource.block)) {
     return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", `Binding target references unknown block "${bindingSource.block}".`);
   }
-  const blockJsonRelativePath = path62.join("src", "blocks", bindingSource.block, "block.json");
-  const blockJsonPath = path62.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path63.join("src", "blocks", bindingSource.block, "block.json");
+  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
   const issues = [];
   try {
     const blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs47.readFileSync(blockJsonPath, "utf8")));
@@ -237625,7 +237680,7 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   } catch (error48) {
     issues.push(error48 instanceof Error ? `Unable to read ${blockJsonRelativePath}: ${error48.message}` : `Unable to read ${blockJsonRelativePath}.`);
   }
-  const serverPath = path62.join(projectDir, bindingSource.serverFile);
+  const serverPath = path63.join(projectDir, bindingSource.serverFile);
   if (fs47.existsSync(serverPath)) {
     const serverSource = fs47.readFileSync(serverPath, "utf8");
     const supportedAttributesFilter = `block_bindings_supported_attributes_${workspace.workspace.namespace}/${bindingSource.block}`;
@@ -237638,7 +237693,7 @@ function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs
   } else {
     issues.push(`Missing ${bindingSource.serverFile}`);
   }
-  const editorPath = path62.join(projectDir, bindingSource.editorFile);
+  const editorPath = path63.join(projectDir, bindingSource.editorFile);
   if (fs47.existsSync(editorPath)) {
     const editorSource = fs47.readFileSync(editorPath, "utf8");
     const blockName = `${workspace.workspace.namespace}/${bindingSource.block}`;
@@ -237686,7 +237741,7 @@ function getWorkspaceRestResourceRequiredFiles(restResource) {
   }
   return Array.from(new Set([
     restResource.apiFile,
-    ...Array.from(schemaNames, (schemaName) => path62.join(path62.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+    ...Array.from(schemaNames, (schemaName) => path63.join(path63.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
     restResource.clientFile,
     restResource.dataFile,
     restResource.openApiFile,
@@ -237702,9 +237757,9 @@ function checkWorkspaceRestResourceConfig(restResource) {
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_rest_resources`;
@@ -237725,7 +237780,7 @@ function getWorkspaceAbilityRequiredFiles(ability) {
   ]));
 }
 function checkWorkspaceAbilityConfig(projectDir, ability) {
-  const configPath = path62.join(projectDir, ability.configFile);
+  const configPath = path63.join(projectDir, ability.configFile);
   if (!fs47.existsSync(configPath)) {
     return createDoctorCheck2(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
   }
@@ -237742,9 +237797,9 @@ function checkWorkspaceAbilityConfig(projectDir, ability) {
 }
 function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
@@ -237763,13 +237818,13 @@ function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
 }
 function checkWorkspaceAbilityIndex(projectDir, abilities) {
   const indexRelativePath = [
-    path62.join("src", "abilities", "index.ts"),
-    path62.join("src", "abilities", "index.js")
-  ].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+    path63.join("src", "abilities", "index.ts"),
+    path63.join("src", "abilities", "index.js")
+  ].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
   }
-  const indexPath = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.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");
@@ -237781,9 +237836,9 @@ function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
   return Array.from(new Set([
     aiFeature.aiSchemaFile,
     aiFeature.apiFile,
-    path62.join(path62.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
-    path62.join(path62.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
-    path62.join(path62.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
+    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
+    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
+    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
     aiFeature.clientFile,
     aiFeature.dataFile,
     aiFeature.openApiFile,
@@ -237798,9 +237853,9 @@ function checkWorkspaceAiFeatureConfig(aiFeature) {
 }
 function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_ai_features`;
@@ -237810,14 +237865,14 @@ function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   return createDoctorCheck2("AI feature bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook ? "AI feature PHP loader hook is present" : "Missing AI feature PHP require glob or init hook");
 }
 function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
-  const editorPluginDir = path62.join("src", "editor-plugins", editorPlugin.slug);
-  const surfaceFile = editorPlugin.slot === "PluginSidebar" ? path62.join(editorPluginDir, "Sidebar.tsx") : path62.join(editorPluginDir, "Surface.tsx");
+  const editorPluginDir = path63.join("src", "editor-plugins", editorPlugin.slug);
+  const surfaceFile = editorPlugin.slot === "PluginSidebar" ? path63.join(editorPluginDir, "Sidebar.tsx") : path63.join(editorPluginDir, "Surface.tsx");
   return Array.from(new Set([
     editorPlugin.file,
     surfaceFile,
-    path62.join(editorPluginDir, "data.ts"),
-    path62.join(editorPluginDir, "types.ts"),
-    path62.join(editorPluginDir, "style.scss")
+    path63.join(editorPluginDir, "data.ts"),
+    path63.join(editorPluginDir, "types.ts"),
+    path63.join(editorPluginDir, "style.scss")
   ]));
 }
 function checkWorkspaceEditorPluginConfig(editorPlugin) {
@@ -237827,9 +237882,9 @@ function checkWorkspaceEditorPluginConfig(editorPlugin) {
 }
 function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
@@ -237842,13 +237897,13 @@ function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix)
 }
 function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   const indexRelativePath = [
-    path62.join("src", "editor-plugins", "index.ts"),
-    path62.join("src", "editor-plugins", "index.js")
-  ].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+    path63.join("src", "editor-plugins", "index.ts"),
+    path63.join("src", "editor-plugins", "index.js")
+  ].find((relativePath) => fs47.existsSync(path63.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 = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.readFileSync(indexPath, "utf8");
   const missingImports = editorPlugins.filter((editorPlugin) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
@@ -237857,15 +237912,15 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   return createDoctorCheck2("Editor plugins index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Editor plugin registrations are aggregated" : `Missing editor plugin imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function getWorkspaceAdminViewRequiredFiles(adminView) {
-  const adminViewDir = path62.join("src", "admin-views", adminView.slug);
+  const adminViewDir = path63.join("src", "admin-views", adminView.slug);
   return Array.from(new Set([
     adminView.file,
     adminView.phpFile,
-    path62.join(adminViewDir, "Screen.tsx"),
-    path62.join(adminViewDir, "config.ts"),
-    path62.join(adminViewDir, "data.ts"),
-    path62.join(adminViewDir, "style.scss"),
-    path62.join(adminViewDir, "types.ts")
+    path63.join(adminViewDir, "Screen.tsx"),
+    path63.join(adminViewDir, "config.ts"),
+    path63.join(adminViewDir, "data.ts"),
+    path63.join(adminViewDir, "style.scss"),
+    path63.join(adminViewDir, "types.ts")
   ]));
 }
 function checkWorkspaceAdminViewConfig(adminView, inventory) {
@@ -237882,9 +237937,9 @@ function checkWorkspaceAdminViewConfig(adminView, inventory) {
 }
 function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path62.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
   if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path62.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
   }
   const source = fs47.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_admin_views`;
@@ -237895,13 +237950,13 @@ function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
 }
 function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
   const indexRelativePath = [
-    path62.join("src", "admin-views", "index.ts"),
-    path62.join("src", "admin-views", "index.js")
-  ].find((relativePath) => fs47.existsSync(path62.join(projectDir, relativePath)));
+    path63.join("src", "admin-views", "index.ts"),
+    path63.join("src", "admin-views", "index.js")
+  ].find((relativePath) => fs47.existsSync(path63.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 = path62.join(projectDir, indexRelativePath);
+  const indexPath = path63.join(projectDir, indexRelativePath);
   const source = fs47.readFileSync(indexPath, "utf8");
   const missingImports = adminViews.filter((adminView) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(adminView.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
@@ -237910,7 +237965,7 @@ function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
   return createDoctorCheck2("Admin views index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Admin view registrations are aggregated" : `Missing admin view imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function checkWorkspaceAdminViewPhp(projectDir, adminView) {
-  const phpPath = path62.join(projectDir, adminView.phpFile);
+  const phpPath = path63.join(projectDir, adminView.phpFile);
   if (!fs47.existsSync(phpPath)) {
     return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
   }
@@ -237924,9 +237979,9 @@ function checkWorkspaceAdminViewPhp(projectDir, adminView) {
   return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, hasAdminMenu && hasAdminEnqueue && hasScript && hasAsset && hasStyle && hasComponentsStyleDependency ? "pass" : "fail", hasAdminMenu && hasAdminEnqueue && hasScript && hasAsset && hasStyle && hasComponentsStyleDependency ? "Admin menu, script, style, and wp-components style dependency are wired" : "Missing admin menu, enqueue hook, build/admin-views asset reference, or wp-components style dependency");
 }
 function checkVariationEntrypoint(projectDir, blockSlug) {
-  const entryPath = path62.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path62.relative(projectDir, entryPath)}`);
+    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
   }
   const source = fs47.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern2(source, WORKSPACE_VARIATIONS_IMPORT_PATTERN);
@@ -237934,9 +237989,9 @@ function checkVariationEntrypoint(projectDir, blockSlug) {
   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 = path62.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path62.relative(projectDir, entryPath)}`);
+    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
   }
   const source = fs47.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN);
@@ -237944,9 +237999,9 @@ function checkBlockStyleEntrypoint(projectDir, blockSlug) {
   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 = path62.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path62.relative(projectDir, entryPath)}`);
+    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
   }
   const source = fs47.readFileSync(entryPath, "utf8");
   const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN);
@@ -237966,8 +238021,8 @@ function checkBlockTransformConfig(workspace, transform2) {
 }
 function checkMigrationWorkspaceHint(workspace, packageJson) {
   const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
-  const migrationConfigRelativePath = path62.join("src", "migrations", "config.ts");
-  const hasMigrationConfig = fs47.existsSync(path62.join(workspace.projectDir, migrationConfigRelativePath));
+  const migrationConfigRelativePath = path63.join("src", "migrations", "config.ts");
+  const hasMigrationConfig = fs47.existsSync(path63.join(workspace.projectDir, migrationConfigRelativePath));
   if (!hasMigrationScript && !hasMigrationConfig) {
     return null;
   }
@@ -238037,7 +238092,7 @@ function getWorkspaceDoctorChecks(cwd) {
     }
     for (const blockSlug of blockStyleTargetBlocks) {
       checks3.push(checkExistingFiles(workspace.projectDir, `Block style registry ${blockSlug}`, [
-        path62.join("src", "blocks", blockSlug, "styles", "index.ts")
+        path63.join("src", "blocks", blockSlug, "styles", "index.ts")
       ]));
       checks3.push(checkBlockStyleEntrypoint(workspace.projectDir, blockSlug));
     }
@@ -238053,11 +238108,11 @@ function getWorkspaceDoctorChecks(cwd) {
     }
     for (const blockSlug of blockTransformTargetBlocks) {
       checks3.push(checkExistingFiles(workspace.projectDir, `Block transform registry ${blockSlug}`, [
-        path62.join("src", "blocks", blockSlug, "transforms", "index.ts")
+        path63.join("src", "blocks", blockSlug, "transforms", "index.ts")
       ]));
       checks3.push(checkBlockTransformEntrypoint(workspace.projectDir, blockSlug));
     }
-    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs47.existsSync(path62.join(workspace.projectDir, "src", "patterns"));
+    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs47.existsSync(path63.join(workspace.projectDir, "src", "patterns"));
     if (shouldCheckPatternBootstrap) {
       checks3.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
     }
@@ -238225,13 +238280,13 @@ __export(exports_cli_init, {
 });
 import fs48 from "fs";
 import { promises as fsp25 } from "fs";
-import path63 from "path";
+import path64 from "path";
 import { analyzeSourceTypes } from "@wp-typia/block-runtime/metadata-parser";
 function normalizeRelativePath2(value2) {
   return value2.replace(/\\/gu, "/");
 }
 function readProjectPackageJson(projectDir) {
-  const packageJsonPath = path63.join(projectDir, "package.json");
+  const packageJsonPath = path64.join(projectDir, "package.json");
   if (!fs48.existsSync(packageJsonPath)) {
     return null;
   }
@@ -238247,13 +238302,13 @@ function inferInitPackageManager(projectDir, packageJson) {
   if (packageJson?.packageManager) {
     return parseWorkspacePackageManagerId(packageJson.packageManager);
   }
-  if (fs48.existsSync(path63.join(projectDir, "bun.lock")) || fs48.existsSync(path63.join(projectDir, "bun.lockb"))) {
+  if (fs48.existsSync(path64.join(projectDir, "bun.lock")) || fs48.existsSync(path64.join(projectDir, "bun.lockb"))) {
     return "bun";
   }
-  if (fs48.existsSync(path63.join(projectDir, "pnpm-lock.yaml"))) {
+  if (fs48.existsSync(path64.join(projectDir, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs48.existsSync(path63.join(projectDir, "yarn.lock")) || fs48.existsSync(path63.join(projectDir, ".yarnrc.yml"))) {
+  if (fs48.existsSync(path64.join(projectDir, "yarn.lock")) || fs48.existsSync(path64.join(projectDir, ".yarnrc.yml"))) {
     return "yarn";
   }
   return "npm";
@@ -238337,13 +238392,13 @@ function buildPackageManagerFieldChange(packageJson, packageManager, options = {
   };
 }
 function buildGeneratedArtifactPaths(blockJsonFile, manifestFile) {
-  const manifestDir = path63.dirname(manifestFile);
+  const manifestDir = path64.dirname(manifestFile);
   const artifactPaths = [
     blockJsonFile,
     manifestFile,
-    path63.join(manifestDir, "typia.schema.json"),
-    path63.join(manifestDir, "typia-validator.php"),
-    path63.join(manifestDir, "typia.openapi.json")
+    path64.join(manifestDir, "typia.schema.json"),
+    path64.join(manifestDir, "typia-validator.php"),
+    path64.join(manifestDir, "typia.openapi.json")
   ];
   return Array.from(new Set(artifactPaths.map((filePath) => normalizeRelativePath2(filePath))));
 }
@@ -238364,7 +238419,7 @@ function isObjectLikeSourceType(projectDir, typesFile, sourceTypeName) {
   return analyzedTypes[sourceTypeName]?.kind === "object";
 }
 function inferRetrofitAttributeTypeName(projectDir, block) {
-  const typesPath = path63.join(projectDir, block.typesFile);
+  const typesPath = path64.join(projectDir, block.typesFile);
   const typesSource = fs48.readFileSync(typesPath, "utf8");
   const blockNameSegments = block.blockName.split("/");
   const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
@@ -238670,10 +238725,10 @@ function hasExistingWpTypiaProjectSurface(projectDir, packageJson) {
   const scripts = packageJson?.scripts ?? {};
   const hasSyncSurface = typeof scripts.sync === "string" || typeof scripts["sync-types"] === "string";
   const hasHelperFiles = [
-    path63.join("scripts", "block-config.ts"),
-    path63.join("scripts", "sync-project.ts"),
-    path63.join("scripts", "sync-types-to-block-json.ts")
-  ].every((relativePath) => fs48.existsSync(path63.join(projectDir, relativePath)));
+    path64.join("scripts", "block-config.ts"),
+    path64.join("scripts", "sync-project.ts"),
+    path64.join("scripts", "sync-types-to-block-json.ts")
+  ].every((relativePath) => fs48.existsSync(path64.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;
 }
@@ -238683,17 +238738,17 @@ function buildPlannedFiles(projectDir, layoutKind) {
   }
   return [
     {
-      action: fs48.existsSync(path63.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
+      action: fs48.existsSync(path64.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: fs48.existsSync(path63.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
+      action: fs48.existsSync(path64.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: fs48.existsSync(path63.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
+      action: fs48.existsSync(path64.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."
     }
@@ -238841,13 +238896,13 @@ function buildProjectPackageJsonSource(packageJson) {
 }
 function buildRetrofitHelperFiles(blockTargets) {
   return {
-    [path63.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
-    [path63.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
-    [path63.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
+    [path64.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
+    [path64.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
+    [path64.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
   };
 }
 async function createRetrofitMutationSnapshot(projectDir, filePaths) {
-  const scriptsDir = path63.join(projectDir, "scripts");
+  const scriptsDir = path64.join(projectDir, "scripts");
   const scriptsDirExisted = fs48.existsSync(scriptsDir);
   const fileSources = await snapshotWorkspaceFiles(filePaths);
   const targetPaths = fileSources.filter((entry) => entry.source === null).map((entry) => entry.filePath);
@@ -238862,11 +238917,11 @@ async function createRetrofitMutationSnapshot(projectDir, filePaths) {
 }
 async function writeRetrofitFiles(options) {
   const helperFiles = buildRetrofitHelperFiles(options.blockTargets);
-  const scriptsDir = path63.join(options.projectDir, "scripts");
+  const scriptsDir = path64.join(options.projectDir, "scripts");
   await fsp25.mkdir(scriptsDir, { recursive: true });
-  await fsp25.writeFile(path63.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
+  await fsp25.writeFile(path64.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
   for (const [relativePath, source] of Object.entries(helperFiles)) {
-    await fsp25.writeFile(path63.join(options.projectDir, relativePath), source, "utf8");
+    await fsp25.writeFile(path64.join(options.projectDir, relativePath), source, "utf8");
   }
 }
 function buildApplyFailureError(error48) {
@@ -238874,7 +238929,7 @@ function buildApplyFailureError(error48) {
   return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to apply the retrofit init plan safely. The command restored the previous package.json/helper-file snapshot. ${message}`, error48 instanceof Error ? { cause: error48 } : undefined);
 }
 function getInitPlan(projectDir, options = {}) {
-  const resolvedProjectDir = path63.resolve(projectDir);
+  const resolvedProjectDir = path64.resolve(projectDir);
   const packageJson = readProjectPackageJson(resolvedProjectDir);
   const packageManager = resolveInitPackageManager(resolvedProjectDir, packageJson, options.packageManager);
   const workspace = tryResolveWorkspaceProject(resolvedProjectDir);
@@ -238910,7 +238965,7 @@ function getInitPlan(projectDir, options = {}) {
       status: "already-initialized"
     });
   }
-  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path63.basename(resolvedProjectDir);
+  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path64.basename(resolvedProjectDir);
   const layout = buildLayoutDetails(resolvedProjectDir);
   const dependencyChanges = buildDependencyChanges(packageJson);
   const scriptChanges = buildScriptChanges(packageJson, packageManager);
@@ -238976,8 +239031,8 @@ async function applyInitPlan(projectDir, options = {}) {
   });
   const helperFiles = buildRetrofitHelperFiles(previewPlan.blockTargets);
   const filePaths = [
-    path63.join(previewPlan.projectDir, "package.json"),
-    ...Object.keys(helperFiles).map((relativePath) => path63.join(previewPlan.projectDir, relativePath))
+    path64.join(previewPlan.projectDir, "package.json"),
+    ...Object.keys(helperFiles).map((relativePath) => path64.join(previewPlan.projectDir, relativePath))
   ];
   const mutationSnapshot = await createRetrofitMutationSnapshot(previewPlan.projectDir, filePaths);
   try {
@@ -239041,18 +239096,18 @@ __export(exports_cli_scaffold, {
 });
 import fs49 from "fs";
 import { promises as fsp26 } from "fs";
-import path64 from "path";
+import path65 from "path";
 async function listRelativeProjectFiles(rootDir) {
   const relativeFiles = [];
   async function visit2(currentDir) {
     const entries = await fsp26.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = path64.join(currentDir, entry.name);
+      const absolutePath = path65.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         await visit2(absolutePath);
         continue;
       }
-      relativeFiles.push(path64.relative(rootDir, absolutePath).replace(path64.sep === "\\" ? /\\/gu : /\//gu, "/"));
+      relativeFiles.push(path65.relative(rootDir, absolutePath).replace(path65.sep === "\\" ? /\\/gu : /\//gu, "/"));
     }
   }
   await visit2(rootDir);
@@ -239090,7 +239145,7 @@ async function buildScaffoldDryRunPlan({
 }) {
   await assertDryRunTargetDirectoryReady(projectDir, allowExistingDir);
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-scaffold-plan-");
-  const previewProjectDir = path64.join(tempRoot, "preview-project");
+  const previewProjectDir = path65.join(tempRoot, "preview-project");
   try {
     const result = await scaffoldProject({
       allowExistingDir: false,
@@ -239130,14 +239185,14 @@ function validateCreateProjectInput(projectInput) {
   if (normalizedProjectInput.length === 0) {
     throw new Error("Project directory is required. Usage: wp-typia create <project-dir> (or wp-typia <project-dir> when <project-dir> is the only positional argument).");
   }
-  const normalizedProjectPath = path64.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path64.normalize(normalizedProjectInput);
+  const normalizedProjectPath = path65.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path65.normalize(normalizedProjectInput);
   if (normalizedProjectPath === "." || normalizedProjectPath === "..") {
     throw new Error("`wp-typia create` requires a new project directory. Use an explicit child directory instead of `.` or `..`.");
   }
 }
 function collectProjectDirectoryWarnings(projectDir) {
   const warnings = [];
-  const projectName = path64.basename(projectDir);
+  const projectName = path65.basename(projectDir);
   if (/\s/u.test(projectName)) {
     warnings.push(`Project directory "${projectName}" contains spaces. The generated next-step commands will be quoted, but a simple kebab-case directory name is usually easier to use with shells and downstream tooling.`);
   }
@@ -239292,7 +239347,7 @@ function getNextSteps({
   noInstall,
   templateId
 }) {
-  const cdTarget = path64.isAbsolute(projectInput) ? projectDir : projectInput;
+  const cdTarget = path65.isAbsolute(projectInput) ? projectDir : projectInput;
   const steps = [`cd ${quoteShellValue(cdTarget)}`];
   if (noInstall) {
     steps.push(formatInstallCommand(packageManager));
@@ -239440,8 +239495,8 @@ async function runScaffoldFlow({
       select: selectWithMigrationUi,
       yes
     });
-    const projectDir = path64.resolve(cwd, projectInput);
-    const projectName = path64.basename(projectDir);
+    const projectDir = path65.resolve(cwd, projectInput);
+    const projectName = path65.basename(projectDir);
     const answers = await collectScaffoldAnswers({
       dataStorageMode: resolvedDataStorage,
       namespace,
@@ -239504,7 +239559,7 @@ async function runScaffoldFlow({
     let availableScripts;
     if (!dryRun) {
       try {
-        const parsedPackageJson = JSON.parse(fs49.readFileSync(path64.join(projectDir, "package.json"), "utf8"));
+        const parsedPackageJson = JSON.parse(fs49.readFileSync(path65.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 {
@@ -292421,6 +292476,12 @@ var MIGRATE_OPTION_METADATA = {
     type: "string"
   }
 };
+var MCP_OPTION_METADATA = {
+  "output-dir": {
+    description: "Output directory for generated MCP metadata.",
+    type: "string"
+  }
+};
 var SYNC_OPTION_METADATA = {
   check: {
     argumentKind: "flag",
@@ -292458,10 +292519,6 @@ var GLOBAL_OPTION_METADATA = {
   id: {
     description: "Template id for top-level `templates inspect` convenience.",
     type: "string"
-  },
-  "output-dir": {
-    description: "Output directory for generated MCP metadata.",
-    type: "string"
   }
 };
 var COMMAND_OPTION_METADATA_BY_GROUP = {
@@ -292471,6 +292528,7 @@ var COMMAND_OPTION_METADATA_BY_GROUP = {
   global: GLOBAL_OPTION_METADATA,
   init: INIT_OPTION_METADATA,
   migrate: MIGRATE_OPTION_METADATA,
+  mcp: MCP_OPTION_METADATA,
   sync: SYNC_OPTION_METADATA,
   templates: TEMPLATES_OPTION_METADATA
 };
@@ -292547,13 +292605,17 @@ function resolveCommandOptionValues(metadata2, options) {
 
 // src/cli-diagnostic-output.ts
 init_cli_diagnostics();
+function writeStructuredCliJsonToStderr(payload) {
+  process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+}
 function prefersStructuredCliOutput(args) {
   return args.formatExplicit && args.format !== "toon" || Boolean(args.agent) || Boolean(args.context?.store?.isAIAgent);
 }
 function emitCliDiagnosticFailure(args, options) {
   const diagnostic = createCliCommandError(options);
   if (prefersStructuredCliOutput(args)) {
-    args.output({
+    writeStructuredCliJsonToStderr({
       ...options.extraOutput ?? {},
       error: serializeCliDiagnosticError(diagnostic),
       ok: false
@@ -292603,6 +292665,24 @@ init_cli_diagnostics();
 
 // src/add-kind-registry.ts
 init_cli_diagnostics();
+
+// src/add-kind-ids.ts
+var ADD_KIND_IDS = [
+  "admin-view",
+  "block",
+  "variation",
+  "style",
+  "transform",
+  "pattern",
+  "binding-source",
+  "rest-resource",
+  "ability",
+  "ai-feature",
+  "hooked-block",
+  "editor-plugin"
+];
+
+// src/add-kind-registry.ts
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
   "name",
@@ -292612,6 +292692,54 @@ var BLOCK_VISIBLE_FIELD_ORDER = [
   "data-storage",
   "persistence-policy"
 ];
+var NAME_ONLY_VISIBLE_FIELDS = [
+  "kind",
+  "name"
+];
+var NAME_SOURCE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "source"
+];
+var NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "block",
+  "attribute"
+];
+var NAME_BLOCK_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "block"
+];
+var NAME_SLOT_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "slot"
+];
+var NAME_ANCHOR_POSITION_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "anchor",
+  "position"
+];
+var NAME_FROM_TO_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "from",
+  "to"
+];
+var NAME_NAMESPACE_METHODS_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "namespace",
+  "methods"
+];
+var NAME_NAMESPACE_VISIBLE_FIELDS = [
+  "kind",
+  "name",
+  "namespace"
+];
 function readOptionalStringFlag(flags2, name2) {
   const value2 = flags2[name2];
   if (value2 === undefined || value2 === null) {
@@ -292622,6 +292750,21 @@ function readOptionalStringFlag(flags2, name2) {
   }
   return value2;
 }
+function requireStringFlag(flags2, name2, message) {
+  const value2 = readOptionalStringFlag(flags2, name2);
+  if (!value2) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return value2;
+}
+function readOptionalPairedStringFlags(flags2, leftName, rightName, message) {
+  const leftValue = readOptionalStringFlag(flags2, leftName);
+  const rightValue = readOptionalStringFlag(flags2, rightName);
+  if (Boolean(leftValue) !== Boolean(rightValue)) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return [leftValue, rightValue];
+}
 function requireAddKindName(context, message) {
   if (!context.name) {
     throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
@@ -292645,6 +292788,15 @@ function toExternalLayerPromptOptions(options) {
 function defineAddKindRegistryEntry(entry) {
   return entry;
 }
+function createNamedExecutionPlan(context, options) {
+  const name2 = options.name ?? requireAddKindName(context, options.missingNameMessage);
+  return {
+    execute: (cwd) => options.execute({ cwd, name: name2 }),
+    getValues: options.getValues,
+    ...options.getWarnings ? { getWarnings: options.getWarnings } : {},
+    ...options.warnLine ? { warnLine: options.warnLine } : {}
+  };
+}
 function isAddPersistenceTemplate(template) {
   return template === "persistence" || template === "compound";
 }
@@ -292667,22 +292819,24 @@ var ADD_KIND_REGISTRY = {
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
       const source = readOptionalStringFlag(context.flags, "source");
-      return {
-        execute: (cwd) => context.addRuntime.runAddAdminViewCommand({
-          adminViewName: name2,
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddAdminViewCommand({
+          adminViewName: name3,
           cwd,
           source
         }),
         getValues: (result) => ({
           adminViewSlug: result.adminViewSlug,
           ...result.source ? { source: result.source } : {}
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].",
+        name: name2
+      });
     },
     sortOrder: 10,
     supportsDryRun: true,
     usage: "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "source"]
+    visibleFieldNames: () => NAME_SOURCE_VISIBLE_FIELDS
   }),
   "binding-source": defineAddKindRegistryEntry({
     completion: {
@@ -292704,15 +292858,11 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Binding source name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
-      const blockName = readOptionalStringFlag(context.flags, "block");
-      const attributeName = readOptionalStringFlag(context.flags, "attribute");
-      if (Boolean(blockName) !== Boolean(attributeName)) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddBindingSourceCommand({
+      const [blockName, attributeName] = readOptionalPairedStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBindingSourceCommand({
           attributeName,
-          bindingSourceName: name2,
+          bindingSourceName: name3,
           blockName,
           cwd
         }),
@@ -292720,13 +292870,15 @@ var ADD_KIND_REGISTRY = {
           ...result.attributeName ? { attributeName: result.attributeName } : {},
           ...result.blockSlug ? { blockSlug: result.blockSlug } : {},
           bindingSourceSlug: result.bindingSourceSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].",
+        name: name2
+      });
     },
     sortOrder: 70,
     supportsDryRun: true,
     usage: "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "block", "attribute"]
+    visibleFieldNames: () => NAME_BLOCK_ATTRIBUTE_VISIBLE_FIELDS
   }),
   block: defineAddKindRegistryEntry({
     completion: {
@@ -292764,10 +292916,10 @@ var ADD_KIND_REGISTRY = {
         })), 1);
       }
       resolvedTemplateId ??= "basic";
-      return {
-        execute: (cwd) => context.addRuntime.runAddBlockCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockCommand({
           alternateRenderTargets,
-          blockName: name2,
+          blockName: name3,
           cwd,
           dataStorageMode,
           externalLayerId,
@@ -292782,8 +292934,10 @@ var ADD_KIND_REGISTRY = {
           templateId: result.templateId
         }),
         getWarnings: (result) => result.warnings,
+        missingNameMessage: "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]",
+        name: name2,
         warnLine: context.warnLine
-      };
+      });
     },
     sortOrder: 20,
     supportsDryRun: true,
@@ -292816,21 +292970,21 @@ var ADD_KIND_REGISTRY = {
     description: "Add a typed server/client workflow ability scaffold",
     nameLabel: "Ability name",
     async prepareExecution(context) {
-      const name2 = requireAddKindName(context, "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>.");
-      return {
-        execute: (cwd) => context.addRuntime.runAddAbilityCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddAbilityCommand({
           abilityName: name2,
           cwd
         }),
         getValues: (result) => ({
           abilitySlug: result.abilitySlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add ability` requires <name>. Usage: wp-typia add ability <name>."
+      });
     },
     sortOrder: 90,
     supportsDryRun: true,
     usage: "wp-typia add ability <name> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name"]
+    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
   }),
   "editor-plugin": defineAddKindRegistryEntry({
     completion: {
@@ -292850,22 +293004,24 @@ var ADD_KIND_REGISTRY = {
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
       const slot = readOptionalStringFlag(context.flags, "slot");
-      return {
-        execute: (cwd) => context.addRuntime.runAddEditorPluginCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddEditorPluginCommand({
           cwd,
-          editorPluginName: name2,
+          editorPluginName: name3,
           slot
         }),
         getValues: (result) => ({
           editorPluginSlug: result.editorPluginSlug,
           slot: result.slot
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].",
+        name: name2
+      });
     },
     sortOrder: 120,
     supportsDryRun: true,
     usage: "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "slot"]
+    visibleFieldNames: () => NAME_SLOT_VISIBLE_FIELDS
   }),
   "hooked-block": defineAddKindRegistryEntry({
     completion: {
@@ -292885,18 +293041,12 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Target block",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
-      const anchorBlockName = readOptionalStringFlag(context.flags, "anchor");
-      if (!anchorBlockName) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-      }
-      const position = readOptionalStringFlag(context.flags, "position");
-      if (!position) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddHookedBlockCommand({
+      const anchorBlockName = requireStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+      const position = requireStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddHookedBlockCommand({
           anchorBlockName,
-          blockName: name2,
+          blockName: name3,
           cwd,
           position
         }),
@@ -292904,13 +293054,15 @@ var ADD_KIND_REGISTRY = {
           anchorBlockName: result.anchorBlockName,
           blockSlug: result.blockSlug,
           position: result.position
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.",
+        name: name2
+      });
     },
     sortOrder: 110,
     supportsDryRun: true,
     usage: "wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "anchor", "position"]
+    visibleFieldNames: () => NAME_ANCHOR_POSITION_VISIBLE_FIELDS
   }),
   pattern: defineAddKindRegistryEntry({
     completion: {
@@ -292927,21 +293079,21 @@ var ADD_KIND_REGISTRY = {
     description: "Add a PHP block pattern shell",
     nameLabel: "Pattern name",
     async prepareExecution(context) {
-      const name2 = requireAddKindName(context, "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>.");
-      return {
-        execute: (cwd) => context.addRuntime.runAddPatternCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name2 }) => context.addRuntime.runAddPatternCommand({
           cwd,
           patternName: name2
         }),
         getValues: (result) => ({
           patternSlug: result.patternSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add pattern` requires <name>. Usage: wp-typia add pattern <name>."
+      });
     },
     sortOrder: 60,
     supportsDryRun: true,
     usage: "wp-typia add pattern <name> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name"]
+    visibleFieldNames: () => NAME_ONLY_VISIBLE_FIELDS
   }),
   style: defineAddKindRegistryEntry({
     completion: {
@@ -292960,26 +293112,25 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Style name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
-      const blockSlug = readOptionalStringFlag(context.flags, "block");
-      if (!blockSlug) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add style` requires --block <block-slug>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddBlockStyleCommand({
+      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockStyleCommand({
           blockName: blockSlug,
           cwd,
-          styleName: name2
+          styleName: name3
         }),
         getValues: (result) => ({
           blockSlug: result.blockSlug,
           styleSlug: result.styleSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.",
+        name: name2
+      });
     },
     sortOrder: 40,
     supportsDryRun: true,
     usage: "wp-typia add style <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "block"]
+    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
   }),
   transform: defineAddKindRegistryEntry({
     completion: {
@@ -292999,33 +293150,29 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Transform name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
-      const fromBlockName = readOptionalStringFlag(context.flags, "from");
-      if (!fromBlockName) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add transform` requires --from <namespace/block>.");
-      }
-      const toBlockName = readOptionalStringFlag(context.flags, "to");
-      if (!toBlockName) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddBlockTransformCommand({
+      const fromBlockName = requireStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
+      const toBlockName = requireStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockTransformCommand({
           cwd,
           fromBlockName,
           toBlockName,
-          transformName: name2
+          transformName: name3
         }),
         getValues: (result) => ({
           blockSlug: result.blockSlug,
           fromBlockName: result.fromBlockName,
           toBlockName: result.toBlockName,
           transformSlug: result.transformSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.",
+        name: name2
+      });
     },
     sortOrder: 50,
     supportsDryRun: true,
     usage: "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "from", "to"]
+    visibleFieldNames: () => NAME_FROM_TO_VISIBLE_FIELDS
   }),
   "rest-resource": defineAddKindRegistryEntry({
     completion: {
@@ -293047,24 +293194,26 @@ var ADD_KIND_REGISTRY = {
       const name2 = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
       const methods = readOptionalStringFlag(context.flags, "methods");
       const namespace = readOptionalStringFlag(context.flags, "namespace");
-      return {
-        execute: (cwd) => context.addRuntime.runAddRestResourceCommand({
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddRestResourceCommand({
           cwd,
           methods,
           namespace,
-          restResourceName: name2
+          restResourceName: name3
         }),
         getValues: (result) => ({
           methods: result.methods.join(", "),
           namespace: result.namespace,
           restResourceSlug: result.restResourceSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].",
+        name: name2
+      });
     },
     sortOrder: 80,
     supportsDryRun: true,
     usage: "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "namespace", "methods"]
+    visibleFieldNames: () => NAME_NAMESPACE_METHODS_VISIBLE_FIELDS
   }),
   "ai-feature": defineAddKindRegistryEntry({
     completion: {
@@ -293084,9 +293233,9 @@ var ADD_KIND_REGISTRY = {
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
       const namespace = readOptionalStringFlag(context.flags, "namespace");
-      return {
-        execute: (cwd) => context.addRuntime.runAddAiFeatureCommand({
-          aiFeatureName: name2,
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddAiFeatureCommand({
+          aiFeatureName: name3,
           cwd,
           namespace
         }),
@@ -293095,13 +293244,15 @@ var ADD_KIND_REGISTRY = {
           namespace: result.namespace
         }),
         getWarnings: (result) => result.warnings,
+        missingNameMessage: "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].",
+        name: name2,
         warnLine: context.warnLine
-      };
+      });
     },
     sortOrder: 100,
     supportsDryRun: true,
     usage: "wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "namespace"]
+    visibleFieldNames: () => NAME_NAMESPACE_VISIBLE_FIELDS
   }),
   variation: defineAddKindRegistryEntry({
     completion: {
@@ -293120,29 +293271,27 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Variation name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
-      const blockSlug = readOptionalStringFlag(context.flags, "block");
-      if (!blockSlug) {
-        throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, "`wp-typia add variation` requires --block <block-slug>.");
-      }
-      return {
-        execute: (cwd) => context.addRuntime.runAddVariationCommand({
+      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
+      return createNamedExecutionPlan(context, {
+        execute: ({ cwd, name: name3 }) => context.addRuntime.runAddVariationCommand({
           blockName: blockSlug,
           cwd,
-          variationName: name2
+          variationName: name3
         }),
         getValues: (result) => ({
           blockSlug: result.blockSlug,
           variationSlug: result.variationSlug
-        })
-      };
+        }),
+        missingNameMessage: "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>",
+        name: name2
+      });
     },
     sortOrder: 30,
     supportsDryRun: true,
     usage: "wp-typia add variation <name> --block <block-slug> [--dry-run]",
-    visibleFieldNames: () => ["kind", "name", "block"]
+    visibleFieldNames: () => NAME_BLOCK_VISIBLE_FIELDS
   })
 };
-var ADD_KIND_IDS = Object.keys(ADD_KIND_REGISTRY).sort((left, right) => ADD_KIND_REGISTRY[left].sortOrder - ADD_KIND_REGISTRY[right].sortOrder);
 function isAddKindId(value2) {
   return typeof value2 === "string" && ADD_KIND_IDS.includes(value2);
 }
@@ -293300,7 +293449,7 @@ import path10 from "path";
 // package.json
 var package_default2 = {
   name: "wp-typia",
-  version: "0.22.0",
+  version: "0.22.1",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -293370,7 +293519,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.0",
+    "@wp-typia/project-tools": "0.22.1",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -293540,15 +293689,7 @@ function buildStructuredCompletionSuccessPayload(command, completion, metadata2
       command,
       ...serializedCompletion ? {
         completion: serializedCompletion,
-        files: extractPlannedFiles(serializedCompletion),
-        nextSteps: serializedCompletion.nextSteps,
-        optionalLines: serializedCompletion.optionalLines,
-        optionalNote: serializedCompletion.optionalNote,
-        optionalTitle: serializedCompletion.optionalTitle,
-        preambleLines: serializedCompletion.preambleLines,
-        summaryLines: serializedCompletion.summaryLines,
-        title: serializedCompletion.title,
-        warnings: serializedCompletion.warningLines
+        files: extractPlannedFiles(serializedCompletion)
       } : {}
     }
   };
@@ -293567,14 +293708,11 @@ function buildStructuredInitSuccessPayload(plan) {
       detectedLayout: plan.detectedLayout,
       files: toNonEmptyArray(files),
       mode: plan.commandMode === "apply" ? "apply" : "preview",
-      nextSteps: toNonEmptyArray(plan.nextSteps),
       packageManager: plan.packageManager,
       plan,
       projectDir: plan.projectDir,
       status: plan.status,
-      summary: plan.summary,
-      title: completion.title,
-      warnings: toNonEmptyArray(plan.notes)
+      summary: plan.summary
     }
   };
 }
@@ -295046,7 +295184,7 @@ init_cli_diagnostics();
 
 // src/mcp.ts
 import fs50 from "fs/promises";
-import path65 from "path";
+import path66 from "path";
 
 // ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
 class SchemaConversionError extends TaggedError("SchemaConversionError")() {
@@ -295574,7 +295712,7 @@ function isToolGroup(value2) {
   return isObject3(value2) && typeof value2.namespace === "string" && Array.isArray(value2.tools) && value2.tools.every(isTool);
 }
 async function readSchemaSource(cwd, source) {
-  const schemaPath = path65.resolve(cwd, source.path);
+  const schemaPath = path66.resolve(cwd, source.path);
   const raw = await fs50.readFile(schemaPath, "utf8");
   const parsed = JSON.parse(raw);
   if (isToolGroup(parsed)) {
@@ -295591,7 +295729,7 @@ async function readSchemaSource(cwd, source) {
 async function loadMcpToolGroups(cwd, schemaSources) {
   return Promise.all(schemaSources.map((source) => readSchemaSource(cwd, source)));
 }
-async function syncMcpSchemas(cwd, schemaSources, outputDir = path65.join(cwd, ".bunli", "mcp")) {
+async function syncMcpSchemas(cwd, schemaSources, outputDir = path66.join(cwd, ".bunli", "mcp")) {
   const groups = await loadMcpToolGroups(cwd, schemaSources);
   const result = await generateMCPTypes({
     outputDir,
@@ -295614,7 +295752,7 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path65.join(cwd, "
     }
   }
   await fs50.mkdir(outputDir, { recursive: true });
-  await fs50.writeFile(path65.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
+  await fs50.writeFile(path66.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
 `, "utf8");
   return {
     commandCount: registry2.reduce((count, group) => count + group.tools.length, 0),
@@ -295675,7 +295813,9 @@ var mcpCommand = defineCommand({
       emitCliDiagnosticFailure(args, {
         code: CLI_DIAGNOSTIC_CODES.INVALID_COMMAND,
         command: "mcp",
-        detailLines: [`Unknown mcp subcommand "${subcommand}". Expected list or sync.`]
+        detailLines: [
+          `Unknown mcp subcommand "${subcommand}". Expected list or sync.`
+        ]
       });
     } catch (error48) {
       emitCliDiagnosticFailure(args, {
@@ -295685,12 +295825,7 @@ var mcpCommand = defineCommand({
     }
   },
   name: "mcp",
-  options: {
-    "output-dir": {
-      description: "Output directory for generated MCP metadata during `mcp sync`.",
-      schema: exports_external.string().optional()
-    }
-  }
+  options: buildCommandOptions(MCP_OPTION_METADATA)
 });
 var mcp_default = mcpCommand;
 
@@ -295936,4 +296071,4 @@ export {
   cli
 };
 
-//# debugId=D9C2F8E8EFC1ECF864756E2164756E21
+//# debugId=7FC90D52A694344264756E2164756E21