wp-typia 0.22.0 → 0.22.1

package/dist-bunli/{cli-add-kjhghdqq.js → cli-add-5z3wpzkh.js}

@@ -20,7 +20,7 @@ import {
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-1w5vkye4.js";
+} from "./cli-886tjd8m.js";
 import {
   DEFAULT_WORDPRESS_ABILITIES_VERSION,
   DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
@@ -28,11 +28,12 @@ import {
   DEFAULT_WORDPRESS_DATAVIEWS_VERSION,
   DEFAULT_WORDPRESS_DATA_VERSION,
   DEFAULT_WP_TYPIA_DATAVIEWS_VERSION,
-  getPackageVersions
-} from "./cli-39er8888.js";
+  getPackageVersions,
+  resolveManagedPackageVersionRange
+} from "./cli-1sm60g1z.js";
 import {
   snapshotProjectVersion
-} from "./cli-e623rs7g.js";
+} from "./cli-yzmkz95r.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
@@ -45,7 +46,6 @@ import {
 } from "./cli-sj5mtyzj.js";
 import"./cli-10pe4mf8.js";
 import {
-  PROJECT_TOOLS_PACKAGE_ROOT,
   SHARED_WORKSPACE_TEMPLATE_ROOT
 } from "./cli-tke8twkn.js";
 import {
@@ -89,11 +89,12 @@ import {
   resolveWorkspaceBlock,
   rollbackWorkspaceMutation,
   snapshotWorkspaceFiles,
+  toCamelCase,
   toKebabCase,
   toPascalCase,
   toSnakeCase,
   toTitleCase
-} from "./cli-j180bk07.js";
+} from "./cli-5md428hf.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -781,16 +782,15 @@ async function runAddBlockCommand({
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
 import fs6 from "fs";
 import { promises as fsp9 } from "fs";
-import path13 from "path";
+import path14 from "path";
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
-import fs3 from "fs";
-import { promises as fsp3 } from "fs";
-import { createRequire } from "module";
-import path4 from "path";
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-types.ts
 var ADMIN_VIEW_REST_SOURCE_KIND = "rest-resource";
 var ADMIN_VIEW_CORE_DATA_SOURCE_KIND = "core-data";
-var ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS = ["postType", "taxonomy"];
+var ADMIN_VIEW_CORE_DATA_ENTITY_KIND_IDS = [
+  "postType",
+  "taxonomy"
+];
 var ADMIN_VIEW_CORE_DATA_ENTITY_SEGMENT_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
 var ADMIN_VIEW_CORE_DATA_ENTITY_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/u;
 var ADMIN_VIEW_SOURCE_USAGE = "wp-typia add admin-view <name> --source <rest-resource:slug|core-data:kind/name>";
@@ -801,28 +801,20 @@ var ADMIN_VIEWS_STYLE_RTL = "build/admin-views/style-index-rtl.css";
 var ADMIN_VIEWS_PHP_GLOB = "/inc/admin-views/*.php";
 var ADMIN_VIEW_ALLOW_UNPUBLISHED_DATAVIEWS_ENV = "WP_TYPIA_ALLOW_UNPUBLISHED_DATAVIEWS";
 var ADMIN_VIEW_PUBLIC_INSTALLS_ENABLED = false;
