wp-typia 0.22.0 → 0.22.2

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

@@ -4,6 +4,7 @@ import {
   REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY,
   assertExternalLayerCompositionOptions,
   copyInterpolatedDirectory,
+  createScaffoldCompatibilityConfig,
   getDefaultAnswers,
   listInterpolatedDirectoryOutputs,
   normalizeOptionalCliString,
@@ -20,7 +21,7 @@ import {
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-1w5vkye4.js";
+} from "./cli-kww2sraq.js";
 import {
   DEFAULT_WORDPRESS_ABILITIES_VERSION,
   DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
@@ -28,11 +29,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-6hcbjvym.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
@@ -45,7 +47,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 +90,12 @@ import {
   resolveWorkspaceBlock,
   rollbackWorkspaceMutation,
   snapshotWorkspaceFiles,
+  toCamelCase,
   toKebabCase,
   toPascalCase,
   toSnakeCase,
   toTitleCase
-} from "./cli-j180bk07.js";
+} from "./cli-smzkbfna.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -781,16 +783,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 +802,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 +825,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 +852,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 +895,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 +1045,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 +1862,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 +1917,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 +1962,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 +1998,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 +2043,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 +2063,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 +2105,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 +2445,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 +2457,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 +2699,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 +2887,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 +2899,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 +2912,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 +2946,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 +2964,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 +2978,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 +2996,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 +3052,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 +3091,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 +3110,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 +3140,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 +3191,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 +3205,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 +3220,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 +3338,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 +3474,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 +3483,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 +4308,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 +4328,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 +4371,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 +4856,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 +4867,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 +4999,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 +5019,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 +5034,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 +5045,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 +5058,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 +5068,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 +5085,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 +5116,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 +5146,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 +5176,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 +5217,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 +5247,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 +5319,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 +5328,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 +5346,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
   };
@@ -5416,6 +5436,45 @@ export interface ${pascalCase}AiFeatureResponse {
 	result: ${pascalCase}AiFeatureResult;
 	telemetry: ${pascalCase}AiFeatureTelemetry;
 }