-var require2 = createRequire(import.meta.url);
-function toCamelCase(input) {
-  const pascalCase = toPascalCase(input);
-  return `${pascalCase.charAt(0).toLowerCase()}${pascalCase.slice(1)}`;
+function isAdminViewCoreDataSource(source) {
+  return source?.kind === ADMIN_VIEW_CORE_DATA_SOURCE_KIND;
 }
-function normalizeVersionRange(value, fallback) {
-  const trimmed = value?.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 readPackageManifest(packageJsonPath) {
-  try {
-    return JSON.parse(fs3.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 readPackageManifest(packageJsonPath)?.version;
-}
+
+// ../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";
 }
@@ -832,36 +824,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(path4.join(PROJECT_TOOLS_PACKAGE_ROOT, "..", workspacePackageDirName, "package.json"));
-    if (workspaceVersion) {
-      return normalizeVersionRange(workspaceVersion, fallback);
-    }
-  }
-  try {
-    return normalizeVersionRange(readPackageManifestVersion(require2.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 = path4.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, value) {
   const trimmed = value.trim();
   if (!trimmed) {
@@ -889,12 +851,6 @@ function assertValidCoreDataEntityKind(value) {
   }
   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) {
@@ -938,6 +894,24 @@ function resolveRestResourceSource(restResources, source) {
   }
   return restResource;
 }
+function resolveAdminViewCoreDataSource(source) {
+  return isAdminViewCoreDataSource(source) ? source : undefined;
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
+import fs3 from "fs";
+import { promises as fsp3 } from "fs";
+import path5 from "path";
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-templates.ts
+import path4 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 = path4.posix.relative(adminViewDir, modulePath);
+  return relativeModulePath.startsWith(".") ? relativeModulePath : `./${relativeModulePath}`;
+}
 function buildAdminViewConfigEntry(adminViewSlug, source) {
   return [
     "\t{",
@@ -1070,8 +1044,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',
@@ -1887,12 +1861,31 @@ add_action( 'admin_menu', '${registerFunctionName}' );
 add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
 `;
 }
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
+function detectJsonIndent(source) {
+  const indentMatch = /\n([ \t]+)"/u.exec(source);
+  return indentMatch?.[1] ?? 2;
+}
 async function ensureAdminViewPackageDependencies(workspace, adminViewSource) {
-  const packageJsonPath = path4.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 = path5.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) ? {
@@ -1923,6 +1916,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}() {
@@ -1967,19 +1961,19 @@ ${snippet}
       if (!functionSource.includes(ADMIN_VIEWS_PHP_GLOB)) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, loadFunctionName, loadFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path4.basename(bootstrapPath)} for ${loadFunctionName}.`);
+          throw new Error(`Unable to repair ${path5.basename(bootstrapPath)} for ${loadFunctionName}.`);
         }
         nextSource = replacedSource;
       }
     }
-    if (!nextSource.includes(loadHook)) {
+    if (!loadHookPattern.test(nextSource)) {
       appendPhpSnippet(loadHook);
     }
     return nextSource;
   });
 }
 async function ensureAdminViewBuildScriptAnchors(workspace) {
-  const buildScriptPath = path4.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path5.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/admin-views\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -2003,11 +1997,11 @@ async function ensureAdminViewBuildScriptAnchors(workspace) {
     if (nextSource !== source) {
       return nextSource;
     }
-    throw new Error(`Unable to update ${path4.relative(workspace.projectDir, buildScriptPath)} for admin view shared entries.`);
+    throw new Error(`Unable to update ${path5.relative(workspace.projectDir, buildScriptPath)} for admin view shared entries.`);
   });
 }
 async function ensureAdminViewWebpackAnchors(workspace) {
-  const webpackConfigPath = path4.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path5.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]admin-views\/index['"]/u.test(source)) {
       return source;
@@ -2048,17 +2042,17 @@ async function ensureAdminViewWebpackAnchors(workspace) {
 	}`;
     nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path4.relative(workspace.projectDir, webpackConfigPath)} for admin view shared entries.`);
+      throw new Error(`Unable to update ${path5.relative(workspace.projectDir, webpackConfigPath)} for admin view shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveAdminViewRegistryPath(projectDir) {
-  const adminViewsDir = path4.join(projectDir, "src", "admin-views");
+  const adminViewsDir = path5.join(projectDir, "src", "admin-views");
   return [
-    path4.join(adminViewsDir, "index.ts"),
-    path4.join(adminViewsDir, "index.js")
-  ].find((candidatePath) => fs3.existsSync(candidatePath)) ?? path4.join(adminViewsDir, "index.ts");
+    path5.join(adminViewsDir, "index.ts"),
+    path5.join(adminViewsDir, "index.js")
+  ].find((candidatePath) => fs3.existsSync(candidatePath)) ?? path5.join(adminViewsDir, "index.ts");
 }
 function readAdminViewRegistrySlugs(registryPath) {
   if (!fs3.existsSync(registryPath)) {
@@ -2068,35 +2062,34 @@ function readAdminViewRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeAdminViewRegistry(projectDir, adminViewSlug) {
-  const adminViewsDir = path4.join(projectDir, "src", "admin-views");
+  const adminViewsDir = path5.join(projectDir, "src", "admin-views");
   const registryPath = resolveAdminViewRegistryPath(projectDir);
   await fsp3.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 fsp3.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 = path4.join(workspace.projectDir, "scripts", "block-config.ts");
+async function scaffoldAdminViewWorkspace(options) {
+  const {
+    adminViewSlug,
+    coreDataSource,
+    parsedSource,
+    restResource,
+    workspace
+  } = options;
+  const blockConfigPath = path5.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path4.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path4.join(workspace.projectDir, "package.json");
-  const webpackConfigPath = path4.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path5.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path5.join(workspace.projectDir, "package.json");
+  const webpackConfigPath = path5.join(workspace.projectDir, "webpack.config.js");
   const adminViewsIndexPath = resolveAdminViewRegistryPath(workspace.projectDir);
-  const adminViewDir = path4.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
-  const adminViewPhpPath = path4.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
+  const adminViewDir = path5.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
+  const adminViewPhpPath = path5.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       adminViewsIndexPath,
@@ -2111,37 +2104,63 @@ async function runAddAdminViewCommand({
   };
   try {
     await fsp3.mkdir(adminViewDir, { recursive: true });
-    await fsp3.mkdir(path4.dirname(adminViewPhpPath), { recursive: true });
+    await fsp3.mkdir(path5.dirname(adminViewPhpPath), { recursive: true });
     await ensureAdminViewPackageDependencies(workspace, parsedSource);
     await ensureAdminViewBootstrapAnchors(workspace);
     await ensureAdminViewBuildScriptAnchors(workspace);
     await ensureAdminViewWebpackAnchors(workspace);
-    await fsp3.writeFile(path4.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
-    await fsp3.writeFile(path4.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
-    await fsp3.writeFile(path4.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
-    await fsp3.writeFile(path4.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
-    await fsp3.writeFile(path4.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
-    await fsp3.writeFile(path4.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
+    await fsp3.writeFile(path5.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
+    await fsp3.writeFile(path5.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
+    await fsp3.writeFile(path5.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
+    await fsp3.writeFile(path5.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
+    await fsp3.writeFile(path5.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
+    await fsp3.writeFile(path5.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
     await fsp3.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 (error) {
     await rollbackWorkspaceMutation(mutationSnapshot);
     throw error;
   }
 }
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
+var ADD_ADMIN_VIEW_USAGE = "wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]";
+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
+  };
+}
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
 var import_typescript = __toESM(require_typescript(), 1);
 import fs4 from "fs";
 import { promises as fsp4 } from "fs";
-import path5 from "path";
+import path6 from "path";
 import {
   syncBlockMetadata as syncBlockMetadata2
 } from "@wp-typia/block-runtime/metadata-core";
@@ -2425,7 +2444,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 = path5.join(projectDir, block.typesFile);
+  const typesPath = path6.join(projectDir, block.typesFile);
   const source = await fsp4.readFile(typesPath, "utf8");
   const targetInterface = getInterfaceDeclaration(source, block.attributeTypeName);
   if (!targetInterface) {
@@ -2437,10 +2456,10 @@ async function ensureBindingTargetBlockAttributeType(projectDir, block, target)
     await fsp4.writeFile(typesPath, nextSource, "utf8");
   }
   await syncBlockMetadata2({
-    blockJsonFile: path5.join("src", "blocks", block.slug, "block.json"),
-    jsonSchemaFile: path5.join("src", "blocks", block.slug, "typia.schema.json"),
-    manifestFile: path5.join("src", "blocks", block.slug, "typia.manifest.json"),
-    openApiFile: path5.join("src", "blocks", block.slug, "typia.openapi.json"),
+    blockJsonFile: path6.join("src", "blocks", block.slug, "block.json"),
+    jsonSchemaFile: path6.join("src", "blocks", block.slug, "typia.schema.json"),
+    manifestFile: path6.join("src", "blocks", block.slug, "typia.manifest.json"),
+    openApiFile: path6.join("src", "blocks", block.slug, "typia.openapi.json"),
     projectRoot: projectDir,
     sourceTypeName: block.attributeTypeName,
     typesFile: block.typesFile
@@ -2679,7 +2698,7 @@ ${patternFunctions}
       }
     }
     if (!nextSource.includes(patternCategoryFunctionName) || !nextSource.includes(patternRegistrationFunctionName)) {
-      throw new Error(`Unable to inject pattern bootstrap functions into ${path5.basename(bootstrapPath)}.`);
+      throw new Error(`Unable to inject pattern bootstrap functions into ${path6.basename(bootstrapPath)}.`);
     }
     if (!nextSource.includes(patternCategoryHook)) {
       nextSource = `${nextSource.trimEnd()}
@@ -2867,7 +2886,7 @@ ${snippet}
       if (missingReferences.length > 0) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path5.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
+          throw new Error(`Unable to repair ${path6.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
         }
         nextSource = replacedSource;
       }
@@ -2879,7 +2898,7 @@ ${snippet}
   });
 }
 async function ensureEditorPluginBuildScriptAnchors(workspace) {
-  const buildScriptPath = path5.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path6.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/editor-plugins\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -2892,13 +2911,13 @@ async function ensureEditorPluginBuildScriptAnchors(workspace) {
 		'src/editor-plugins/index.js',
 	]`);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path5.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path6.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 async function ensureEditorPluginWebpackAnchors(workspace) {
-  const webpackConfigPath = path5.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path6.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]editor-plugins\/index['"]/u.test(source)) {
       return source;
@@ -2926,17 +2945,17 @@ async function ensureEditorPluginWebpackAnchors(workspace) {
 	}`;
     const nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path5.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path6.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveBindingSourceRegistryPath(projectDir) {
-  const bindingsDir = path5.join(projectDir, "src", "bindings");
-  return [path5.join(bindingsDir, "index.ts"), path5.join(bindingsDir, "index.js")].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path5.join(bindingsDir, "index.ts");
+  const bindingsDir = path6.join(projectDir, "src", "bindings");
+  return [path6.join(bindingsDir, "index.ts"), path6.join(bindingsDir, "index.js")].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path6.join(bindingsDir, "index.ts");
 }
 async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
-  const bindingsDir = path5.join(projectDir, "src", "bindings");
+  const bindingsDir = path6.join(projectDir, "src", "bindings");
   const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
   await fsp4.mkdir(bindingsDir, { recursive: true });
   const existingBindingSourceSlugs = fs4.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -2944,11 +2963,11 @@ async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
   await fsp4.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
 }
 function resolveEditorPluginRegistryPath(projectDir) {
-  const editorPluginsDir = path5.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path6.join(projectDir, "src", "editor-plugins");
   return [
-    path5.join(editorPluginsDir, "index.ts"),
-    path5.join(editorPluginsDir, "index.js")
-  ].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path5.join(editorPluginsDir, "index.ts");
+    path6.join(editorPluginsDir, "index.ts"),
+    path6.join(editorPluginsDir, "index.js")
+  ].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path6.join(editorPluginsDir, "index.ts");
 }
 function readEditorPluginRegistrySlugs(registryPath) {
   if (!fs4.existsSync(registryPath)) {
@@ -2958,7 +2977,7 @@ function readEditorPluginRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
-  const editorPluginsDir = path5.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path6.join(projectDir, "src", "editor-plugins");
   const registryPath = resolveEditorPluginRegistryPath(projectDir);
   await fsp4.mkdir(editorPluginsDir, { recursive: true });
   const existingEditorPluginSlugs = readWorkspaceInventory(projectDir).editorPlugins.map((entry) => entry.slug);
@@ -2976,17 +2995,17 @@ async function runAddEditorPluginCommand({
   const resolvedSlot = assertValidEditorPluginSlot(slot);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertEditorPluginDoesNotExist(workspace.projectDir, editorPluginSlug, inventory);
-  const blockConfigPath = path5.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path6.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path5.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path6.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   const editorPluginsIndexPath = resolveEditorPluginRegistryPath(workspace.projectDir);
-  const webpackConfigPath = path5.join(workspace.projectDir, "webpack.config.js");
-  const editorPluginDir = path5.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
-  const entryFilePath = path5.join(editorPluginDir, "index.tsx");
-  const surfaceFilePath = path5.join(editorPluginDir, "Surface.tsx");
-  const dataFilePath = path5.join(editorPluginDir, "data.ts");
-  const typesFilePath = path5.join(editorPluginDir, "types.ts");
-  const styleFilePath = path5.join(editorPluginDir, "style.scss");
+  const webpackConfigPath = path6.join(workspace.projectDir, "webpack.config.js");
+  const editorPluginDir = path6.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
+  const entryFilePath = path6.join(editorPluginDir, "index.tsx");
+  const surfaceFilePath = path6.join(editorPluginDir, "Surface.tsx");
+  const dataFilePath = path6.join(editorPluginDir, "data.ts");
+  const typesFilePath = path6.join(editorPluginDir, "types.ts");
+  const styleFilePath = path6.join(editorPluginDir, "style.scss");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -3032,16 +3051,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 = path5.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path6.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const patternFilePath = path5.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
+  const patternFilePath = path6.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath]),
     snapshotDirs: [],
     targetPaths: [patternFilePath]
   };
   try {
-    await fsp4.mkdir(path5.dirname(patternFilePath), { recursive: true });
+    await fsp4.mkdir(path6.dirname(patternFilePath), { recursive: true });
     await ensurePatternBootstrapAnchors(workspace);
     await fsp4.writeFile(patternFilePath, buildPatternSource(patternSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -3071,18 +3090,18 @@ async function runAddBindingSourceCommand({
     blockName
   }, workspace.workspace.namespace);
   const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
-  const blockConfigPath = path5.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path6.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
-  const bindingSourceDir = path5.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-  const serverFilePath = path5.join(bindingSourceDir, "server.php");
-  const editorFilePath = path5.join(bindingSourceDir, "editor.ts");
-  const blockJsonPath = target ? path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
+  const bindingSourceDir = path6.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
+  const serverFilePath = path6.join(bindingSourceDir, "server.php");
+  const editorFilePath = path6.join(bindingSourceDir, "editor.ts");
+  const blockJsonPath = target ? path6.join(workspace.projectDir, "src", "blocks", target.blockSlug, "block.json") : undefined;
   const targetGeneratedMetadataPaths = target ? [
-    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
-    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
-    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
-    path5.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
+    path6.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.manifest.json"),
+    path6.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.openapi.json"),
+    path6.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia.schema.json"),
+    path6.join(workspace.projectDir, "src", "blocks", target.blockSlug, "typia-validator.php")
   ] : [];
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -3090,7 +3109,7 @@ async function runAddBindingSourceCommand({
       bootstrapPath,
       bindingsIndexPath,
       ...blockJsonPath ? [blockJsonPath] : [],
-      ...targetBlock ? [path5.join(workspace.projectDir, targetBlock.typesFile)] : [],
+      ...targetBlock ? [path6.join(workspace.projectDir, targetBlock.typesFile)] : [],
       ...targetGeneratedMetadataPaths
     ]),
     snapshotDirs: [],
@@ -3120,10 +3139,10 @@ async function runAddBindingSourceCommand({
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
 import { promises as fsp5 } from "fs";
-import path8 from "path";
+import path9 from "path";
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-anchors.ts
-import path6 from "path";
+import path7 from "path";
 var REST_RESOURCE_SERVER_GLOB = "/inc/rest/*.php";
 async function ensureRestResourceBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
@@ -3171,7 +3190,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(REST_RESOURCE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path6.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
+        `Unable to patch ${path7.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(" "));
@@ -3185,7 +3204,7 @@ ${snippet}
 function assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureRestResourceSyncScriptAnchors could not patch ${path6.basename(syncRestScriptPath)}.`,
+      `ensureRestResourceSyncScriptAnchors could not patch ${path7.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(" "));
@@ -3200,7 +3219,7 @@ function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureRestResourceSyncScriptAnchors(workspace) {
-  const syncRestScriptPath = path6.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path7.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = "import { BLOCKS, type WorkspaceBlockConfig } from './block-config';";
@@ -3318,7 +3337,7 @@ async function ensureRestResourceSyncScriptAnchors(workspace) {
 }
 
 // ../wp-typia-project-tools/src/runtime/rest-resource-artifacts.ts
-import path7 from "path";
+import path8 from "path";
 import {
   defineEndpointManifest,
   syncEndpointClient,
@@ -3454,8 +3473,8 @@ async function syncRestResourceArtifacts({
   const manifest = buildRestResourceEndpointManifest(variables, methods);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas({
-      jsonSchemaFile: path7.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path7.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path8.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path8.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -3463,7 +3482,7 @@ async function syncRestResourceArtifacts({
   }
   await syncRestOpenApi({
     manifest,
-    openApiFile: path7.join(outputDir, "api.openapi.json"),
+    openApiFile: path8.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   });
@@ -4288,15 +4307,15 @@ async function runAddRestResourceCommand({
   const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
-  const blockConfigPath = path8.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path9.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const syncRestScriptPath = path8.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const restResourceDir = path8.join(workspace.projectDir, "src", "rest", restResourceSlug);
-  const typesFilePath = path8.join(restResourceDir, "api-types.ts");
-  const validatorsFilePath = path8.join(restResourceDir, "api-validators.ts");
-  const apiFilePath = path8.join(restResourceDir, "api.ts");
-  const dataFilePath = path8.join(restResourceDir, "data.ts");
-  const phpFilePath = path8.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
+  const syncRestScriptPath = path9.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const restResourceDir = path9.join(workspace.projectDir, "src", "rest", restResourceSlug);
+  const typesFilePath = path9.join(restResourceDir, "api-types.ts");
+  const validatorsFilePath = path9.join(restResourceDir, "api-validators.ts");
+  const apiFilePath = path9.join(restResourceDir, "api.ts");
+  const dataFilePath = path9.join(restResourceDir, "data.ts");
+  const phpFilePath = path9.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -4308,7 +4327,7 @@ async function runAddRestResourceCommand({
   };
   try {
     await fsp5.mkdir(restResourceDir, { recursive: true });
-    await fsp5.mkdir(path8.dirname(phpFilePath), { recursive: true });
+    await fsp5.mkdir(path9.dirname(phpFilePath), { recursive: true });
     await ensureRestResourceBootstrapAnchors(workspace);
     await ensureRestResourceSyncScriptAnchors(workspace);
     await fsp5.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
@@ -4351,7 +4370,7 @@ async function runAddRestResourceCommand({
 var import_semver = __toESM(require_semver(), 1);
 import fs5 from "fs";
 import { promises as fsp6 } from "fs";
-import path9 from "path";
+import path10 from "path";
 import { syncTypeSchemas as syncTypeSchemas2 } from "@wp-typia/block-runtime/metadata-core";
 var ABILITY_SERVER_GLOB = "/inc/abilities/*.php";
 var ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
@@ -4836,8 +4855,8 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `);
 }
 function resolveAbilityRegistryPath(projectDir) {
-  const abilitiesDir = path9.join(projectDir, "src", "abilities");
-  return [path9.join(abilitiesDir, "index.ts"), path9.join(abilitiesDir, "index.js")].find((candidatePath) => fs5.existsSync(candidatePath)) ?? path9.join(abilitiesDir, "index.ts");
+  const abilitiesDir = path10.join(projectDir, "src", "abilities");
+  return [path10.join(abilitiesDir, "index.ts"), path10.join(abilitiesDir, "index.js")].find((candidatePath) => fs5.existsSync(candidatePath)) ?? path10.join(abilitiesDir, "index.ts");
 }
 function readAbilityRegistrySlugs(registryPath) {
   if (!fs5.existsSync(registryPath)) {
@@ -4847,7 +4866,7 @@ function readAbilityRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeAbilityRegistry(projectDir, abilitySlug) {
-  const abilitiesDir = path9.join(projectDir, "src", "abilities");
+  const abilitiesDir = path10.join(projectDir, "src", "abilities");
   const registryPath = resolveAbilityRegistryPath(projectDir);
   await fsp6.mkdir(abilitiesDir, { recursive: true });
   const existingAbilitySlugs = readWorkspaceInventory(projectDir).abilities.map((entry) => entry.slug);
@@ -4979,7 +4998,7 @@ ${snippet}
   });
 }
 async function ensureAbilityPackageScripts(workspace) {
-  const packageJsonPath = path9.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path10.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp6.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
@@ -4999,7 +5018,7 @@ async function ensureAbilityPackageScripts(workspace) {
 `, "utf8");
 }
 async function ensureAbilitySyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path9.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path10.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' );";
@@ -5014,7 +5033,7 @@ async function ensureAbilitySyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAbilitiesConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path9.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path10.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(" "));
@@ -5025,7 +5044,7 @@ ${syncAbilitiesConst}`);
     if (!nextSource.includes("runSyncScript( syncAbilitiesScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path9.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path10.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(" "));
@@ -5038,7 +5057,7 @@ ${syncAbilitiesBlock}`);
   });
 }
 async function ensureAbilityBuildScriptAnchors(workspace) {
-  const buildScriptPath = path9.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path10.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     let nextSource = source;
     if (/['"]src\/abilities\/index\.(?:ts|js)['"]/u.test(nextSource)) {
@@ -5048,7 +5067,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     const match = nextSource.match(sharedEntriesPattern);
     if (!match || !match[2].includes("src/bindings/index.ts") || !match[2].includes("src/editor-plugins/index.ts")) {
       throw new Error([
-        `ensureAbilityBuildScriptAnchors could not patch ${path9.basename(buildScriptPath)}.`,
+        `ensureAbilityBuildScriptAnchors could not patch ${path10.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(" "));
@@ -5065,7 +5084,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
   });
 }
 async function ensureAbilityWebpackAnchors(workspace) {
-  const webpackConfigPath = path9.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path10.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]abilities\/index['"]/u.test(source)) {
       return source;
@@ -5096,7 +5115,7 @@ $2`);
     const match = source.match(sharedEntriesPattern);
     if (!match || !match[1].includes("bindings/index") || !match[1].includes("editor-plugins/index")) {
       throw new Error([
-        `ensureAbilityWebpackAnchors could not patch ${path9.basename(webpackConfigPath)}.`,
+        `ensureAbilityWebpackAnchors could not patch ${path10.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(" "));
@@ -5126,20 +5145,20 @@ async function runAddAbilityCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
-  const blockConfigPath = path9.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path10.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path9.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path9.join(workspace.projectDir, "package.json");
-  const syncAbilitiesScriptPath = path9.join(workspace.projectDir, "scripts", "sync-abilities.ts");
-  const syncProjectScriptPath = path9.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const webpackConfigPath = path9.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path10.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path10.join(workspace.projectDir, "package.json");
+  const syncAbilitiesScriptPath = path10.join(workspace.projectDir, "scripts", "sync-abilities.ts");
+  const syncProjectScriptPath = path10.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const webpackConfigPath = path10.join(workspace.projectDir, "webpack.config.js");
   const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
-  const abilityDir = path9.join(workspace.projectDir, "src", "abilities", abilitySlug);
-  const configFilePath = path9.join(abilityDir, "ability.config.json");
-  const typesFilePath = path9.join(abilityDir, "types.ts");
-  const dataFilePath = path9.join(abilityDir, "data.ts");
-  const clientFilePath = path9.join(abilityDir, "client.ts");
-  const phpFilePath = path9.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
+  const abilityDir = path10.join(workspace.projectDir, "src", "abilities", abilitySlug);
+  const configFilePath = path10.join(abilityDir, "ability.config.json");
+  const typesFilePath = path10.join(abilityDir, "types.ts");
+  const dataFilePath = path10.join(abilityDir, "data.ts");
+  const clientFilePath = path10.join(abilityDir, "client.ts");
+  const phpFilePath = path10.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -5156,7 +5175,7 @@ async function runAddAbilityCommand({
   };
   try {
     await fsp6.mkdir(abilityDir, { recursive: true });
-    await fsp6.mkdir(path9.dirname(phpFilePath), { recursive: true });
+    await fsp6.mkdir(path10.dirname(phpFilePath), { recursive: true });
     await ensureAbilityBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     await ensureAbilityPackageScripts(workspace);
@@ -5197,11 +5216,11 @@ async function runAddAbilityCommand({
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
 import { promises as fsp8 } from "fs";
-import path12 from "path";
+import path13 from "path";
 
 // ../wp-typia-project-tools/src/runtime/ai-feature-artifacts.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest2,
   syncEndpointClient as syncEndpointClient2,
@@ -5227,7 +5246,7 @@ function normalizeGeneratedArtifactContent(content) {
 }
 async function reconcileGeneratedArtifact(options) {
   if (!options.check) {
-    await mkdir(path10.dirname(options.filePath), {
+    await mkdir(path11.dirname(options.filePath), {
       recursive: true
     });
     await writeFile(options.filePath, options.content, "utf8");
@@ -5299,8 +5318,8 @@ async function syncAiFeatureRestArtifacts({
   const manifest = buildAiFeatureEndpointManifest(variables);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas3({
-      jsonSchemaFile: path10.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path10.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path11.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path11.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -5308,7 +5327,7 @@ async function syncAiFeatureRestArtifacts({
   }
   await syncRestOpenApi2({
     manifest,
-    openApiFile: path10.join(outputDir, "api.openapi.json"),
+    openApiFile: path11.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   }, executionOptions);
@@ -5326,19 +5345,19 @@ async function syncAiFeatureSchemaArtifact({
   outputDir,
   projectDir
 }) {
-  const sourceSchemaPath = path10.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
+  const sourceSchemaPath = path11.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
   const responseSchema = assertJsonObject(JSON.parse(await readFile(sourceSchemaPath, "utf8")), sourceSchemaPath);
   const aiSchema = projectWordPressAiSchema(responseSchema);
   await reconcileGeneratedArtifact({
     check,
     content: `${JSON.stringify(aiSchema, null, 2)}
 `,
-    filePath: path10.join(projectDir, aiSchemaFile),
+    filePath: path11.join(projectDir, aiSchemaFile),
     label: "AI feature schema"
   });
   return {
     aiSchema,
-    aiSchemaPath: path10.join(projectDir, aiSchemaFile),
+    aiSchemaPath: path11.join(projectDir, aiSchemaFile),
     check,
     sourceSchemaPath
   };
@@ -5662,7 +5681,7 @@ main().catch( ( error ) => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-anchors.ts
 import { promises as fsp7 } from "fs";
-import path11 from "path";
+import path12 from "path";
 var AI_FEATURE_SERVER_GLOB = "/inc/ai-features/*.php";
 async function ensureAiFeatureBootstrapAnchors(workspace) {
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
@@ -5710,7 +5729,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(AI_FEATURE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path11.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
+        `Unable to patch ${path12.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(" "));
@@ -5722,7 +5741,7 @@ ${snippet}
   });
 }
 async function ensureAiFeaturePackageScripts(workspace) {
-  const packageJsonPath = path11.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path12.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp7.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
@@ -5750,7 +5769,7 @@ async function ensureAiFeaturePackageScripts(workspace) {
   };
 }
 async function ensureAiFeatureSyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path11.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path12.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' );";
@@ -5765,7 +5784,7 @@ async function ensureAiFeatureSyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAiConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path11.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path12.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(" "));
@@ -5776,7 +5795,7 @@ ${syncAiConst}`);
     if (!nextSource.includes("runSyncScript( syncAiScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path11.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path12.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(" "));
@@ -5791,7 +5810,7 @@ ${syncAiBlock}`);
 function assertSyncRestAnchor2(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureAiFeatureSyncRestAnchors could not patch ${path11.basename(syncRestScriptPath)}.`,
+      `ensureAiFeatureSyncRestAnchors could not patch ${path12.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(" "));
@@ -5806,7 +5825,7 @@ function replaceRequiredSyncRestSource2(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureAiFeatureSyncRestAnchors(workspace) {
-  const syncRestScriptPath = path11.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path12.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = [
@@ -6323,18 +6342,18 @@ async function runAddAiFeatureCommand({
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
-  const blockConfigPath = path12.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const packageJsonPath = path12.join(workspace.projectDir, "package.json");
-  const syncAiScriptPath = path12.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
-  const syncProjectScriptPath = path12.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const syncRestScriptPath = path12.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const aiFeatureDir = path12.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
-  const typesFilePath = path12.join(aiFeatureDir, "api-types.ts");
-  const validatorsFilePath = path12.join(aiFeatureDir, "api-validators.ts");
-  const apiFilePath = path12.join(aiFeatureDir, "api.ts");
-  const dataFilePath = path12.join(aiFeatureDir, "data.ts");
-  const phpFilePath = path12.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
+  const packageJsonPath = path13.join(workspace.projectDir, "package.json");
+  const syncAiScriptPath = path13.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
+  const syncProjectScriptPath = path13.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncRestScriptPath = path13.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const aiFeatureDir = path13.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
+  const typesFilePath = path13.join(aiFeatureDir, "api-types.ts");
+  const validatorsFilePath = path13.join(aiFeatureDir, "api-validators.ts");
+  const apiFilePath = path13.join(aiFeatureDir, "api.ts");
+  const dataFilePath = path13.join(aiFeatureDir, "data.ts");
+  const phpFilePath = path13.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -6349,7 +6368,7 @@ async function runAddAiFeatureCommand({
   };
   try {
     await fsp8.mkdir(aiFeatureDir, { recursive: true });
-    await fsp8.mkdir(path12.dirname(phpFilePath), { recursive: true });
+    await fsp8.mkdir(path13.dirname(phpFilePath), { recursive: true });
     await ensureAiFeatureBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
@@ -6364,7 +6383,7 @@ async function runAddAiFeatureCommand({
     const pascalCase = toPascalCase(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
-      outputDir: path12.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path13.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir,
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
@@ -6377,7 +6396,7 @@ async function runAddAiFeatureCommand({
     });
     await syncAiFeatureSchemaArtifact({
       aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
-      outputDir: path12.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path13.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -6798,7 +6817,7 @@ ${VARIATIONS_CALL_LINE}
       }
     }
     if (!hasExecutablePattern(nextSource, VARIATIONS_CALL_PATTERN)) {
-      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path13.basename(blockIndexPath)}.`);
+      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path14.basename(blockIndexPath)}.`);
     }
     return nextSource;
   });
@@ -6828,7 +6847,7 @@ ${BLOCK_STYLES_CALL_LINE}
       }
     }
     if (!hasExecutablePattern(nextSource, BLOCK_STYLES_CALL_PATTERN)) {
-      throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path13.basename(blockIndexPath)}.`);
+      throw new Error(`Unable to inject ${BLOCK_STYLES_CALL_LINE} into ${path14.basename(blockIndexPath)}.`);
     }
     return nextSource;
   });
@@ -6845,7 +6864,7 @@ ${nextSource}`;
         SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN
       ]);
       if (!callRange) {
-        throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path13.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
+        throw new Error(`Unable to inject ${BLOCK_TRANSFORMS_CALL_LINE} into ${path14.basename(blockIndexPath)} because it does not expose a scaffold registration settings object.`);
       }
       nextSource = [
         nextSource.slice(0, callRange.start),
@@ -6858,42 +6877,42 @@ ${nextSource}`;
   });
 }
 async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
-  const variationsDir = path13.join(projectDir, "src", "blocks", blockSlug, "variations");
-  const variationsIndexPath = path13.join(variationsDir, "index.ts");
+  const variationsDir = path14.join(projectDir, "src", "blocks", blockSlug, "variations");
+  const variationsIndexPath = path14.join(variationsDir, "index.ts");
   await fsp9.mkdir(variationsDir, { recursive: true });
   const existingVariationSlugs = fs6.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 fsp9.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
 async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
-  const stylesDir = path13.join(projectDir, "src", "blocks", blockSlug, "styles");
-  const stylesIndexPath = path13.join(stylesDir, "index.ts");
+  const stylesDir = path14.join(projectDir, "src", "blocks", blockSlug, "styles");
+  const stylesIndexPath = path14.join(stylesDir, "index.ts");
   await fsp9.mkdir(stylesDir, { recursive: true });
   const existingStyleSlugs = fs6.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 fsp9.writeFile(stylesIndexPath, buildBlockStyleIndexSource(nextStyleSlugs), "utf8");
 }
 async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug) {
-  const transformsDir = path13.join(projectDir, "src", "blocks", blockSlug, "transforms");
-  const transformsIndexPath = path13.join(transformsDir, "index.ts");
+  const transformsDir = path14.join(projectDir, "src", "blocks", blockSlug, "transforms");
+  const transformsIndexPath = path14.join(transformsDir, "index.ts");
   await fsp9.mkdir(transformsDir, { recursive: true });
   const existingTransformSlugs = fs6.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 fsp9.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
 function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  const stylePath = path13.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
+  const stylePath = path14.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
   if (fs6.existsSync(stylePath)) {
-    throw new Error(`A block style already exists at ${path13.relative(projectDir, stylePath)}. Choose a different name.`);
+    throw new Error(`A block style already exists at ${path14.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 = path13.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
+  const transformPath = path14.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
   if (fs6.existsSync(transformPath)) {
-    throw new Error(`A block transform already exists at ${path13.relative(projectDir, transformPath)}. Choose a different name.`);
+    throw new Error(`A block transform already exists at ${path14.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.`);
@@ -6939,11 +6958,11 @@ async function runAddVariationCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
-  const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const variationsDir = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
-  const variationFilePath = path13.join(variationsDir, `${variationSlug}.ts`);
-  const variationsIndexPath = path13.join(variationsDir, "index.ts");
+  const blockConfigPath = path14.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path14.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const variationsDir = path14.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
+  const variationFilePath = path14.join(variationsDir, `${variationSlug}.ts`);
+  const variationsIndexPath = path14.join(variationsDir, "index.ts");
   const shouldRemoveVariationsDirOnRollback = !fs6.existsSync(variationsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -6986,11 +7005,11 @@ async function runAddBlockStyleCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertBlockStyleDoesNotExist(workspace.projectDir, blockSlug, styleSlug, inventory);
-  const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const stylesDir = path13.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
-  const styleFilePath = path13.join(stylesDir, `${styleSlug}.ts`);
-  const stylesIndexPath = path13.join(stylesDir, "index.ts");
+  const blockConfigPath = path14.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path14.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const stylesDir = path14.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
+  const styleFilePath = path14.join(stylesDir, `${styleSlug}.ts`);
+  const stylesIndexPath = path14.join(stylesDir, "index.ts");
   const shouldRemoveStylesDirOnRollback = !fs6.existsSync(stylesDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -7035,11 +7054,11 @@ async function runAddBlockTransformCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, target.blockSlug);
   assertBlockTransformDoesNotExist(workspace.projectDir, target.blockSlug, transformSlug, inventory);
-  const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path13.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
-  const transformsDir = path13.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
-  const transformFilePath = path13.join(transformsDir, `${transformSlug}.ts`);
-  const transformsIndexPath = path13.join(transformsDir, "index.ts");
+  const blockConfigPath = path14.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path14.join(workspace.projectDir, "src", "blocks", target.blockSlug, "index.tsx");
+  const transformsDir = path14.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
+  const transformFilePath = path14.join(transformsDir, `${transformSlug}.ts`);
+  const transformsIndexPath = path14.join(transformsDir, "index.ts");
   const shouldRemoveTransformsDirOnRollback = !fs6.existsSync(transformsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
@@ -7101,7 +7120,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 = path13.relative(workspace.projectDir, blockJsonPath);
+  const blockJsonRelativePath = path14.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}".`);
@@ -7146,4 +7165,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=8932DC6C8A5BAD5564756E2164756E21
+//# debugId=DE205F0F5620636264756E2164756E21