+
+export type ${pascalCase}AiFeatureSupportProbeMode = 'request-time';
+
+export type ${pascalCase}AiFeatureUnavailableErrorCode =
+	'ai_client_unavailable';
+
+export type ${pascalCase}AiFeatureUnavailableReasonCode =
+	| 'missing-wordpress-ai-client'
+	| 'request-time-support-probe';
+
+export interface ${pascalCase}AiFeatureSupportReason {
+	code: ${pascalCase}AiFeatureUnavailableReasonCode;
+	label: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	message: string & tags.MinLength< 1 > & tags.MaxLength< 4000 >;
+}
+
+export interface ${pascalCase}AiFeatureSupportMetadata {
+	featureLabel: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	featureSlug: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	compatibility: {
+		hardMinimums: {
+			php?: string;
+			wordpress?: string;
+		};
+		mode: 'baseline' | 'optional' | 'required';
+		optionalFeatureIds: string[];
+		optionalFeatures: string[];
+		requiredFeatureIds: string[];
+		requiredFeatures: string[];
+		runtimeGates: string[];
+	};
+	supportProbe: {
+		endpointMethod: 'POST';
+		endpointPath: string & tags.MinLength< 1 > & tags.MaxLength< 200 >;
+		mode: ${pascalCase}AiFeatureSupportProbeMode;
+		unavailableErrorCode: ${pascalCase}AiFeatureUnavailableErrorCode;
+	};
+	unavailableReasons: ${pascalCase}AiFeatureSupportReason[];
+}
 `;
 }
 function buildAiFeatureValidatorsSource(aiFeatureSlug) {
@@ -5451,6 +5510,8 @@ export const apiValidators = {
 }
 function buildAiFeatureApiSource(aiFeatureSlug) {
   const pascalCase = toPascalCase(aiFeatureSlug);
+  const compatibility = createScaffoldCompatibilityConfig(resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY));
+  const title = toTitleCase(aiFeatureSlug);
   return `import {
 	callEndpoint,
 	resolveRestRouteUrl,
@@ -5458,6 +5519,7 @@ function buildAiFeatureApiSource(aiFeatureSlug) {
 
 import type {
 	${pascalCase}AiFeatureRequest,
+	${pascalCase}AiFeatureSupportMetadata,
 } from './api-types';
 import {
 	run${pascalCase}AiFeatureEndpoint,
@@ -5484,6 +5546,14 @@ function resolveRestNonce( fallback?: string ): string | undefined {
 		: undefined;
 }
 
+function isPlainObject( value: unknown ): value is Record< string, unknown > {
+	return (
+		!! value &&
+		typeof value === 'object' &&
+		! Array.isArray( value )
+	);
+}
+
 export const aiFeatureRunEndpoint = {
 	...run${pascalCase}AiFeatureEndpoint,
 	buildRequestOptions: () => {
@@ -5499,6 +5569,63 @@ export const aiFeatureRunEndpoint = {
 	},
 };
 
+export const aiFeatureSupportMetadata = {
+	compatibility: ${JSON.stringify(compatibility, null, "\t")},
+	featureLabel: ${quoteTsString(title)},
+	featureSlug: ${quoteTsString(aiFeatureSlug)},
+	supportProbe: {
+		endpointMethod: 'POST',
+		endpointPath: aiFeatureRunEndpoint.path,
+		mode: 'request-time',
+		unavailableErrorCode: 'ai_client_unavailable',
+	},
+	unavailableReasons: [
+		{
+			code: 'missing-wordpress-ai-client',
+			label: 'WordPress AI Client unavailable',
+			message:
+				'This AI feature stays disabled until the WordPress AI Client is available on the site.',
+		},
+		{
+			code: 'request-time-support-probe',
+			label: 'Support is checked at request time',
+			message:
+				'Support is verified when the feature runs, so editor and admin UIs should degrade gracefully when the site rejects the request.',
+		},
+	],
+} satisfies ${pascalCase}AiFeatureSupportMetadata;
+
+export function getAiFeatureSupportHintLines() {
+	return aiFeatureSupportMetadata.unavailableReasons.map(
+		( reason ) => reason.message
+	);
+}
+
+export function isAiFeatureSupportUnavailableError( error: unknown ) {
+	if ( ! isPlainObject( error ) ) {
+		return false;
+	}
+
+	const data = isPlainObject( error.data ) ? error.data : undefined;
+	return (
+		error.code === aiFeatureSupportMetadata.supportProbe.unavailableErrorCode ||
+		data?.status === 501
+	);
+}
+
+export function resolveAiFeatureUnavailableMessage( error: unknown ) {
+	if (
+		isPlainObject( error ) &&
+		typeof error.message === 'string' &&
+		error.message.length > 0
+	) {
+		return error.message;
+	}
+
+	return aiFeatureSupportMetadata.unavailableReasons[ 0 ]?.message ??
+		'This AI feature is currently unavailable.';
+}
+
 export function runAiFeature( request: ${pascalCase}AiFeatureRequest ) {
 	return callEndpoint( aiFeatureRunEndpoint, request );
 }
@@ -5517,6 +5644,10 @@ import type {
 } from './api-types';
 import {
 	aiFeatureRunEndpoint,
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
 } from './api';
 
 export type UseRun${pascalCase}AiFeatureMutationOptions =
@@ -5531,6 +5662,13 @@ export function useRun${pascalCase}AiFeatureMutation(
 ) {
 	return useEndpointMutation( aiFeatureRunEndpoint, options );
 }
+
+export {
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
+};
 `;
 }
 function buildAiFeatureSyncScriptSource() {
@@ -5662,7 +5800,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 +5848,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 +5860,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 +5888,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 +5903,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 +5914,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 +5929,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 +5944,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 = [
@@ -5943,18 +6081,40 @@ function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain
   const normalizeSchemaFunctionName = `${phpPrefix}_${aiFeaturePhpId}_sanitize_ai_feature_schema`;
   const validatePayloadFunctionName = `${phpPrefix}_${aiFeaturePhpId}_validate_ai_feature_payload`;
   const canManageFunctionName = `${phpPrefix}_${aiFeaturePhpId}_can_manage_ai_feature`;
+  const normalizePromptPayloadFunctionName = `${phpPrefix}_${aiFeaturePhpId}_normalize_ai_feature_prompt_payload`;
   const buildPromptFunctionName = `${phpPrefix}_${aiFeaturePhpId}_build_ai_feature_prompt`;
+  const resolvePromptOptionsFunctionName = `${phpPrefix}_${aiFeaturePhpId}_resolve_ai_feature_prompt_options`;
   const normalizeProviderTypeFunctionName = `${phpPrefix}_${aiFeaturePhpId}_normalize_provider_type`;
   const buildTelemetryFunctionName = `${phpPrefix}_${aiFeaturePhpId}_build_ai_feature_telemetry`;
+  const resolveUnavailableMessageFunctionName = `${phpPrefix}_${aiFeaturePhpId}_resolve_ai_feature_unavailable_message`;
   const isSupportedFunctionName = `${phpPrefix}_${aiFeaturePhpId}_is_ai_feature_supported`;
   const adminNoticeFunctionName = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_admin_notice`;
   const handlerFunctionName = `${phpPrefix}_${aiFeaturePhpId}_handle_run_ai_feature`;
   const registerRoutesFunctionName = `${phpPrefix}_${aiFeaturePhpId}_register_ai_feature_routes`;
+  const permissionFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_permission`;
+  const promptPayloadFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_prompt_payload`;
+  const promptFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_prompt`;
+  const promptOptionsFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_prompt_options`;
+  const adminNoticeMessageFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_admin_notice_message`;
+  const unavailableMessageFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_unavailable_message`;
+  const telemetryFilterHook = `${phpPrefix}_${aiFeaturePhpId}_ai_feature_telemetry`;
   return `<?php
 if ( ! defined( 'ABSPATH' ) ) {
 	return;
 }
 
+/*
+ * Customization hooks for the ${aiFeatureTitle} AI feature:
+ *
+ * - ${quotePhpString(permissionFilterHook)} filters the default current_user_can( 'edit_posts' ) capability check.
+ * - ${quotePhpString(promptPayloadFilterHook)} filters the validated request payload array before prompt serialization.
+ * - ${quotePhpString(promptFilterHook)} filters the final prompt string after payload normalization.
+ * - ${quotePhpString(promptOptionsFilterHook)} filters prompt options with \`temperature\` and \`modelPreference\` keys.
+ * - ${quotePhpString(adminNoticeMessageFilterHook)} filters the wp-admin notice shown when AI support is unavailable.
+ * - ${quotePhpString(unavailableMessageFilterHook)} filters REST-facing unavailable messages by reason code.
+ * - ${quotePhpString(telemetryFilterHook)} filters the response telemetry array before schema validation. Return a schema-compatible array.
+ */
+
 if ( ! function_exists( '${loadSchemaFunctionName}' ) ) {
 	function ${loadSchemaFunctionName}( $schema_name ) {
 		$project_root = dirname( __DIR__, 2 );
@@ -6021,17 +6181,111 @@ if ( ! function_exists( '${validatePayloadFunctionName}' ) ) {
 }
 
 if ( ! function_exists( '${canManageFunctionName}' ) ) {
-	function ${canManageFunctionName}() {
-		return current_user_can( 'edit_posts' );
+	function ${canManageFunctionName}( WP_REST_Request $request = null ) {
+		$permission = apply_filters(
+			${quotePhpString(permissionFilterHook)},
+			current_user_can( 'edit_posts' ),
+			$request
+		);
+		if ( is_wp_error( $permission ) ) {
+			return $permission;
+		}
+		return (bool) $permission;
+	}
+}
+
+if ( ! function_exists( '${normalizePromptPayloadFunctionName}' ) ) {
+	function ${normalizePromptPayloadFunctionName}( array $payload ) {
+		$normalized_payload = apply_filters(
+			${quotePhpString(promptPayloadFilterHook)},
+			$payload
+		);
+		return is_array( $normalized_payload ) ? $normalized_payload : $payload;
 	}
 }
 
 if ( ! function_exists( '${buildPromptFunctionName}' ) ) {
 	function ${buildPromptFunctionName}( array $payload ) {
-		return sprintf(
+		$normalized_payload = ${normalizePromptPayloadFunctionName}( $payload );
+		$prompt = sprintf(
 			'You are helping with the %1$s AI workflow. Read the JSON request payload and return JSON that matches the provided schema. Request payload: %2$s',
 			${quotePhpString(aiFeatureTitle)},
-			wp_json_encode( $payload )
+			wp_json_encode( $normalized_payload )
+		);
+		$filtered_prompt = apply_filters(
+			${quotePhpString(promptFilterHook)},
+			$prompt,
+			$normalized_payload,
+			$payload
+		);
+		return is_string( $filtered_prompt ) && '' !== $filtered_prompt ? $filtered_prompt : $prompt;
+	}
+}
+
+if ( ! function_exists( '${resolvePromptOptionsFunctionName}' ) ) {
+	function ${resolvePromptOptionsFunctionName}( array $payload = array() ) {
+		$options = apply_filters(
+			${quotePhpString(promptOptionsFilterHook)},
+			array(
+				'modelPreference' => array(),
+				'temperature'     => 0.2,
+			),
+			$payload
+		);
+		if ( ! is_array( $options ) ) {
+			$options = array();
+		}
+
+		$temperature = 0.2;
+		if ( array_key_exists( 'temperature', $options ) ) {
+			if ( null === $options['temperature'] ) {
+				$temperature = null;
+			} elseif ( is_numeric( $options['temperature'] ) ) {
+				$temperature = (float) $options['temperature'];
+			}
+		}
+
+		$model_preferences = array();
+		if ( isset( $options['modelPreference'] ) ) {
+			$raw_model_preferences = $options['modelPreference'];
+			if ( is_string( $raw_model_preferences ) && '' !== $raw_model_preferences ) {
+				$model_preferences = array( $raw_model_preferences );
+			} elseif ( is_array( $raw_model_preferences ) ) {
+				$model_preferences = array_values(
+					array_filter(
+						array_map(
+							static function ( $candidate ) {
+								if ( is_string( $candidate ) && '' !== $candidate ) {
+									return $candidate;
+								}
+								if ( ! is_array( $candidate ) ) {
+									return null;
+								}
+
+								$normalized = array_values(
+									array_filter(
+										$candidate,
+										static function ( $value ) {
+											return is_string( $value ) && '' !== $value;
+										}
+									)
+								);
+
+								return count( $normalized ) > 0 ? $normalized : null;
+							},
+							$raw_model_preferences
+						),
+						static function ( $candidate ) {
+							return null !== $candidate;
+						}
+					)
+				);
+			}
+		}
+
+		return array(
+			'modelPreference' => $model_preferences,
+			'temperature'     => $temperature,
 		);
 	}
 }
@@ -6047,7 +6301,7 @@ if ( ! function_exists( '${normalizeProviderTypeFunctionName}' ) ) {
 }
 
 if ( ! function_exists( '${buildTelemetryFunctionName}' ) ) {
-	function ${buildTelemetryFunctionName}( $result ) {
+	function ${buildTelemetryFunctionName}( $result, array $payload = array(), array $normalized_result = array() ) {
 		if (
 			! is_object( $result ) ||
 			! method_exists( $result, 'getId' ) ||
@@ -6107,47 +6361,95 @@ if ( ! function_exists( '${buildTelemetryFunctionName}' ) ) {
 			}
 		}
 
-		return $telemetry;
+		$filtered_telemetry = apply_filters(
+			${quotePhpString(telemetryFilterHook)},
+			$telemetry,
+			$result,
+			$payload,
+			$normalized_result
+		);
+		return is_array( $filtered_telemetry ) ? $filtered_telemetry : $telemetry;
+	}
+}
+
+if ( ! function_exists( '${resolveUnavailableMessageFunctionName}' ) ) {
+	function ${resolveUnavailableMessageFunctionName}( $message, $reason, array $context = array() ) {
+		$filtered_message = apply_filters(
+			${quotePhpString(unavailableMessageFilterHook)},
+			$message,
+			$reason,
+			$context
+		);
+		return is_string( $filtered_message ) && '' !== $filtered_message ? $filtered_message : $message;
 	}
 }
 
 if ( ! function_exists( '${isSupportedFunctionName}' ) ) {
-	function ${isSupportedFunctionName}() {
+	function ${isSupportedFunctionName}( array $payload = array(), $cache_result = true ) {
 		static $is_supported = null;
-		if ( null !== $is_supported ) {
+		$use_cache = $cache_result && count( $payload ) === 0;
+		if ( $use_cache && null !== $is_supported ) {
 			return $is_supported;
 		}
 
 		if ( ! function_exists( 'wp_ai_client_prompt' ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
 		}
 
 		$schema = ${loadAiSchemaFunctionName}();
 		if ( ! is_array( $schema ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
 		}
 
 		$prompt = wp_ai_client_prompt( 'AI feature support probe.' );
 		if ( ! is_object( $prompt ) || ! method_exists( $prompt, 'as_json_response' ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
+		}
+		$prompt_options = ${resolvePromptOptionsFunctionName}( $payload );
+		if (
+			array_key_exists( 'temperature', $prompt_options ) &&
+			null !== $prompt_options['temperature'] &&
+			method_exists( $prompt, 'using_temperature' )
+		) {
+			$prompt = $prompt->using_temperature( $prompt_options['temperature'] );
+		}
+		if (
+			! empty( $prompt_options['modelPreference'] ) &&
+			method_exists( $prompt, 'using_model_preference' )
+		) {
+			$prompt = $prompt->using_model_preference( ...$prompt_options['modelPreference'] );
 		}
 
 		$structured_prompt = $prompt->as_json_response( $schema );
 		if ( ! is_object( $structured_prompt ) ) {
-			$is_supported = false;
-			return $is_supported;
+			if ( $use_cache ) {
+				$is_supported = false;
+			}
+			return false;
 		}
 
 		if ( method_exists( $structured_prompt, 'is_supported_for_text_generation' ) ) {
-			$is_supported = (bool) $structured_prompt->is_supported_for_text_generation();
-			return $is_supported;
+			$supported = (bool) $structured_prompt->is_supported_for_text_generation();
+			if ( $use_cache ) {
+				$is_supported = $supported;
+			}
+			return $supported;
 		}
 
-		$is_supported = method_exists( $structured_prompt, 'generate_text_result' );
-		return $is_supported;
+		$supported = method_exists( $structured_prompt, 'generate_text_result' );
+		if ( $use_cache ) {
+			$is_supported = $supported;
+		}
+		return $supported;
 	}
 }
 
@@ -6162,6 +6464,18 @@ if ( ! function_exists( '${adminNoticeFunctionName}' ) ) {
 			__( 'The %s AI feature is optional and remains disabled until the WordPress AI Client is available with structured text generation support for the generated schema.', ${quotePhpString(textDomain)} ),
 			${quotePhpString(aiFeatureTitle)}
 		);
+		$filtered_message = apply_filters(
+			${quotePhpString(adminNoticeMessageFilterHook)},
+			$message,
+			array(
+				'featureSlug'  => ${quotePhpString(aiFeatureSlug)},
+				'featureTitle' => ${quotePhpString(aiFeatureTitle)},
+				'namespace'    => ${quotePhpString(namespace)},
+			)
+		);
+		if ( is_string( $filtered_message ) && '' !== $filtered_message ) {
+			$message = $filtered_message;
+		}
 		printf( '<div class="notice notice-warning"><p>%s</p></div>', esc_html( $message ) );
 	}
 }
@@ -6173,10 +6487,16 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			return $payload;
 		}
 
-		if ( ! ${isSupportedFunctionName}() ) {
+		if ( ! ${isSupportedFunctionName}( $payload, false ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The WordPress AI Client is unavailable or does not support this feature endpoint.',
+				${resolveUnavailableMessageFunctionName}(
+					'The WordPress AI Client is unavailable or does not support this feature endpoint.',
+					'support_probe_failed',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -6190,22 +6510,45 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			);
 		}
 
+		$prompt_options = ${resolvePromptOptionsFunctionName}( $payload );
 		$prompt = wp_ai_client_prompt( ${buildPromptFunctionName}( $payload ) );
 		if ( ! is_object( $prompt ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The WordPress AI Client prompt builder is unavailable on this site.',
+				${resolveUnavailableMessageFunctionName}(
+					'The WordPress AI Client prompt builder is unavailable on this site.',
+					'prompt_builder_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
 
-		if ( method_exists( $prompt, 'using_temperature' ) ) {
-			$prompt = $prompt->using_temperature( 0.2 );
+		if (
+			array_key_exists( 'temperature', $prompt_options ) &&
+			null !== $prompt_options['temperature'] &&
+			method_exists( $prompt, 'using_temperature' )
+		) {
+			$prompt = $prompt->using_temperature( $prompt_options['temperature'] );
+		}
+		if (
+			! empty( $prompt_options['modelPreference'] ) &&
+			method_exists( $prompt, 'using_model_preference' )
+		) {
+			$prompt = $prompt->using_model_preference( ...$prompt_options['modelPreference'] );
 		}
 		if ( ! method_exists( $prompt, 'as_json_response' ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client does not expose as_json_response().',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client does not expose as_json_response().',
+					'as_json_response_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -6214,7 +6557,13 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 		if ( ! is_object( $structured_prompt ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client could not prepare a structured-output prompt.',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client could not prepare a structured-output prompt.',
+					'structured_prompt_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -6225,14 +6574,26 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 		) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client provider or model does not support this structured-output feature.',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client provider or model does not support this structured-output feature.',
+					'text_generation_unsupported',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
 		if ( ! method_exists( $structured_prompt, 'generate_text_result' ) ) {
 			return new WP_Error(
 				'ai_client_unavailable',
-				'The current WordPress AI Client does not expose generate_text_result() after as_json_response().',
+				${resolveUnavailableMessageFunctionName}(
+					'The current WordPress AI Client does not expose generate_text_result() after as_json_response().',
+					'generate_text_result_missing',
+					array(
+						'featureSlug' => ${quotePhpString(aiFeatureSlug)},
+					)
+				),
 				array( 'status' => 501 )
 			);
 		}
@@ -6267,7 +6628,7 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			);
 		}
 
-		$telemetry = ${buildTelemetryFunctionName}( $result );
+		$telemetry = ${buildTelemetryFunctionName}( $result, $payload, $normalized_result );
 		if ( is_wp_error( $telemetry ) ) {
 			return $telemetry;
 		}
@@ -6323,18 +6684,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 +6710,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 +6725,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 +6738,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 +7159,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 +7189,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 +7206,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 +7219,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 +7300,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 +7347,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 +7396,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 +7462,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 +7507,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=8932DC6C8A5BAD5564756E2164756E21
+//# debugId=FE993C1947A36DF464756E2164756E21