wp-typia 0.22.1 → 0.22.3

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

@@ -36308,93 +36308,192 @@ function getMutableBlockHooks(blockJson, blockJsonRelativePath) {
   }
   return blockHooks;
 }
-function assertVariationDoesNotExist(projectDir, blockSlug, variationSlug, inventory) {
-  const variationPath = path12.join(projectDir, "src", "blocks", blockSlug, "variations", `${variationSlug}.ts`);
-  if (fs8.existsSync(variationPath)) {
-    throw new Error(`A variation already exists at ${path12.relative(projectDir, variationPath)}. Choose a different name.`);
+function assertScaffoldDoesNotExist(options) {
+  for (const collision of options.filesystemCollisions) {
+    const targetPath = path12.join(options.projectDir, collision.relativePath);
+    if (fs8.existsSync(targetPath)) {
+      throw new Error(`${collision.label} already exists at ${path12.relative(options.projectDir, targetPath)}. Choose a different name.`);
+    }
   }
-  if (inventory.variations.some((entry) => entry.block === blockSlug && entry.slug === variationSlug)) {
-    throw new Error(`A variation inventory entry already exists for ${blockSlug}/${variationSlug}. Choose a different name.`);
+  if (options.inventoryCollision && options.inventoryCollision.entries.some(options.inventoryCollision.exists)) {
+    throw new Error(options.inventoryCollision.message);
   }
 }
+function assertVariationDoesNotExist(projectDir, blockSlug, variationSlug, inventory) {
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "A variation",
+        relativePath: path12.join("src", "blocks", blockSlug, "variations", `${variationSlug}.ts`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.variations,
+      exists: (entry) => entry.block === blockSlug && entry.slug === variationSlug,
+      message: `A variation inventory entry already exists for ${blockSlug}/${variationSlug}. Choose a different name.`
+    },
+    projectDir
+  });
+}
+function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "A block style",
+        relativePath: path12.join("src", "blocks", blockSlug, "styles", `${styleSlug}.ts`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.blockStyles,
+      exists: (entry) => entry.block === blockSlug && entry.slug === styleSlug,
+      message: `A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`
+    },
+    projectDir
+  });
+}
+function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "A block transform",
+        relativePath: path12.join("src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.blockTransforms,
+      exists: (entry) => entry.block === blockSlug && entry.slug === transformSlug,
+      message: `A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`
+    },
+    projectDir
+  });
+}
 function assertPatternDoesNotExist(projectDir, patternSlug, inventory) {
-  const patternPath = path12.join(projectDir, "src", "patterns", `${patternSlug}.php`);
-  if (fs8.existsSync(patternPath)) {
-    throw new Error(`A pattern already exists at ${path12.relative(projectDir, patternPath)}. Choose a different name.`);
-  }
-  if (inventory.patterns.some((entry) => entry.slug === patternSlug)) {
-    throw new Error(`A pattern inventory entry already exists for ${patternSlug}. Choose a different name.`);
-  }
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "A pattern",
+        relativePath: path12.join("src", "patterns", `${patternSlug}.php`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.patterns,
+      exists: (entry) => entry.slug === patternSlug,
+      message: `A pattern inventory entry already exists for ${patternSlug}. Choose a different name.`
+    },
+    projectDir
+  });
 }
 function assertBindingSourceDoesNotExist(projectDir, bindingSourceSlug, inventory) {
-  const bindingSourceDir = path12.join(projectDir, "src", "bindings", bindingSourceSlug);
-  if (fs8.existsSync(bindingSourceDir)) {
-    throw new Error(`A binding source already exists at ${path12.relative(projectDir, bindingSourceDir)}. Choose a different name.`);
-  }
-  if (inventory.bindingSources.some((entry) => entry.slug === bindingSourceSlug)) {
-    throw new Error(`A binding source inventory entry already exists for ${bindingSourceSlug}. Choose a different name.`);
-  }
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "A binding source",
+        relativePath: path12.join("src", "bindings", bindingSourceSlug)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.bindingSources,
+      exists: (entry) => entry.slug === bindingSourceSlug,
+      message: `A binding source inventory entry already exists for ${bindingSourceSlug}. Choose a different name.`
+    },
+    projectDir
+  });
 }
 function assertRestResourceDoesNotExist(projectDir, restResourceSlug, inventory) {
-  const restResourceDir = path12.join(projectDir, "src", "rest", restResourceSlug);
-  const restResourcePhpPath = path12.join(projectDir, "inc", "rest", `${restResourceSlug}.php`);
-  if (fs8.existsSync(restResourceDir)) {
-    throw new Error(`A REST resource already exists at ${path12.relative(projectDir, restResourceDir)}. Choose a different name.`);
-  }
-  if (fs8.existsSync(restResourcePhpPath)) {
-    throw new Error(`A REST resource bootstrap already exists at ${path12.relative(projectDir, restResourcePhpPath)}. Choose a different name.`);
-  }
-  if (inventory.restResources.some((entry) => entry.slug === restResourceSlug)) {
-    throw new Error(`A REST resource inventory entry already exists for ${restResourceSlug}. Choose a different name.`);
-  }
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "A REST resource",
+        relativePath: path12.join("src", "rest", restResourceSlug)
+      },
+      {
+        label: "A REST resource bootstrap",
+        relativePath: path12.join("inc", "rest", `${restResourceSlug}.php`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.restResources,
+      exists: (entry) => entry.slug === restResourceSlug,
+      message: `A REST resource inventory entry already exists for ${restResourceSlug}. Choose a different name.`
+    },
+    projectDir
+  });
 }
 function assertAdminViewDoesNotExist(projectDir, adminViewSlug, inventory) {
-  const adminViewDir = path12.join(projectDir, "src", "admin-views", adminViewSlug);
-  const adminViewPhpPath = path12.join(projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
-  if (fs8.existsSync(adminViewDir)) {
-    throw new Error(`An admin view already exists at ${path12.relative(projectDir, adminViewDir)}. Choose a different name.`);
-  }
-  if (fs8.existsSync(adminViewPhpPath)) {
-    throw new Error(`An admin view bootstrap already exists at ${path12.relative(projectDir, adminViewPhpPath)}. Choose a different name.`);
-  }
-  if (inventory.adminViews.some((entry) => entry.slug === adminViewSlug)) {
-    throw new Error(`An admin view inventory entry already exists for ${adminViewSlug}. Choose a different name.`);
-  }
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "An admin view",
+        relativePath: path12.join("src", "admin-views", adminViewSlug)
+      },
+      {
+        label: "An admin view bootstrap",
+        relativePath: path12.join("inc", "admin-views", `${adminViewSlug}.php`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.adminViews,
+      exists: (entry) => entry.slug === adminViewSlug,
+      message: `An admin view inventory entry already exists for ${adminViewSlug}. Choose a different name.`
+    },
+    projectDir
+  });
 }
 function assertAbilityDoesNotExist(projectDir, abilitySlug, inventory) {
-  const abilityDir = path12.join(projectDir, "src", "abilities", abilitySlug);
-  const abilityPhpPath = path12.join(projectDir, "inc", "abilities", `${abilitySlug}.php`);
-  if (fs8.existsSync(abilityDir)) {
-    throw new Error(`An ability scaffold already exists at ${path12.relative(projectDir, abilityDir)}. Choose a different name.`);
-  }
-  if (fs8.existsSync(abilityPhpPath)) {
-    throw new Error(`An ability bootstrap already exists at ${path12.relative(projectDir, abilityPhpPath)}. Choose a different name.`);
-  }
-  if (inventory.abilities.some((entry) => entry.slug === abilitySlug)) {
-    throw new Error(`An ability inventory entry already exists for ${abilitySlug}. Choose a different name.`);
-  }
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "An ability scaffold",
+        relativePath: path12.join("src", "abilities", abilitySlug)
+      },
+      {
+        label: "An ability bootstrap",
+        relativePath: path12.join("inc", "abilities", `${abilitySlug}.php`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.abilities,
+      exists: (entry) => entry.slug === abilitySlug,
+      message: `An ability inventory entry already exists for ${abilitySlug}. Choose a different name.`
+    },
+    projectDir
+  });
 }
 function assertAiFeatureDoesNotExist(projectDir, aiFeatureSlug, inventory) {
-  const aiFeatureDir = path12.join(projectDir, "src", "ai-features", aiFeatureSlug);
-  const aiFeaturePhpPath = path12.join(projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
-  if (fs8.existsSync(aiFeatureDir)) {
-    throw new Error(`An AI feature already exists at ${path12.relative(projectDir, aiFeatureDir)}. Choose a different name.`);
-  }
-  if (fs8.existsSync(aiFeaturePhpPath)) {
-    throw new Error(`An AI feature bootstrap already exists at ${path12.relative(projectDir, aiFeaturePhpPath)}. Choose a different name.`);
-  }
-  if (inventory.aiFeatures.some((entry) => entry.slug === aiFeatureSlug)) {
-    throw new Error(`An AI feature inventory entry already exists for ${aiFeatureSlug}. Choose a different name.`);
-  }
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "An AI feature",
+        relativePath: path12.join("src", "ai-features", aiFeatureSlug)
+      },
+      {
+        label: "An AI feature bootstrap",
+        relativePath: path12.join("inc", "ai-features", `${aiFeatureSlug}.php`)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.aiFeatures,
+      exists: (entry) => entry.slug === aiFeatureSlug,
+      message: `An AI feature inventory entry already exists for ${aiFeatureSlug}. Choose a different name.`
+    },
+    projectDir
+  });
 }
 function assertEditorPluginDoesNotExist(projectDir, editorPluginSlug, inventory) {
-  const editorPluginDir = path12.join(projectDir, "src", "editor-plugins", editorPluginSlug);
-  if (fs8.existsSync(editorPluginDir)) {
-    throw new Error(`An editor plugin already exists at ${path12.relative(projectDir, editorPluginDir)}. Choose a different name.`);
-  }
-  if (inventory.editorPlugins.some((entry) => entry.slug === editorPluginSlug)) {
-    throw new Error(`An editor plugin inventory entry already exists for ${editorPluginSlug}. Choose a different name.`);
-  }
+  assertScaffoldDoesNotExist({
+    filesystemCollisions: [
+      {
+        label: "An editor plugin",
+        relativePath: path12.join("src", "editor-plugins", editorPluginSlug)
+      }
+    ],
+    inventoryCollision: {
+      entries: inventory.editorPlugins,
+      exists: (entry) => entry.slug === editorPluginSlug,
+      message: `An editor plugin inventory entry already exists for ${editorPluginSlug}. Choose a different name.`
+    },
+    projectDir
+  });
 }
 function formatAddHelpText() {
   return `Usage:
@@ -211339,6 +211438,27 @@ function ensureInterfaceField(source, interfaceName, fieldName, fieldSource) {
     return `${start}${body}${body.length > 0 && !body.endsWith(lineEnding) ? lineEnding : ""}${formattedFieldSource}${end}`;
   });
 }
+function normalizeInterfaceFieldBlock(source, interfaceName, fieldName, fieldSource, requiredFragments) {
+  const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex2(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
+  return source.replace(interfacePattern, (match3, start, body, end) => {
+    const fieldPattern = new RegExp(`(^([ \\t]*)${escapeRegex2(fieldName)}\\??:\\s*\\{[ \\t]*\\r?\\n)([\\s\\S]*?)(^\\2\\};\\r?\\n?)`, "mu");
+    const fieldMatch = fieldPattern.exec(body);
+    if (!fieldMatch) {
+      return match3;
+    }
+    const existingFieldSource = fieldMatch[0];
+    if (requiredFragments.every((fragment) => existingFieldSource.includes(fragment))) {
+      return match3;
+    }
+    const lineEnding = start.endsWith(`\r
+`) ? `\r
+` : `
+`;
+    const formattedFieldSource = `${fieldSource.replace(/\r?\n$/u, "").split(`
+`).join(lineEnding)}${lineEnding}`;
+    return `${start}${body.slice(0, fieldMatch.index)}${formattedFieldSource}${body.slice(fieldMatch.index + existingFieldSource.length)}${end}`;
+  });
+}
 function updateWorkspaceInventorySource(source, {
   blockEntries = [],
   blockStyleEntries = [],
@@ -211370,7 +211490,9 @@ function updateWorkspaceInventorySource(source, {
   nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "attribute", "\tattribute?: string;");
   nextSource = ensureInterfaceField(nextSource, "WorkspaceBindingSourceConfig", "block", "\tblock?: string;");
   nextSource = ensureInterfaceField(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+  nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
   nextSource = ensureInterfaceField(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+  nextSource = normalizeInterfaceFieldBlock(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD, ["optionalFeatureIds: string[];", "requiredFeatureIds: string[];"]);
   nextSource = appendEntriesAtMarker(nextSource, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, editorPluginEntries);
   return nextSource;
 }
@@ -211473,7 +211595,9 @@ export const REST_RESOURCES: WorkspaceRestResourceConfig[] = [
 			wordpress?: string;
 		};
 		mode: 'baseline' | 'optional' | 'required';
+		optionalFeatureIds: string[];
 		optionalFeatures: string[];
+		requiredFeatureIds: string[];
 		requiredFeatures: string[];
 		runtimeGates: string[];
 	};
@@ -224640,7 +224764,9 @@ function createScaffoldCompatibilityConfig(policy) {
   return {
     hardMinimums: capabilityPlan.hardMinimums,
     mode: getPolicyMode(capabilityPlan),
+    optionalFeatureIds: capabilityPlan.optionalFeatures.map((feature) => feature.id),
     optionalFeatures: capabilityPlan.optionalFeatures.map((feature) => feature.label),
+    requiredFeatureIds: capabilityPlan.requiredFeatures.map((feature) => feature.id),
     requiredFeatures: capabilityPlan.requiredFeatures.map((feature) => feature.label),
     runtimeGates: [
       ...capabilityPlan.requiredFeatures.flatMap(formatRuntimeGate),
@@ -226882,7 +227008,9 @@ type InteractivityActionShape = object;
 type InteractivityCallbackShape = object;
 type InteractivityContextShape = object;
 type InteractivityStateShape = object;
-type InteractivityCallable = CallableFunction;
+type InteractivityCallable =
+  | ((...args: unknown[]) => unknown)
+  | ReturnType<typeof import('@wordpress/interactivity').withSyncEvent>;
 type InteractivityKey<T extends object> = Extract<keyof T, string>;
 type InteractivityMethodKey<T extends object> = {
   [Key in InteractivityKey<T>]: T[Key] extends InteractivityCallable ? Key : never;
@@ -226985,7 +227113,7 @@ export function defineInteractivityStore<
   };
 }
 
-type InteractivityActionHandler = CallableFunction;
+type InteractivityActionHandler = InteractivityCallable;
 
 export interface {{pascalCase}}StoreActions {
   handleClick: InteractivityActionHandler;
@@ -232316,8 +232444,10 @@ registerBlockBindingsSource( {
 `;
 }
 function resolveBindingTarget(options, namespace) {
-  const hasBlock = options.blockName !== undefined && options.blockName.trim().length > 0;
-  const hasAttribute = options.attributeName !== undefined && options.attributeName.trim().length > 0;
+  const blockName = normalizeOptionalCliString(options.blockName);
+  const attributeName = normalizeOptionalCliString(options.attributeName);
+  const hasBlock = blockName !== undefined;
+  const hasAttribute = attributeName !== undefined;
   if (!hasBlock && !hasAttribute) {
     return;
   }
@@ -232325,8 +232455,8 @@ function resolveBindingTarget(options, namespace) {
     throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
   }
   return {
-    attributeName: assertValidBindingAttributeName(options.attributeName ?? ""),
-    blockSlug: resolveBindingTargetBlockSlug(options.blockName ?? "", namespace)
+    attributeName: assertValidBindingAttributeName(attributeName ?? ""),
+    blockSlug: resolveBindingTargetBlockSlug(blockName ?? "", namespace)
   };
 }
 function formatBindingAttributeTypeMember(attributeName) {
@@ -233082,6 +233212,7 @@ var init_cli_add_workspace_assets = __esm(() => {
   init_workspace_project();
   init_workspace_inventory();
   init_cli_add_shared();
+  init_cli_validation();
   import_typescript2 = __toESM(require_typescript(), 1);
   BINDING_ATTRIBUTE_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/u;
 });
@@ -234331,22 +234462,10 @@ var init_cli_add_workspace_rest = __esm(() => {
   init_workspace_project();
 });
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
-import fs44 from "fs";
-import { promises as fsp21 } from "fs";
-import path57 from "path";
-import { syncTypeSchemas as syncTypeSchemas3 } from "@wp-typia/block-runtime/metadata-core";
-function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
-  if (!existingVersion) {
-    return requiredVersion;
-  }
-  const existingMinimum = import_semver2.default.minVersion(existingVersion);
-  const requiredMinimum = import_semver2.default.minVersion(requiredVersion);
-  if (!existingMinimum || !requiredMinimum) {
-    return requiredVersion;
-  }
-  return import_semver2.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
-}
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-types.ts
+var ABILITY_SERVER_GLOB = "/inc/abilities/*.php", ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end", ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start", WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities", WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-templates.ts
 function toAbilityCategorySlug(workspaceNamespace) {
   const normalizedNamespace = workspaceNamespace.replace(/[^a-z0-9-]+/gu, "-").replace(/-{2,}/gu, "-").replace(/^-|-$/gu, "");
   return `${normalizedNamespace || "workspace"}-workflows`;
@@ -234811,6 +234930,27 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `).concat(`
 `);
 }
+var init_cli_add_workspace_ability_templates = __esm(() => {
+  init_scaffold_compatibility();
+  init_cli_add_shared();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
+import fs44 from "fs";
+import { promises as fsp21 } from "fs";
+import path57 from "path";
+import { syncTypeSchemas as syncTypeSchemas3 } from "@wp-typia/block-runtime/metadata-core";
+function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
+  if (!existingVersion) {
+    return requiredVersion;
+  }
+  const existingMinimum = import_semver2.default.minVersion(existingVersion);
+  const requiredMinimum = import_semver2.default.minVersion(requiredVersion);
+  if (!existingMinimum || !requiredMinimum) {
+    return requiredVersion;
+  }
+  return import_semver2.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
+}
 function resolveAbilityRegistryPath(projectDir) {
   const abilitiesDir = path57.join(projectDir, "src", "abilities");
   return [path57.join(abilitiesDir, "index.ts"), path57.join(abilitiesDir, "index.js")].find((candidatePath) => fs44.existsSync(candidatePath)) ?? path57.join(abilitiesDir, "index.ts");
@@ -235022,21 +235162,29 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     }
     const sharedEntriesPattern = /(for\s*\(\s*const\s+relativePath\s+of\s+\[)([\s\S]*?)(\]\s*\)\s*\{)/u;
     const match3 = nextSource.match(sharedEntriesPattern);
-    if (!match3 || !match3[2].includes("src/bindings/index.ts") || !match3[2].includes("src/editor-plugins/index.ts")) {
+    if (!match3 || !/['"]src\/bindings\/index\.(?:ts|js)['"]/u.test(match3[2]) || !/['"]src\/editor-plugins\/index\.(?:tsx|ts|js)['"]/u.test(match3[2])) {
       throw new Error([
         `ensureAbilityBuildScriptAnchors could not patch ${path57.basename(buildScriptPath)}.`,
         "Missing the expected shared editor entries array in scripts/build-workspace.mjs.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    nextSource = nextSource.replace(sharedEntriesPattern, `$1
-		'src/bindings/index.ts',
-		'src/bindings/index.js',
-		'src/editor-plugins/index.ts',
-		'src/editor-plugins/index.js',
-		'src/abilities/index.ts',
-		'src/abilities/index.js',
-	$3`);
+    nextSource = nextSource.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      const missingAbilityEntries = [
+        "'src/abilities/index.ts'",
+        "'src/abilities/index.js'"
+      ].filter((entry) => !sharedEntries.includes(entry));
+      if (missingAbilityEntries.length === 0) {
+        return fullMatch;
+      }
+      const itemIndent = sharedEntries.match(/\n([ \t]*)['"]/u)?.[1] ?? "\t\t";
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const nextEntries = `${trimmedEntries}${separator}` + missingAbilityEntries.map((entry) => `
+${itemIndent}${entry},`).join("") + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
     return nextSource;
   });
 }
@@ -235065,8 +235213,7 @@ async function ensureAbilityWebpackAnchors(workspace) {
 			entries.push( [ entryName, entryPath ] );
 			break;
 		}
-	}
-$2`);
+	}$2`);
     }
     const sharedEntriesPattern = /for\s*\(\s*const\s+\[\s*entryName\s*,\s*candidates\s*\]\s+of\s+\[([\s\S]*?)\]\s*\)\s*\{/u;
     const match3 = source.match(sharedEntriesPattern);
@@ -235077,31 +235224,33 @@ $2`);
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    return source.replace(sharedEntriesPattern, `for ( const [ entryName, candidates ] of [
-		[
-			'bindings/index',
-			[ 'src/bindings/index.ts', 'src/bindings/index.js' ],
-		],
-		[
-			'editor-plugins/index',
-			[ 'src/editor-plugins/index.ts', 'src/editor-plugins/index.js' ],
-		],
-		[
-			'abilities/index',
-			[ 'src/abilities/index.ts', 'src/abilities/index.js' ],
-		],
-	] ) {`);
+    return source.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      if (/['"]abilities\/index['"]/u.test(sharedEntries)) {
+        return fullMatch;
+      }
+      const tupleIndent = sharedEntries.match(/\n([ \t]*)\[/u)?.[1] ?? "\t\t";
+      const nestedIndent = `${tupleIndent}	`;
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const abilityTuple = [
+        `${tupleIndent}[`,
+        `${nestedIndent}'abilities/index',`,
+        `${nestedIndent}[ 'src/abilities/index.ts', 'src/abilities/index.js' ],`,
+        `${tupleIndent}],`
+      ].join(`
+`);
+      const nextEntries = `${trimmedEntries}${separator}
+${abilityTuple}` + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
   });
 }
-async function runAddAbilityCommand({
-  abilityName,
-  cwd = process.cwd()
+async function scaffoldAbilityWorkspace({
+  abilitySlug,
+  compatibilityPolicy,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
   const blockConfigPath = path57.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const buildScriptPath = path57.join(workspace.projectDir, "scripts", "build-workspace.mjs");
@@ -235160,27 +235309,53 @@ async function runAddAbilityCommand({
     });
     await writeAbilityRegistry(workspace.projectDir, abilitySlug);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
-      abilityEntries: [buildAbilityConfigEntry(abilitySlug, compatibilityPolicy)]
+      abilityEntries: [
+        buildAbilityConfigEntry(abilitySlug, compatibilityPolicy)
+      ]
     });
-    return {
-      abilitySlug,
-      projectDir: workspace.projectDir
-    };
   } catch (error48) {
     await rollbackWorkspaceMutation(mutationSnapshot);
     throw error48;
   }
 }
-var import_semver2, ABILITY_SERVER_GLOB = "/inc/abilities/*.php", ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end", ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start", WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities", WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
-var init_cli_add_workspace_ability = __esm(() => {
+var import_semver2;
+var init_cli_add_workspace_ability_scaffold = __esm(() => {
   init_workspace_inventory();
-  init_workspace_project();
+  init_cli_add_workspace_ability_templates();
   init_cli_add_shared();
   init_scaffold_compatibility();
   init_package_versions();
   import_semver2 = __toESM(require_semver2(), 1);
 });
 
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+async function runAddAbilityCommand({
+  abilityName,
+  cwd = process.cwd()
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
+  await scaffoldAbilityWorkspace({
+    abilitySlug,
+    compatibilityPolicy,
+    workspace
+  });
+  return {
+    abilitySlug,
+    projectDir: workspace.projectDir
+  };
+}
+var init_cli_add_workspace_ability = __esm(() => {
+  init_cli_add_shared();
+  init_cli_add_workspace_ability_scaffold();
+  init_workspace_inventory();
+  init_workspace_project();
+  init_scaffold_compatibility();
+});
+
 // ../wp-typia-project-tools/src/runtime/schema-core.ts
 var exports_schema_core = {};
 import"@wp-typia/block-runtime/schema-core";
@@ -235415,6 +235590,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) {
@@ -235450,6 +235664,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,
@@ -235457,6 +235673,7 @@ function buildAiFeatureApiSource(aiFeatureSlug) {
 
 import type {
 	${pascalCase}AiFeatureRequest,
+	${pascalCase}AiFeatureSupportMetadata,
 } from './api-types';
 import {
 	run${pascalCase}AiFeatureEndpoint,
@@ -235483,6 +235700,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: () => {
@@ -235498,6 +235723,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 );
 }
@@ -235516,6 +235798,10 @@ import type {
 } from './api-types';
 import {
 	aiFeatureRunEndpoint,
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
 } from './api';
 
 export type UseRun${pascalCase}AiFeatureMutationOptions =
@@ -235530,6 +235816,13 @@ export function useRun${pascalCase}AiFeatureMutation(
 ) {
 	return useEndpointMutation( aiFeatureRunEndpoint, options );
 }
+
+export {
+	aiFeatureSupportMetadata,
+	getAiFeatureSupportHintLines,
+	isAiFeatureSupportUnavailableError,
+	resolveAiFeatureUnavailableMessage,
+};
 `;
 }
 function buildAiFeatureSyncScriptSource() {
@@ -235942,9 +236235,7 @@ var init_cli_add_workspace_ai_anchors = __esm(() => {
   init_cli_add_shared();
 });
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
-import { promises as fsp23 } from "fs";
-import path60 from "path";
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-templates.ts
 function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
   const aiFeatureTitle = toTitleCase(aiFeatureSlug);
   const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
@@ -235953,18 +236244,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 );
@@ -236031,17 +236344,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,
 		);
 	}
 }
@@ -236057,7 +236464,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' ) ||
@@ -236117,47 +236524,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;
 	}
 }
 
@@ -236172,6 +236627,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 ) );
 	}
 }
@@ -236183,10 +236650,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 )
 			);
 		}
@@ -236200,22 +236673,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 )
 			);
 		}
@@ -236224,7 +236720,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 )
 			);
 		}
@@ -236235,14 +236737,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 )
 			);
 		}
@@ -236277,7 +236791,7 @@ if ( ! function_exists( '${handlerFunctionName}' ) ) {
 			);
 		}
 
-		$telemetry = ${buildTelemetryFunctionName}( $result );
+		$telemetry = ${buildTelemetryFunctionName}( $result, $payload, $normalized_result );
 		if ( is_wp_error( $telemetry ) ) {
 			return $telemetry;
 		}
@@ -236322,17 +236836,17 @@ add_action( 'admin_notices', '${adminNoticeFunctionName}' );
 add_action( 'rest_api_init', '${registerRoutesFunctionName}' );
 `;
 }
-async function runAddAiFeatureCommand({
-  aiFeatureName,
-  cwd = process.cwd(),
-  namespace
+var init_cli_add_workspace_ai_templates = () => {};
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-scaffold.ts
+import { promises as fsp23 } from "fs";
+import path60 from "path";
+async function scaffoldAiFeatureWorkspace({
+  aiFeatureSlug,
+  compatibilityPolicy,
+  namespace,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
-  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
   const blockConfigPath = path60.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const packageJsonPath = path60.join(workspace.projectDir, "package.json");
@@ -236370,7 +236884,7 @@ async function runAddAiFeatureCommand({
     await fsp23.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
     await fsp23.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
     await fsp23.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
-    await fsp23.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
+    await fsp23.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, namespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
     const pascalCase = toPascalCase(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
@@ -236379,7 +236893,7 @@ async function runAddAiFeatureCommand({
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
       variables: {
-        namespace: resolvedNamespace,
+        namespace,
         pascalCase,
         slugKebabCase: aiFeatureSlug,
         title: toTitleCase(aiFeatureSlug)
@@ -236392,14 +236906,11 @@ async function runAddAiFeatureCommand({
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
       aiFeatureEntries: [
-        buildAiFeatureConfigEntry(aiFeatureSlug, resolvedNamespace)
+        buildAiFeatureConfigEntry(aiFeatureSlug, namespace)
       ],
       transformSource: ensureBlockConfigCanAddRestManifests
     });
     return {
-      aiFeatureSlug,
-      namespace: resolvedNamespace,
-      projectDir: workspace.projectDir,
       warnings: packageScriptChanges.addedProjectToolsDependency ? [
         "Added `@wp-typia/project-tools` to devDependencies for `sync-ai`. If this workspace was already installed, rerun your package manager install command before the first `wp-typia sync ai`."
       ] : []
@@ -236409,12 +236920,45 @@ async function runAddAiFeatureCommand({
     throw error48;
   }
 }
-var init_cli_add_workspace_ai = __esm(() => {
-  init_cli_add_shared();
+var init_cli_add_workspace_ai_scaffold = __esm(() => {
   init_cli_add_block_legacy_validator();
   init_cli_add_workspace_ai_source_emitters();
   init_cli_add_workspace_ai_anchors();
+  init_cli_add_workspace_ai_templates();
+  init_workspace_inventory();
+  init_cli_add_shared();
+  init_scaffold_compatibility();
   init_ai_feature_artifacts();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+async function runAddAiFeatureCommand({
+  aiFeatureName,
+  cwd = process.cwd(),
+  namespace
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
+  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
+  const scaffoldResult = await scaffoldAiFeatureWorkspace({
+    aiFeatureSlug,
+    compatibilityPolicy,
+    namespace: resolvedNamespace,
+    workspace
+  });
+  return {
+    aiFeatureSlug,
+    namespace: resolvedNamespace,
+    projectDir: workspace.projectDir,
+    warnings: scaffoldResult.warnings
+  };
+}
+var init_cli_add_workspace_ai = __esm(() => {
+  init_cli_add_shared();
+  init_cli_add_workspace_ai_scaffold();
   init_workspace_inventory();
   init_workspace_project();
   init_scaffold_compatibility();
@@ -236890,24 +237434,6 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
   const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
   await fsp24.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
-function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  const stylePath = path61.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
-  if (fs45.existsSync(stylePath)) {
-    throw new Error(`A block style already exists at ${path61.relative(projectDir, stylePath)}. Choose a different name.`);
-  }
-  if (inventory.blockStyles.some((entry) => entry.block === blockSlug && entry.slug === styleSlug)) {
-    throw new Error(`A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`);
-  }
-}
-function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-  const transformPath = path61.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
-  if (fs45.existsSync(transformPath)) {
-    throw new Error(`A block transform already exists at ${path61.relative(projectDir, transformPath)}. Choose a different name.`);
-  }
-  if (inventory.blockTransforms.some((entry) => entry.block === blockSlug && entry.slug === transformSlug)) {
-    throw new Error(`A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`);
-  }
-}
 function assertFullBlockName(blockName, flagName) {
   const trimmed = blockName.trim();
   if (!trimmed) {
@@ -237283,16 +237809,153 @@ var init_cli_doctor_environment = __esm(() => {
   init_template_registry();
 });
 
-// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace.ts
+// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-shared.ts
 import fs47 from "fs";
 import path63 from "path";
-import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata2 } from "@wp-typia/block-runtime/blocks";
 function createDoctorCheck2(label, status, detail, code) {
   return code ? { code, detail, label, status } : { detail, label, status };
 }
 function createDoctorScopeCheck(status, detail) {
   return createDoctorCheck2("Doctor scope", status, detail);
 }
+function getWorkspaceBootstrapRelativePath(packageName) {
+  return `${packageName.split("/").pop() ?? packageName}.php`;
+}
+function checkExistingFiles(projectDir, label, filePaths) {
+  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs47.existsSync(path63.join(projectDir, filePath)));
+  return createDoctorCheck2(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
+}
+var WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php", WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js", WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php", WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php", WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php", WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php", WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php", WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js", WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php", WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css", WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js", WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php", WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css", WORKSPACE_GENERATED_BLOCK_ARTIFACTS, WORKSPACE_FULL_BLOCK_NAME_PATTERN;
+var init_cli_doctor_workspace_shared = __esm(() => {
+  WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
+    "block.json",
+    "typia.manifest.json",
+    "typia.schema.json",
+    "typia-validator.php",
+    "typia.openapi.json"
+  ];
+  WORKSPACE_FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-bindings.ts
+import fs48 from "fs";
+import path64 from "path";
+import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata2 } from "@wp-typia/block-runtime/blocks";
+function checkWorkspaceBindingBootstrap(projectDir, packageName) {
+  const packageBaseName = packageName.split("/").pop() ?? packageName;
+  const bootstrapPath = path64.join(projectDir, `${packageBaseName}.php`);
+  if (!fs48.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path64.basename(bootstrapPath)}`);
+  }
+  const source = fs48.readFileSync(bootstrapPath, "utf8");
+  const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
+  const hasEditorEnqueueHook = source.includes("enqueue_block_editor_assets");
+  const hasEditorScript = source.includes(WORKSPACE_BINDING_EDITOR_SCRIPT);
+  const hasEditorAsset = source.includes(WORKSPACE_BINDING_EDITOR_ASSET);
+  return createDoctorCheck2("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "Binding source PHP and editor bootstrap hooks are present" : "Missing binding source PHP require glob or editor enqueue hook");
+}
+function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
+  const indexRelativePath = [path64.join("src", "bindings", "index.ts"), path64.join("src", "bindings", "index.js")].find((relativePath) => fs48.existsSync(path64.join(projectDir, relativePath)));
+  if (!indexRelativePath) {
+    return createDoctorCheck2("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
+  }
+  const indexPath = path64.join(projectDir, indexRelativePath);
+  const source = fs48.readFileSync(indexPath, "utf8");
+  const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
+  return createDoctorCheck2("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Binding source editor registrations are aggregated" : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
+}
+function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs, bindingSource) {
+  const hasBlock = bindingSource.block !== undefined;
+  const hasAttribute = bindingSource.attribute !== undefined;
+  if (!hasBlock && !hasAttribute) {
+    return;
+  }
+  if (!bindingSource.block || !bindingSource.attribute) {
+    return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", "Binding target entries must include both block and attribute.");
+  }
+  if (!registeredBlockSlugs.has(bindingSource.block)) {
+    return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", `Binding target references unknown block "${bindingSource.block}".`);
+  }
+  const blockJsonRelativePath = path64.join("src", "blocks", bindingSource.block, "block.json");
+  const blockJsonPath = path64.join(projectDir, blockJsonRelativePath);
+  const issues = [];
+  try {
+    const blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs48.readFileSync(blockJsonPath, "utf8")));
+    const attributes = blockJson.attributes;
+    if (!attributes || typeof attributes !== "object" || Array.isArray(attributes)) {
+      issues.push(`${blockJsonRelativePath} must define an attributes object`);
+    } else {
+      const attributeConfig = attributes[bindingSource.attribute];
+      if (!attributeConfig || typeof attributeConfig !== "object" || Array.isArray(attributeConfig)) {
+        issues.push(`${blockJsonRelativePath} must declare attribute "${bindingSource.attribute}"`);
+      }
+    }
+  } catch (error48) {
+    issues.push(error48 instanceof Error ? `Unable to read ${blockJsonRelativePath}: ${error48.message}` : `Unable to read ${blockJsonRelativePath}.`);
+  }
+  const serverPath = path64.join(projectDir, bindingSource.serverFile);
+  if (fs48.existsSync(serverPath)) {
+    const serverSource = fs48.readFileSync(serverPath, "utf8");
+    const supportedAttributesFilter = `block_bindings_supported_attributes_${workspace.workspace.namespace}/${bindingSource.block}`;
+    if (!serverSource.includes(supportedAttributesFilter)) {
+      issues.push(`${bindingSource.serverFile} must register ${supportedAttributesFilter}`);
+    }
+    if (!new RegExp(`(['"])${escapeRegex2(bindingSource.attribute)}\\1`, "u").test(serverSource)) {
+      issues.push(`${bindingSource.serverFile} must expose attribute "${bindingSource.attribute}"`);
+    }
+  } else {
+    issues.push(`Missing ${bindingSource.serverFile}`);
+  }
+  const editorPath = path64.join(projectDir, bindingSource.editorFile);
+  if (fs48.existsSync(editorPath)) {
+    const editorSource = fs48.readFileSync(editorPath, "utf8");
+    const blockName = `${workspace.workspace.namespace}/${bindingSource.block}`;
+    const bindingSourceTargetMatch = editorSource.match(/export\s+const\s+BINDING_SOURCE_TARGET\s*=\s*\{([\s\S]*?)\}\s+as\s+const\s*;/u);
+    if (!bindingSourceTargetMatch) {
+      issues.push(`${bindingSource.editorFile} must export BINDING_SOURCE_TARGET`);
+    } else {
+      const targetSource = bindingSourceTargetMatch[1] ?? "";
+      const attributePattern = new RegExp(`\\battribute\\s*:\\s*["']${escapeRegex2(bindingSource.attribute)}["']`, "u");
+      const blockPattern = new RegExp(`\\bblock\\s*:\\s*["']${escapeRegex2(blockName)}["']`, "u");
+      if (!attributePattern.test(targetSource)) {
+        issues.push(`${bindingSource.editorFile} must document target attribute "${bindingSource.attribute}"`);
+      }
+      if (!blockPattern.test(targetSource)) {
+        issues.push(`${bindingSource.editorFile} must document target block "${blockName}"`);
+      }
+    }
+  } else {
+    issues.push(`Missing ${bindingSource.editorFile}`);
+  }
+  return createDoctorCheck2(`Binding target ${bindingSource.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${bindingSource.block}.${bindingSource.attribute} is declared and supported` : issues.join("; "));
+}
+function getWorkspaceBindingDoctorChecks(workspace, inventory) {
+  const checks3 = [];
+  if (inventory.bindingSources.length > 0) {
+    checks3.push(checkWorkspaceBindingBootstrap(workspace.projectDir, workspace.packageName));
+    checks3.push(checkWorkspaceBindingSourcesIndex(workspace.projectDir, inventory.bindingSources));
+  }
+  const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
+  for (const bindingSource of inventory.bindingSources) {
+    checks3.push(checkExistingFiles(workspace.projectDir, `Binding source ${bindingSource.slug}`, [
+      bindingSource.serverFile,
+      bindingSource.editorFile
+    ]));
+    const bindingTargetCheck = checkWorkspaceBindingTarget(workspace.projectDir, workspace, registeredBlockSlugs, bindingSource);
+    if (bindingTargetCheck) {
+      checks3.push(bindingTargetCheck);
+    }
+  }
+  return checks3;
+}
+var init_cli_doctor_workspace_bindings = __esm(() => {
+  init_cli_doctor_workspace_shared();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-blocks.ts
+import fs49 from "fs";
+import path65 from "path";
+import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata3 } from "@wp-typia/block-runtime/blocks";
 function maskSourceSegment2(segment) {
   return segment.replace(/[^\n\r]/gu, " ");
 }
@@ -237355,7 +238018,7 @@ function hasExecutablePattern2(source, pattern) {
   return pattern.test(maskTypeScriptCommentsAndLiterals2(source));
 }
 function normalizePathSeparators(relativePath) {
-  return relativePath.split(path63.sep).join("/");
+  return relativePath.split(path65.sep).join("/");
 }
 function hasRegisteredBlockAsset(value2) {
   if (typeof value2 === "string") {
@@ -237367,25 +238030,19 @@ function hasRegisteredBlockAsset(value2) {
   return false;
 }
 function readWorkspaceBlockIframeMetadata(projectDir, blockSlug) {
-  const blockJsonRelativePath = path63.join("src", "blocks", blockSlug, "block.json");
-  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
-  if (!fs47.existsSync(blockJsonPath)) {
+  const blockJsonRelativePath = path65.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path65.join(projectDir, blockJsonRelativePath);
+  if (!fs49.existsSync(blockJsonPath)) {
     return {
       blockJsonRelativePath,
       error: `Missing ${blockJsonRelativePath}`
     };
   }
   try {
-    const parsed = JSON.parse(fs47.readFileSync(blockJsonPath, "utf8"));
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return {
-        blockJsonRelativePath,
-        error: `${blockJsonRelativePath} must contain a JSON object`
-      };
-    }
+    const document2 = parseScaffoldBlockMetadata3(JSON.parse(fs49.readFileSync(blockJsonPath, "utf8")));
     return {
       blockJsonRelativePath,
-      document: parsed
+      document: document2
     };
   } catch (error48) {
     return {
@@ -237395,156 +238052,126 @@ function readWorkspaceBlockIframeMetadata(projectDir, blockSlug) {
   }
 }
 function isWorkspaceBlockEditorSource(relativePath) {
-  const normalizedPath = normalizePathSeparators(relativePath);
-  const normalizedLowerPath = normalizedPath.toLowerCase();
-  if (!WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN.test(normalizedLowerPath) || /\.d\.[cm]?[jt]s$/u.test(normalizedLowerPath)) {
+  if (!WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN.test(relativePath)) {
     return false;
   }
-  const segments = normalizedLowerPath.split("/");
-  const fileName = segments[segments.length - 1] ?? "";
-  const baseName = fileName.replace(/\.[^.]+$/u, "");
-  if (WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES.has(baseName)) {
+  const normalizedRelativePath = normalizePathSeparators(relativePath);
+  const normalizedDirName = path65.posix.dirname(normalizedRelativePath);
+  const normalizedBaseName = path65.posix.basename(normalizedRelativePath, path65.posix.extname(normalizedRelativePath));
+  if (WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES.has(normalizedBaseName)) {
     return true;
   }
-  return segments.slice(0, -1).some((segment) => WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES.has(segment));
+  const pathSegments = normalizedDirName.split("/");
+  return pathSegments.some((segment) => WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES.has(segment));
 }
 function isWorkspaceBlockSaveSource(relativePath) {
-  const fileName = normalizePathSeparators(relativePath).split("/").pop() ?? "";
-  return fileName.replace(/\.[^.]+$/u, "").toLowerCase() === "save";
+  const normalizedBaseName = path65.basename(relativePath, path65.extname(relativePath));
+  return normalizedBaseName === "save";
 }
 function collectWorkspaceBlockEditorSources(projectDir, blockSlug) {
-  const blockDir = path63.join(projectDir, "src", "blocks", blockSlug);
-  if (!fs47.existsSync(blockDir)) {
+  const blockDir = path65.join(projectDir, "src", "blocks", blockSlug);
+  if (!fs49.existsSync(blockDir)) {
     return [];
   }
-  const sources = [];
-  const visitDirectory = (directory) => {
-    for (const entry of fs47.readdirSync(directory, { withFileTypes: true })) {
-      const entryPath = path63.join(directory, entry.name);
+  const collected = [];
+  const queue = [blockDir];
+  while (queue.length > 0) {
+    const currentDir = queue.pop();
+    if (!currentDir) {
+      continue;
+    }
+    for (const entry of fs49.readdirSync(currentDir, { withFileTypes: true })) {
+      const absolutePath = path65.join(currentDir, entry.name);
       if (entry.isDirectory()) {
-        visitDirectory(entryPath);
+        queue.push(absolutePath);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
-      const relativePath = normalizePathSeparators(path63.relative(projectDir, entryPath));
-      const blockRelativePath = path63.relative(blockDir, entryPath);
-      if (!isWorkspaceBlockEditorSource(blockRelativePath)) {
+      const relativePath = path65.relative(projectDir, absolutePath);
+      if (!isWorkspaceBlockEditorSource(relativePath)) {
         continue;
       }
-      sources.push({
-        relativePath,
-        source: fs47.readFileSync(entryPath, "utf8")
+      collected.push({
+        relativePath: normalizePathSeparators(relativePath),
+        source: fs49.readFileSync(absolutePath, "utf8")
       });
     }
-  };
-  visitDirectory(blockDir);
-  return sources;
+  }
+  return collected.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 function getSourceLineNumber(source, index) {
-  let lineNumber = 1;
+  let line = 1;
   for (let cursor = 0;cursor < index; cursor += 1) {
     if (source[cursor] === `
 `) {
-      lineNumber += 1;
+      line += 1;
     }
   }
-  return lineNumber;
+  return line;
 }
-function isGlobalDomAccessCandidate(maskedSource, index, token) {
-  if (token === "document" || token === "window") {
-    return true;
+function isGlobalDomAccessCandidate(source, index, identifier) {
+  const lineStart = source.lastIndexOf(`
+`, index - 1) + 1;
+  const lineEndCandidate = source.indexOf(`
+`, index);
+  const lineEnd = lineEndCandidate === -1 ? source.length : lineEndCandidate;
+  const lineSource = source.slice(lineStart, lineEnd);
+  const trimmedLine = lineSource.trimStart();
+  if (trimmedLine.startsWith("import ")) {
+    return false;
   }
-  const before = maskedSource.slice(0, index);
-  const after = maskedSource.slice(index + token.length);
-  const previousNonWhitespace = before.match(/\S(?=\s*$)/u)?.[0] ?? "";
-  const nextNonWhitespace = after.match(/^\s*(\S)/u)?.[1] ?? "";
-  if (previousNonWhitespace === "." || previousNonWhitespace === "{" || previousNonWhitespace === ",") {
+  if (trimmedLine.startsWith("const ") || trimmedLine.startsWith("let ") || trimmedLine.startsWith("var ")) {
     return false;
   }
-  if (nextNonWhitespace === ":") {
+  if (trimmedLine.startsWith("function ") || trimmedLine.startsWith("class ")) {
     return false;
   }
-  if (/\b(?:const|function|let|var)\s+$/u.test(before)) {
+  const precedingCharacter = index > 0 ? source[index - 1] : "";
+  if (precedingCharacter === "." || precedingCharacter === "'" || precedingCharacter === '"') {
     return false;
   }
-  return true;
+  return identifier === "document" || identifier === "window" || identifier === "parent" || identifier === "top";
 }
-function findWorkspaceBlockGlobalDomAccesses(sources) {
-  const findings = [];
-  for (const { relativePath, source } of sources) {
+function findWorkspaceBlockGlobalDomAccesses(editorSources) {
+  return editorSources.flatMap(({ relativePath, source }) => {
     const maskedSource = maskTypeScriptCommentsAndLiterals2(source);
     const matches = maskedSource.matchAll(WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN);
+    const findings = [];
     for (const match3 of matches) {
-      const index = match3.index ?? 0;
-      const matchedToken = match3[0].replace(/\W+/gu, "");
-      if (!isGlobalDomAccessCandidate(maskedSource, index, matchedToken)) {
+      const identifier = match3[0];
+      const matchIndex = match3.index ?? -1;
+      if (matchIndex < 0) {
         continue;
       }
-      findings.push(`${relativePath}:${getSourceLineNumber(source, index)} (${matchedToken})`);
-      if (findings.length >= 5) {
-        return findings;
+      if (!isGlobalDomAccessCandidate(source, matchIndex, identifier)) {
+        continue;
       }
+      findings.push(`${relativePath}:${getSourceLineNumber(source, matchIndex)}`);
     }
-  }
-  return findings;
-}
-function getWorkspaceBootstrapRelativePath(packageName) {
-  const packageBaseName = packageName.split("/").pop() ?? packageName;
-  return `${packageBaseName}.php`;
-}
-function checkExistingFiles(projectDir, label, filePaths) {
-  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs47.existsSync(path63.join(projectDir, filePath)));
-  return createDoctorCheck2(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
-}
-function checkWorkspacePackageMetadata(workspace, packageJson) {
-  const issues = [];
-  const packageName = packageJson.name;
-  const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0 ? packageName : workspace.packageName);
-  const wpTypia = packageJson.wpTypia;
-  if (typeof packageName !== "string" || packageName.length === 0) {
-    issues.push("package.json must define a string name for workspace bootstrap resolution");
-  }
-  if (wpTypia?.projectType !== "workspace") {
-    issues.push('wpTypia.projectType must be "workspace"');
-  }
-  if (wpTypia?.templatePackage !== WORKSPACE_TEMPLATE_PACKAGE) {
-    issues.push(`wpTypia.templatePackage must be "${WORKSPACE_TEMPLATE_PACKAGE}"`);
-  }
-  if (wpTypia?.namespace !== workspace.workspace.namespace) {
-    issues.push(`wpTypia.namespace must equal "${workspace.workspace.namespace}"`);
-  }
-  if (wpTypia?.textDomain !== workspace.workspace.textDomain) {
-    issues.push(`wpTypia.textDomain must equal "${workspace.workspace.textDomain}"`);
-  }
-  if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
-    issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
-  }
-  if (!fs47.existsSync(path63.join(workspace.projectDir, bootstrapRelativePath))) {
-    issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
-  }
-  return createDoctorCheck2("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}` : issues.join("; "));
+    return findings;
+  });
 }
 function getWorkspaceBlockRequiredFiles(block) {
-  const blockDir = path63.join("src", "blocks", block.slug);
+  const blockDir = path65.join("src", "blocks", block.slug);
   return Array.from(new Set([
     block.typesFile,
     block.apiTypesFile,
     block.openApiFile,
-    path63.join(blockDir, "index.tsx"),
-    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path63.join(blockDir, fileName))
+    path65.join(blockDir, "index.tsx"),
+    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path65.join(blockDir, fileName))
   ].filter((filePath) => typeof filePath === "string")));
 }
 function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
-  const blockJsonRelativePath = path63.join("src", "blocks", block.slug, "block.json");
-  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
-  if (!fs47.existsSync(blockJsonPath)) {
+  const blockJsonRelativePath = path65.join("src", "blocks", block.slug, "block.json");
+  const blockJsonPath = path65.join(projectDir, blockJsonRelativePath);
+  if (!fs49.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
   let blockJson;
   try {
-    blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs47.readFileSync(blockJsonPath, "utf8")));
+    blockJson = parseScaffoldBlockMetadata3(JSON.parse(fs49.readFileSync(blockJsonPath, "utf8")));
   } catch (error48) {
     return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", error48 instanceof Error ? error48.message : String(error48));
   }
@@ -237559,14 +238186,14 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
   return createDoctorCheck2(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}` : issues.join("; "));
 }
 function checkWorkspaceBlockHooks(projectDir, blockSlug) {
-  const blockJsonRelativePath = path63.join("src", "blocks", blockSlug, "block.json");
-  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
-  if (!fs47.existsSync(blockJsonPath)) {
+  const blockJsonRelativePath = path65.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path65.join(projectDir, blockJsonRelativePath);
+  if (!fs49.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
   let blockJson;
   try {
-    blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs47.readFileSync(blockJsonPath, "utf8")));
+    blockJson = parseScaffoldBlockMetadata3(JSON.parse(fs49.readFileSync(blockJsonPath, "utf8")));
   } catch (error48) {
     return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", error48 instanceof Error ? error48.message : String(error48));
   }
@@ -237582,12 +238209,12 @@ function checkWorkspaceBlockHooks(projectDir, blockSlug) {
   return createDoctorCheck2(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0 ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0 ? ` (${Object.keys(blockHooks).join(", ")})` : ""}` : `Invalid blockHooks entries: ${invalidEntries.map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`).join(", ")}`);
 }
 function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
-  const entryRelativePath = path63.join("src", "blocks", blockSlug, "index.tsx");
-  const entryPath = path63.join(projectDir, entryRelativePath);
-  if (!fs47.existsSync(entryPath)) {
+  const entryRelativePath = path65.join("src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path65.join(projectDir, entryRelativePath);
+  if (!fs49.existsSync(entryPath)) {
     return createDoctorCheck2(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
   }
-  const source = fs47.readFileSync(entryPath, "utf8");
+  const source = fs49.readFileSync(entryPath, "utf8");
   const hasCollectionImport = WORKSPACE_COLLECTION_IMPORT_PATTERN.test(source);
   return createDoctorCheck2(`Block collection ${blockSlug}`, hasCollectionImport ? "pass" : "fail", hasCollectionImport ? "Shared block collection import is present" : `Missing a shared collection import like ${WORKSPACE_COLLECTION_IMPORT_LINE}`);
 }
@@ -237600,8 +238227,8 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
   }
   const blockJson = metadataResult.document;
   const apiVersion = typeof blockJson.apiVersion === "number" && Number.isFinite(blockJson.apiVersion) ? blockJson.apiVersion : null;
-  const blockDir = path63.join(projectDir, "src", "blocks", blockSlug);
-  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs47.existsSync(path63.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path63.join("src", "blocks", blockSlug, fileName)));
+  const blockDir = path65.join(projectDir, "src", "blocks", blockSlug);
+  const localStyleFiles = WORKSPACE_BLOCK_LOCAL_STYLE_FILES.filter((fileName) => fs49.existsSync(path65.join(blockDir, fileName))).map((fileName) => normalizePathSeparators(path65.join("src", "blocks", blockSlug, fileName)));
   const hasRegisteredEditorStyles = hasRegisteredBlockAsset(blockJson.style) || hasRegisteredBlockAsset(blockJson.editorStyle);
   const editorSources = collectWorkspaceBlockEditorSources(projectDir, blockSlug);
   const editorWrapperSources = editorSources.filter((source) => !isWorkspaceBlockSaveSource(source.relativePath));
@@ -237619,103 +238246,162 @@ function checkWorkspaceBlockIframeCompatibility(projectDir, blockSlug) {
 }
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
-  if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
+  const bootstrapPath = path65.join(projectDir, `${packageBaseName}.php`);
+  if (!fs49.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path65.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs49.readFileSync(bootstrapPath, "utf8");
   const hasCategoryAnchor = source.includes("register_block_pattern_category");
   const hasPatternGlob = source.includes("/src/patterns/*.php");
   return createDoctorCheck2("Pattern bootstrap", hasCategoryAnchor && hasPatternGlob ? "pass" : "fail", hasCategoryAnchor && hasPatternGlob ? "Pattern category and loader hooks are present" : "Missing pattern category registration or src/patterns loader hook");
 }
-function checkWorkspaceBindingBootstrap(projectDir, packageName) {
-  const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
-  if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
+function checkVariationEntrypoint(projectDir, blockSlug) {
+  const entryPath = path65.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  if (!fs49.existsSync(entryPath)) {
+    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path65.relative(projectDir, entryPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
-  const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
-  const hasEditorEnqueueHook = source.includes("enqueue_block_editor_assets");
-  const hasEditorScript = source.includes(WORKSPACE_BINDING_EDITOR_SCRIPT);
-  const hasEditorAsset = source.includes(WORKSPACE_BINDING_EDITOR_ASSET);
-  return createDoctorCheck2("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "Binding source PHP and editor bootstrap hooks are present" : "Missing binding source PHP require glob or editor enqueue hook");
+  const source = fs49.readFileSync(entryPath, "utf8");
+  const hasImport = hasUncommentedPattern2(source, WORKSPACE_VARIATIONS_IMPORT_PATTERN);
+  const hasCall = hasExecutablePattern2(source, WORKSPACE_VARIATIONS_CALL_PATTERN);
+  return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Variations registration hook is present" : "Missing ./variations import or registerWorkspaceVariations() call");
 }
-function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
-  const indexRelativePath = [path63.join("src", "bindings", "index.ts"), path63.join("src", "bindings", "index.js")].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
-  if (!indexRelativePath) {
-    return createDoctorCheck2("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
+function checkBlockStyleEntrypoint(projectDir, blockSlug) {
+  const entryPath = path65.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  if (!fs49.existsSync(entryPath)) {
+    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path65.relative(projectDir, entryPath)}`);
   }
-  const indexPath = path63.join(projectDir, indexRelativePath);
-  const source = fs47.readFileSync(indexPath, "utf8");
-  const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
-  return createDoctorCheck2("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Binding source editor registrations are aggregated" : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
+  const source = fs49.readFileSync(entryPath, "utf8");
+  const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN);
+  const hasCall = hasExecutablePattern2(source, WORKSPACE_BLOCK_STYLES_CALL_PATTERN);
+  return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block style registration hook is present" : "Missing ./styles import or registerWorkspaceBlockStyles() call");
 }
-function checkWorkspaceBindingTarget(projectDir, workspace, registeredBlockSlugs, bindingSource) {
-  const hasBlock = bindingSource.block !== undefined;
-  const hasAttribute = bindingSource.attribute !== undefined;
-  if (!hasBlock && !hasAttribute) {
-    return;
+function checkBlockTransformEntrypoint(projectDir, blockSlug) {
+  const entryPath = path65.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  if (!fs49.existsSync(entryPath)) {
+    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path65.relative(projectDir, entryPath)}`);
   }
-  if (!bindingSource.block || !bindingSource.attribute) {
-    return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", "Binding target entries must include both block and attribute.");
+  const source = fs49.readFileSync(entryPath, "utf8");
+  const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN);
+  const hasCall = hasExecutablePattern2(source, WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN);
+  return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block transform registration hook is present" : "Missing ./transforms import or applyWorkspaceBlockTransforms(registration.settings) call");
+}
+function checkBlockTransformConfig(workspace, transform2) {
+  const expectedTo = `${workspace.workspace.namespace}/${transform2.block}`;
+  const issues = [];
+  if (!WORKSPACE_FULL_BLOCK_NAME_PATTERN.test(transform2.from)) {
+    issues.push("from must use full namespace/block format");
   }
-  if (!registeredBlockSlugs.has(bindingSource.block)) {
-    return createDoctorCheck2(`Binding target ${bindingSource.slug}`, "fail", `Binding target references unknown block "${bindingSource.block}".`);
+  if (transform2.to !== expectedTo) {
+    issues.push(`to must equal "${expectedTo}" for workspace block "${transform2.block}"`);
   }
-  const blockJsonRelativePath = path63.join("src", "blocks", bindingSource.block, "block.json");
-  const blockJsonPath = path63.join(projectDir, blockJsonRelativePath);
-  const issues = [];
-  try {
-    const blockJson = parseScaffoldBlockMetadata2(JSON.parse(fs47.readFileSync(blockJsonPath, "utf8")));
-    const attributes = blockJson.attributes;
-    if (!attributes || typeof attributes !== "object" || Array.isArray(attributes)) {
-      issues.push(`${blockJsonRelativePath} must define an attributes object`);
-    } else {
-      const attributeConfig = attributes[bindingSource.attribute];
-      if (!attributeConfig || typeof attributeConfig !== "object" || Array.isArray(attributeConfig)) {
-        issues.push(`${blockJsonRelativePath} must declare attribute "${bindingSource.attribute}"`);
-      }
+  return createDoctorCheck2(`Block transform config ${transform2.block}/${transform2.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${transform2.from} transforms into ${transform2.to}` : issues.join("; "));
+}
+function getWorkspaceBlockDoctorChecks(workspace, inventory) {
+  const checks3 = [];
+  for (const block of inventory.blocks) {
+    checks3.push(checkExistingFiles(workspace.projectDir, `Block ${block.slug}`, getWorkspaceBlockRequiredFiles(block)));
+    checks3.push(checkWorkspaceBlockMetadata(workspace.projectDir, workspace, block));
+    checks3.push(checkWorkspaceBlockHooks(workspace.projectDir, block.slug));
+    checks3.push(checkWorkspaceBlockCollectionImport(workspace.projectDir, block.slug));
+    checks3.push(...checkWorkspaceBlockIframeCompatibility(workspace.projectDir, block.slug));
+  }
+  const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
+  const variationTargetBlocks = new Set;
+  for (const variation of inventory.variations) {
+    if (!registeredBlockSlugs.has(variation.block)) {
+      checks3.push(createDoctorCheck2(`Variation ${variation.block}/${variation.slug}`, "fail", `Variation references unknown block "${variation.block}"`));
+      continue;
     }
-  } catch (error48) {
-    issues.push(error48 instanceof Error ? `Unable to read ${blockJsonRelativePath}: ${error48.message}` : `Unable to read ${blockJsonRelativePath}.`);
+    variationTargetBlocks.add(variation.block);
+    checks3.push(checkExistingFiles(workspace.projectDir, `Variation ${variation.block}/${variation.slug}`, [variation.file]));
   }
-  const serverPath = path63.join(projectDir, bindingSource.serverFile);
-  if (fs47.existsSync(serverPath)) {
-    const serverSource = fs47.readFileSync(serverPath, "utf8");
-    const supportedAttributesFilter = `block_bindings_supported_attributes_${workspace.workspace.namespace}/${bindingSource.block}`;
-    if (!serverSource.includes(supportedAttributesFilter)) {
-      issues.push(`${bindingSource.serverFile} must register ${supportedAttributesFilter}`);
-    }
-    if (!new RegExp(`'${escapeRegex2(bindingSource.attribute)}'`, "u").test(serverSource)) {
-      issues.push(`${bindingSource.serverFile} must expose attribute "${bindingSource.attribute}"`);
+  for (const blockSlug of variationTargetBlocks) {
+    checks3.push(checkVariationEntrypoint(workspace.projectDir, blockSlug));
+  }
+  const blockStyleTargetBlocks = new Set;
+  for (const blockStyle of inventory.blockStyles) {
+    if (!registeredBlockSlugs.has(blockStyle.block)) {
+      checks3.push(createDoctorCheck2(`Block style ${blockStyle.block}/${blockStyle.slug}`, "fail", `Block style references unknown block "${blockStyle.block}"`));
+      continue;
     }
-  } else {
-    issues.push(`Missing ${bindingSource.serverFile}`);
+    blockStyleTargetBlocks.add(blockStyle.block);
+    checks3.push(checkExistingFiles(workspace.projectDir, `Block style ${blockStyle.block}/${blockStyle.slug}`, [blockStyle.file]));
   }
-  const editorPath = path63.join(projectDir, bindingSource.editorFile);
-  if (fs47.existsSync(editorPath)) {
-    const editorSource = fs47.readFileSync(editorPath, "utf8");
-    const blockName = `${workspace.workspace.namespace}/${bindingSource.block}`;
-    const bindingSourceTargetMatch = editorSource.match(/export\s+const\s+BINDING_SOURCE_TARGET\s*=\s*\{([\s\S]*?)\}\s+as\s+const\s*;/u);
-    if (!bindingSourceTargetMatch) {
-      issues.push(`${bindingSource.editorFile} must export BINDING_SOURCE_TARGET`);
-    } else {
-      const targetSource = bindingSourceTargetMatch[1] ?? "";
-      const attributePattern = new RegExp(`\\battribute\\s*:\\s*["']${escapeRegex2(bindingSource.attribute)}["']`, "u");
-      const blockPattern = new RegExp(`\\bblock\\s*:\\s*["']${escapeRegex2(blockName)}["']`, "u");
-      if (!attributePattern.test(targetSource)) {
-        issues.push(`${bindingSource.editorFile} must document target attribute "${bindingSource.attribute}"`);
-      }
-      if (!blockPattern.test(targetSource)) {
-        issues.push(`${bindingSource.editorFile} must document target block "${blockName}"`);
-      }
+  for (const blockSlug of blockStyleTargetBlocks) {
+    checks3.push(checkExistingFiles(workspace.projectDir, `Block style registry ${blockSlug}`, [
+      path65.join("src", "blocks", blockSlug, "styles", "index.ts")
+    ]));
+    checks3.push(checkBlockStyleEntrypoint(workspace.projectDir, blockSlug));
+  }
+  const blockTransformTargetBlocks = new Set;
+  for (const blockTransform of inventory.blockTransforms) {
+    if (!registeredBlockSlugs.has(blockTransform.block)) {
+      checks3.push(createDoctorCheck2(`Block transform ${blockTransform.block}/${blockTransform.slug}`, "fail", `Block transform references unknown block "${blockTransform.block}"`));
+      continue;
     }
-  } else {
-    issues.push(`Missing ${bindingSource.editorFile}`);
+    blockTransformTargetBlocks.add(blockTransform.block);
+    checks3.push(checkBlockTransformConfig(workspace, blockTransform));
+    checks3.push(checkExistingFiles(workspace.projectDir, `Block transform ${blockTransform.block}/${blockTransform.slug}`, [blockTransform.file]));
   }
-  return createDoctorCheck2(`Binding target ${bindingSource.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${bindingSource.block}.${bindingSource.attribute} is declared and supported` : issues.join("; "));
+  for (const blockSlug of blockTransformTargetBlocks) {
+    checks3.push(checkExistingFiles(workspace.projectDir, `Block transform registry ${blockSlug}`, [
+      path65.join("src", "blocks", blockSlug, "transforms", "index.ts")
+    ]));
+    checks3.push(checkBlockTransformEntrypoint(workspace.projectDir, blockSlug));
+  }
+  const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs49.existsSync(path65.join(workspace.projectDir, "src", "patterns"));
+  if (shouldCheckPatternBootstrap) {
+    checks3.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
+  }
+  for (const pattern of inventory.patterns) {
+    checks3.push(checkExistingFiles(workspace.projectDir, `Pattern ${pattern.slug}`, [pattern.file]));
+  }
+  return checks3;
 }
+var WORKSPACE_COLLECTION_IMPORT_LINE = "import '../../collection';", WORKSPACE_COLLECTION_IMPORT_PATTERN, WORKSPACE_VARIATIONS_IMPORT_PATTERN, WORKSPACE_VARIATIONS_CALL_PATTERN, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN, WORKSPACE_BLOCK_STYLES_CALL_PATTERN, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN, WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN, WORKSPACE_BLOCK_IFRAME_COMPATIBILITY_DOC_URL = "https://developer.wordpress.org/block-editor/reference-guides/block-api/block-api-versions/block-migration-for-iframe-editor-compatibility/", WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES, WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN, WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES, WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES, WORKSPACE_BLOCK_LOCAL_STYLE_FILES, WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN, WORKSPACE_BLOCK_PROPS_PATTERN;
+var init_cli_doctor_workspace_blocks = __esm(() => {
+  init_cli_doctor_workspace_shared();
+  init_hooked_blocks();
+  WORKSPACE_COLLECTION_IMPORT_PATTERN = /^\s*import\s+["']\.\.\/\.\.\/collection["']\s*;?\s*$/m;
+  WORKSPACE_VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
+  WORKSPACE_VARIATIONS_CALL_PATTERN = /registerWorkspaceVariations\s*\(\s*\)\s*;?/u;
+  WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceBlockStyles\s*\}\s*from\s*["']\.\/styles["']\s*;?\s*$/mu;
+  WORKSPACE_BLOCK_STYLES_CALL_PATTERN = /registerWorkspaceBlockStyles\s*\(\s*\)\s*;?/u;
+  WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN = /^\s*import\s*\{\s*applyWorkspaceBlockTransforms\s*\}\s*from\s*["']\.\/transforms["']\s*;?\s*$/mu;
+  WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
+  WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES = {
+    API_VERSION: "wp-typia.workspace.block.iframe.api-version",
+    BLOCK_PROPS: "wp-typia.workspace.block.iframe.block-props",
+    EDITOR_GLOBALS: "wp-typia.workspace.block.iframe.editor-globals",
+    EDITOR_STYLES: "wp-typia.workspace.block.iframe.editor-styles"
+  };
+  WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN = /\.[cm]?[jt]sx?$/u;
+  WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES = new Set([
+    "edit",
+    "editor",
+    "index",
+    "save"
+  ]);
+  WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES = new Set([
+    "components",
+    "controls",
+    "editor",
+    "inspector"
+  ]);
+  WORKSPACE_BLOCK_LOCAL_STYLE_FILES = [
+    "editor.css",
+    "editor.scss",
+    "index.css",
+    "style.css",
+    "style.scss"
+  ];
+  WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN = /\b(?:document|window)\b|\b(?:parent|top)\b(?!\s*:)/gu;
+  WORKSPACE_BLOCK_PROPS_PATTERN = /\buse(?:Block|InnerBlocks)Props(?:\.save)?\s*\(/u;
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-features.ts
+import fs50 from "fs";
+import path66 from "path";
 function getWorkspaceRestResourceRequiredFiles(restResource) {
   const schemaNames = new Set;
   if (restResource.methods.includes("list")) {
@@ -237741,7 +238427,7 @@ function getWorkspaceRestResourceRequiredFiles(restResource) {
   }
   return Array.from(new Set([
     restResource.apiFile,
-    ...Array.from(schemaNames, (schemaName) => path63.join(path63.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+    ...Array.from(schemaNames, (schemaName) => path66.join(path66.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
     restResource.clientFile,
     restResource.dataFile,
     restResource.openApiFile,
@@ -237757,11 +238443,11 @@ function checkWorkspaceRestResourceConfig(restResource) {
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
-  if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
+  const bootstrapPath = path66.join(projectDir, `${packageBaseName}.php`);
+  if (!fs50.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path66.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs50.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_rest_resources`;
   const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
   const hasServerGlob = source.includes(WORKSPACE_REST_RESOURCE_GLOB);
@@ -237780,12 +238466,12 @@ function getWorkspaceAbilityRequiredFiles(ability) {
   ]));
 }
 function checkWorkspaceAbilityConfig(projectDir, ability) {
-  const configPath = path63.join(projectDir, ability.configFile);
-  if (!fs47.existsSync(configPath)) {
+  const configPath = path66.join(projectDir, ability.configFile);
+  if (!fs50.existsSync(configPath)) {
     return createDoctorCheck2(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
   }
   try {
-    const config2 = JSON.parse(fs47.readFileSync(configPath, "utf8"));
+    const config2 = JSON.parse(fs50.readFileSync(configPath, "utf8"));
     const abilityId = typeof config2.abilityId === "string" ? config2.abilityId.trim() : "";
     const categorySlug = typeof config2.category?.slug === "string" ? config2.category.slug.trim() : "";
     const hasValidAbilityId = /^[a-z0-9-]+\/[a-z0-9-]+$/u.test(abilityId);
@@ -237797,11 +238483,11 @@ function checkWorkspaceAbilityConfig(projectDir, ability) {
 }
 function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
-  if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
+  const bootstrapPath = path66.join(projectDir, `${packageBaseName}.php`);
+  if (!fs50.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path66.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs50.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
   const enqueueFunctionName = `${phpPrefix}_enqueue_workflow_abilities`;
   const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
@@ -237818,14 +238504,14 @@ function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
 }
 function checkWorkspaceAbilityIndex(projectDir, abilities) {
   const indexRelativePath = [
-    path63.join("src", "abilities", "index.ts"),
-    path63.join("src", "abilities", "index.js")
-  ].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
+    path66.join("src", "abilities", "index.ts"),
+    path66.join("src", "abilities", "index.js")
+  ].find((relativePath) => fs50.existsSync(path66.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
   }
-  const indexPath = path63.join(projectDir, indexRelativePath);
-  const source = fs47.readFileSync(indexPath, "utf8");
+  const indexPath = path66.join(projectDir, indexRelativePath);
+  const source = fs50.readFileSync(indexPath, "utf8");
   const missingExports = abilities.filter((ability) => {
     const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex2(ability.slug)}\\/client['"\`]`, "mu");
     return !exportPattern.test(source);
@@ -237836,9 +238522,9 @@ function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
   return Array.from(new Set([
     aiFeature.aiSchemaFile,
     aiFeature.apiFile,
-    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
-    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
-    path63.join(path63.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
+    path66.join(path66.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
+    path66.join(path66.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
+    path66.join(path66.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
     aiFeature.clientFile,
     aiFeature.dataFile,
     aiFeature.openApiFile,
@@ -237853,11 +238539,11 @@ function checkWorkspaceAiFeatureConfig(aiFeature) {
 }
 function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
-  if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
+  const bootstrapPath = path66.join(projectDir, `${packageBaseName}.php`);
+  if (!fs50.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path66.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs50.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_ai_features`;
   const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
   const hasServerGlob = source.includes(WORKSPACE_AI_FEATURE_GLOB);
@@ -237865,14 +238551,14 @@ function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   return createDoctorCheck2("AI feature bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook ? "AI feature PHP loader hook is present" : "Missing AI feature PHP require glob or init hook");
 }
 function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
-  const editorPluginDir = path63.join("src", "editor-plugins", editorPlugin.slug);
-  const surfaceFile = editorPlugin.slot === "PluginSidebar" ? path63.join(editorPluginDir, "Sidebar.tsx") : path63.join(editorPluginDir, "Surface.tsx");
+  const editorPluginDir = path66.join("src", "editor-plugins", editorPlugin.slug);
+  const surfaceFile = editorPlugin.slot === "PluginSidebar" ? path66.join(editorPluginDir, "Sidebar.tsx") : path66.join(editorPluginDir, "Surface.tsx");
   return Array.from(new Set([
     editorPlugin.file,
     surfaceFile,
-    path63.join(editorPluginDir, "data.ts"),
-    path63.join(editorPluginDir, "types.ts"),
-    path63.join(editorPluginDir, "style.scss")
+    path66.join(editorPluginDir, "data.ts"),
+    path66.join(editorPluginDir, "types.ts"),
+    path66.join(editorPluginDir, "style.scss")
   ]));
 }
 function checkWorkspaceEditorPluginConfig(editorPlugin) {
@@ -237882,11 +238568,11 @@ function checkWorkspaceEditorPluginConfig(editorPlugin) {
 }
 function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
-  if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
+  const bootstrapPath = path66.join(projectDir, `${packageBaseName}.php`);
+  if (!fs50.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path66.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs50.readFileSync(bootstrapPath, "utf8");
   const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
   const enqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
   const hasEditorEnqueueHook = source.includes(enqueueHook);
@@ -237897,14 +238583,14 @@ function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix)
 }
 function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   const indexRelativePath = [
-    path63.join("src", "editor-plugins", "index.ts"),
-    path63.join("src", "editor-plugins", "index.js")
-  ].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
+    path66.join("src", "editor-plugins", "index.ts"),
+    path66.join("src", "editor-plugins", "index.js")
+  ].find((relativePath) => fs50.existsSync(path66.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
   }
-  const indexPath = path63.join(projectDir, indexRelativePath);
-  const source = fs47.readFileSync(indexPath, "utf8");
+  const indexPath = path66.join(projectDir, indexRelativePath);
+  const source = fs50.readFileSync(indexPath, "utf8");
   const missingImports = editorPlugins.filter((editorPlugin) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
     return !importPattern.test(source);
@@ -237912,15 +238598,15 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   return createDoctorCheck2("Editor plugins index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Editor plugin registrations are aggregated" : `Missing editor plugin imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function getWorkspaceAdminViewRequiredFiles(adminView) {
-  const adminViewDir = path63.join("src", "admin-views", adminView.slug);
+  const adminViewDir = path66.join("src", "admin-views", adminView.slug);
   return Array.from(new Set([
     adminView.file,
     adminView.phpFile,
-    path63.join(adminViewDir, "Screen.tsx"),
-    path63.join(adminViewDir, "config.ts"),
-    path63.join(adminViewDir, "data.ts"),
-    path63.join(adminViewDir, "style.scss"),
-    path63.join(adminViewDir, "types.ts")
+    path66.join(adminViewDir, "Screen.tsx"),
+    path66.join(adminViewDir, "config.ts"),
+    path66.join(adminViewDir, "data.ts"),
+    path66.join(adminViewDir, "style.scss"),
+    path66.join(adminViewDir, "types.ts")
   ]));
 }
 function checkWorkspaceAdminViewConfig(adminView, inventory) {
@@ -237937,11 +238623,11 @@ function checkWorkspaceAdminViewConfig(adminView, inventory) {
 }
 function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path63.join(projectDir, `${packageBaseName}.php`);
-  if (!fs47.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path63.basename(bootstrapPath)}`);
+  const bootstrapPath = path66.join(projectDir, `${packageBaseName}.php`);
+  if (!fs50.existsSync(bootstrapPath)) {
+    return createDoctorCheck2("Admin view bootstrap", "fail", `Missing ${path66.basename(bootstrapPath)}`);
   }
-  const source = fs47.readFileSync(bootstrapPath, "utf8");
+  const source = fs50.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_admin_views`;
   const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
   const hasLoaderHook = source.includes(loadHook);
@@ -237950,14 +238636,14 @@ function checkWorkspaceAdminViewBootstrap(projectDir, packageName, phpPrefix) {
 }
 function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
   const indexRelativePath = [
-    path63.join("src", "admin-views", "index.ts"),
-    path63.join("src", "admin-views", "index.js")
-  ].find((relativePath) => fs47.existsSync(path63.join(projectDir, relativePath)));
+    path66.join("src", "admin-views", "index.ts"),
+    path66.join("src", "admin-views", "index.js")
+  ].find((relativePath) => fs50.existsSync(path66.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Admin views index", "fail", "Missing src/admin-views/index.ts or src/admin-views/index.js");
   }
-  const indexPath = path63.join(projectDir, indexRelativePath);
-  const source = fs47.readFileSync(indexPath, "utf8");
+  const indexPath = path66.join(projectDir, indexRelativePath);
+  const source = fs50.readFileSync(indexPath, "utf8");
   const missingImports = adminViews.filter((adminView) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex2(adminView.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
     return !importPattern.test(source);
@@ -237965,11 +238651,11 @@ function checkWorkspaceAdminViewIndex(projectDir, adminViews) {
   return createDoctorCheck2("Admin views index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Admin view registrations are aggregated" : `Missing admin view imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function checkWorkspaceAdminViewPhp(projectDir, adminView) {
-  const phpPath = path63.join(projectDir, adminView.phpFile);
-  if (!fs47.existsSync(phpPath)) {
+  const phpPath = path66.join(projectDir, adminView.phpFile);
+  if (!fs50.existsSync(phpPath)) {
     return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, "fail", `Missing ${adminView.phpFile}`);
   }
-  const source = fs47.readFileSync(phpPath, "utf8");
+  const source = fs50.readFileSync(phpPath, "utf8");
   const hasAdminMenu = source.includes("add_submenu_page");
   const hasAdminEnqueue = source.includes("admin_enqueue_scripts");
   const hasScript = source.includes(WORKSPACE_ADMIN_VIEW_SCRIPT);
@@ -237978,56 +238664,115 @@ function checkWorkspaceAdminViewPhp(projectDir, adminView) {
   const hasComponentsStyleDependency = source.includes("'wp-components'");
   return createDoctorCheck2(`Admin view PHP ${adminView.slug}`, hasAdminMenu && hasAdminEnqueue && hasScript && hasAsset && hasStyle && hasComponentsStyleDependency ? "pass" : "fail", hasAdminMenu && hasAdminEnqueue && hasScript && hasAsset && hasStyle && hasComponentsStyleDependency ? "Admin menu, script, style, and wp-components style dependency are wired" : "Missing admin menu, enqueue hook, build/admin-views asset reference, or wp-components style dependency");
 }
-function checkVariationEntrypoint(projectDir, blockSlug) {
-  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
-  if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
+function getWorkspaceFeatureDoctorChecks(workspace, inventory) {
+  const checks3 = [];
+  if (inventory.restResources.length > 0) {
+    checks3.push(checkWorkspaceRestResourceBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
   }
-  const source = fs47.readFileSync(entryPath, "utf8");
-  const hasImport = hasUncommentedPattern2(source, WORKSPACE_VARIATIONS_IMPORT_PATTERN);
-  const hasCall = hasExecutablePattern2(source, WORKSPACE_VARIATIONS_CALL_PATTERN);
-  return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Variations registration hook is present" : "Missing ./variations import or registerWorkspaceVariations() call");
-}
-function checkBlockStyleEntrypoint(projectDir, blockSlug) {
-  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
-  if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
+  for (const restResource of inventory.restResources) {
+    checks3.push(checkWorkspaceRestResourceConfig(restResource));
+    checks3.push(checkExistingFiles(workspace.projectDir, `REST resource ${restResource.slug}`, getWorkspaceRestResourceRequiredFiles(restResource)));
   }
-  const source = fs47.readFileSync(entryPath, "utf8");
-  const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN);
-  const hasCall = hasExecutablePattern2(source, WORKSPACE_BLOCK_STYLES_CALL_PATTERN);
-  return createDoctorCheck2(`Block style entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block style registration hook is present" : "Missing ./styles import or registerWorkspaceBlockStyles() call");
-}
-function checkBlockTransformEntrypoint(projectDir, blockSlug) {
-  const entryPath = path63.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
-  if (!fs47.existsSync(entryPath)) {
-    return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, "fail", `Missing ${path63.relative(projectDir, entryPath)}`);
+  if (inventory.abilities.length > 0) {
+    checks3.push(checkWorkspaceAbilityBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    checks3.push(checkWorkspaceAbilityIndex(workspace.projectDir, inventory.abilities));
   }
-  const source = fs47.readFileSync(entryPath, "utf8");
-  const hasImport = hasUncommentedPattern2(source, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN);
-  const hasCall = hasExecutablePattern2(source, WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN);
-  return createDoctorCheck2(`Block transform entrypoint ${blockSlug}`, hasImport && hasCall ? "pass" : "fail", hasImport && hasCall ? "Block transform registration hook is present" : "Missing ./transforms import or applyWorkspaceBlockTransforms(registration.settings) call");
+  for (const ability of inventory.abilities) {
+    checks3.push(checkWorkspaceAbilityConfig(workspace.projectDir, ability));
+    checks3.push(checkExistingFiles(workspace.projectDir, `Ability ${ability.slug}`, getWorkspaceAbilityRequiredFiles(ability)));
+  }
+  if (inventory.aiFeatures.length > 0) {
+    checks3.push(checkWorkspaceAiFeatureBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+  }
+  for (const aiFeature of inventory.aiFeatures) {
+    checks3.push(checkWorkspaceAiFeatureConfig(aiFeature));
+    checks3.push(checkExistingFiles(workspace.projectDir, `AI feature ${aiFeature.slug}`, getWorkspaceAiFeatureRequiredFiles(aiFeature)));
+  }
+  if (inventory.editorPlugins.length > 0) {
+    checks3.push(checkWorkspaceEditorPluginBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    checks3.push(checkWorkspaceEditorPluginIndex(workspace.projectDir, inventory.editorPlugins));
+  }
+  for (const editorPlugin of inventory.editorPlugins) {
+    checks3.push(checkExistingFiles(workspace.projectDir, `Editor plugin ${editorPlugin.slug}`, getWorkspaceEditorPluginRequiredFiles(editorPlugin)));
+    checks3.push(checkWorkspaceEditorPluginConfig(editorPlugin));
+  }
+  if (inventory.adminViews.length > 0) {
+    checks3.push(checkWorkspaceAdminViewBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
+    checks3.push(checkWorkspaceAdminViewIndex(workspace.projectDir, inventory.adminViews));
+  }
+  for (const adminView of inventory.adminViews) {
+    checks3.push(checkWorkspaceAdminViewConfig(adminView, inventory));
+    checks3.push(checkExistingFiles(workspace.projectDir, `Admin view ${adminView.slug}`, getWorkspaceAdminViewRequiredFiles(adminView)));
+    checks3.push(checkWorkspaceAdminViewPhp(workspace.projectDir, adminView));
+  }
+  return checks3;
 }
-function checkBlockTransformConfig(workspace, transform2) {
-  const expectedTo = `${workspace.workspace.namespace}/${transform2.block}`;
+var init_cli_doctor_workspace_features = __esm(() => {
+  init_cli_add_shared();
+  init_cli_doctor_workspace_shared();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace-package.ts
+import fs51 from "fs";
+import path67 from "path";
+function getWorkspacePackageMetadataCheck(workspace, packageJson) {
   const issues = [];
-  if (!WORKSPACE_FULL_BLOCK_NAME_PATTERN.test(transform2.from)) {
-    issues.push("from must use full namespace/block format");
+  const packageName = packageJson.name;
+  const bootstrapRelativePath = getWorkspaceBootstrapRelativePath(typeof packageName === "string" && packageName.length > 0 ? packageName : workspace.packageName);
+  const wpTypia = packageJson.wpTypia;
+  if (typeof packageName !== "string" || packageName.length === 0) {
+    issues.push("package.json must define a string name for workspace bootstrap resolution");
   }
-  if (transform2.to !== expectedTo) {
-    issues.push(`to must equal "${expectedTo}" for workspace block "${transform2.block}"`);
+  if (wpTypia?.projectType !== "workspace") {
+    issues.push('wpTypia.projectType must be "workspace"');
   }
-  return createDoctorCheck2(`Block transform config ${transform2.block}/${transform2.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `${transform2.from} transforms into ${transform2.to}` : issues.join("; "));
+  if (wpTypia?.templatePackage !== WORKSPACE_TEMPLATE_PACKAGE) {
+    issues.push(`wpTypia.templatePackage must be "${WORKSPACE_TEMPLATE_PACKAGE}"`);
+  }
+  if (wpTypia?.namespace !== workspace.workspace.namespace) {
+    issues.push(`wpTypia.namespace must equal "${workspace.workspace.namespace}"`);
+  }
+  if (wpTypia?.textDomain !== workspace.workspace.textDomain) {
+    issues.push(`wpTypia.textDomain must equal "${workspace.workspace.textDomain}"`);
+  }
+  if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
+    issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
+  }
+  if (!fs51.existsSync(path67.join(workspace.projectDir, bootstrapRelativePath))) {
+    issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
+  }
+  return createDoctorCheck2("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}` : issues.join("; "));
 }
-function checkMigrationWorkspaceHint(workspace, packageJson) {
+function getMigrationWorkspaceHintCheck(workspace, packageJson) {
   const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
-  const migrationConfigRelativePath = path63.join("src", "migrations", "config.ts");
-  const hasMigrationConfig = fs47.existsSync(path63.join(workspace.projectDir, migrationConfigRelativePath));
+  const migrationConfigRelativePath = path67.join("src", "migrations", "config.ts");
+  const hasMigrationConfig = fs51.existsSync(path67.join(workspace.projectDir, migrationConfigRelativePath));
   if (!hasMigrationScript && !hasMigrationConfig) {
     return null;
   }
   return createDoctorCheck2("Migration workspace", hasMigrationConfig ? "pass" : "fail", hasMigrationConfig ? "Run `wp-typia migrate doctor --all` for migration target, snapshot, fixture, and generated artifact checks" : `Missing ${migrationConfigRelativePath} for the configured migration workspace`);
 }
+var init_cli_doctor_workspace_package = __esm(() => {
+  init_cli_doctor_workspace_shared();
+  init_workspace_project();
+});
+
+// ../wp-typia-project-tools/src/runtime/cli-doctor-workspace.ts
+function formatWorkspaceInventorySummary(inventory) {
+  return [
+    `${inventory.blocks.length} block(s)`,
+    `${inventory.variations.length} variation(s)`,
+    `${inventory.blockStyles.length} block style(s)`,
+    `${inventory.blockTransforms.length} block transform(s)`,
+    `${inventory.patterns.length} pattern(s)`,
+    `${inventory.bindingSources.length} binding source(s)`,
+    `${inventory.restResources.length} REST resource(s)`,
+    `${inventory.abilities.length} ability scaffold(s)`,
+    `${inventory.aiFeatures.length} AI feature(s)`,
+    `${inventory.editorPlugins.length} editor plugin(s)`,
+    `${inventory.adminViews.length} admin view(s)`
+  ].join(", ");
+}
 function getWorkspaceDoctorChecks(cwd) {
   const checks3 = [];
   let workspace = null;
@@ -238057,122 +238802,14 @@ function getWorkspaceDoctorChecks(cwd) {
     checks3.push(createDoctorCheck2("Workspace package metadata", "fail", error48 instanceof Error ? error48.message : String(error48)));
     return checks3;
   }
-  checks3.push(checkWorkspacePackageMetadata(workspace, workspacePackageJson));
+  checks3.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson));
   try {
     const inventory = readWorkspaceInventory(workspace.projectDir);
-    checks3.push(createDoctorCheck2("Workspace inventory", "pass", `${inventory.blocks.length} block(s), ${inventory.variations.length} variation(s), ${inventory.blockStyles.length} block style(s), ${inventory.blockTransforms.length} block transform(s), ${inventory.patterns.length} pattern(s), ${inventory.bindingSources.length} binding source(s), ${inventory.restResources.length} REST resource(s), ${inventory.abilities.length} ability scaffold(s), ${inventory.aiFeatures.length} AI feature(s), ${inventory.editorPlugins.length} editor plugin(s), ${inventory.adminViews.length} admin view(s)`));
-    for (const block of inventory.blocks) {
-      checks3.push(checkExistingFiles(workspace.projectDir, `Block ${block.slug}`, getWorkspaceBlockRequiredFiles(block)));
-      checks3.push(checkWorkspaceBlockMetadata(workspace.projectDir, workspace, block));
-      checks3.push(checkWorkspaceBlockHooks(workspace.projectDir, block.slug));
-      checks3.push(checkWorkspaceBlockCollectionImport(workspace.projectDir, block.slug));
-      checks3.push(...checkWorkspaceBlockIframeCompatibility(workspace.projectDir, block.slug));
-    }
-    const registeredBlockSlugs = new Set(inventory.blocks.map((block) => block.slug));
-    const variationTargetBlocks = new Set;
-    for (const variation of inventory.variations) {
-      if (!registeredBlockSlugs.has(variation.block)) {
-        checks3.push(createDoctorCheck2(`Variation ${variation.block}/${variation.slug}`, "fail", `Variation references unknown block "${variation.block}"`));
-        continue;
-      }
-      variationTargetBlocks.add(variation.block);
-      checks3.push(checkExistingFiles(workspace.projectDir, `Variation ${variation.block}/${variation.slug}`, [variation.file]));
-    }
-    for (const blockSlug of variationTargetBlocks) {
-      checks3.push(checkVariationEntrypoint(workspace.projectDir, blockSlug));
-    }
-    const blockStyleTargetBlocks = new Set;
-    for (const blockStyle of inventory.blockStyles) {
-      if (!registeredBlockSlugs.has(blockStyle.block)) {
-        checks3.push(createDoctorCheck2(`Block style ${blockStyle.block}/${blockStyle.slug}`, "fail", `Block style references unknown block "${blockStyle.block}"`));
-        continue;
-      }
-      blockStyleTargetBlocks.add(blockStyle.block);
-      checks3.push(checkExistingFiles(workspace.projectDir, `Block style ${blockStyle.block}/${blockStyle.slug}`, [blockStyle.file]));
-    }
-    for (const blockSlug of blockStyleTargetBlocks) {
-      checks3.push(checkExistingFiles(workspace.projectDir, `Block style registry ${blockSlug}`, [
-        path63.join("src", "blocks", blockSlug, "styles", "index.ts")
-      ]));
-      checks3.push(checkBlockStyleEntrypoint(workspace.projectDir, blockSlug));
-    }
-    const blockTransformTargetBlocks = new Set;
-    for (const blockTransform of inventory.blockTransforms) {
-      if (!registeredBlockSlugs.has(blockTransform.block)) {
-        checks3.push(createDoctorCheck2(`Block transform ${blockTransform.block}/${blockTransform.slug}`, "fail", `Block transform references unknown block "${blockTransform.block}"`));
-        continue;
-      }
-      blockTransformTargetBlocks.add(blockTransform.block);
-      checks3.push(checkBlockTransformConfig(workspace, blockTransform));
-      checks3.push(checkExistingFiles(workspace.projectDir, `Block transform ${blockTransform.block}/${blockTransform.slug}`, [blockTransform.file]));
-    }
-    for (const blockSlug of blockTransformTargetBlocks) {
-      checks3.push(checkExistingFiles(workspace.projectDir, `Block transform registry ${blockSlug}`, [
-        path63.join("src", "blocks", blockSlug, "transforms", "index.ts")
-      ]));
-      checks3.push(checkBlockTransformEntrypoint(workspace.projectDir, blockSlug));
-    }
-    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs47.existsSync(path63.join(workspace.projectDir, "src", "patterns"));
-    if (shouldCheckPatternBootstrap) {
-      checks3.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
-    }
-    for (const pattern of inventory.patterns) {
-      checks3.push(checkExistingFiles(workspace.projectDir, `Pattern ${pattern.slug}`, [pattern.file]));
-    }
-    if (inventory.bindingSources.length > 0) {
-      checks3.push(checkWorkspaceBindingBootstrap(workspace.projectDir, workspace.packageName));
-      checks3.push(checkWorkspaceBindingSourcesIndex(workspace.projectDir, inventory.bindingSources));
-    }
-    for (const bindingSource of inventory.bindingSources) {
-      checks3.push(checkExistingFiles(workspace.projectDir, `Binding source ${bindingSource.slug}`, [
-        bindingSource.serverFile,
-        bindingSource.editorFile
-      ]));
-      const bindingTargetCheck = checkWorkspaceBindingTarget(workspace.projectDir, workspace, registeredBlockSlugs, bindingSource);
-      if (bindingTargetCheck) {
-        checks3.push(bindingTargetCheck);
-      }
-    }
-    if (inventory.restResources.length > 0) {
-      checks3.push(checkWorkspaceRestResourceBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-    }
-    for (const restResource of inventory.restResources) {
-      checks3.push(checkWorkspaceRestResourceConfig(restResource));
-      checks3.push(checkExistingFiles(workspace.projectDir, `REST resource ${restResource.slug}`, getWorkspaceRestResourceRequiredFiles(restResource)));
-    }
-    if (inventory.abilities.length > 0) {
-      checks3.push(checkWorkspaceAbilityBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-      checks3.push(checkWorkspaceAbilityIndex(workspace.projectDir, inventory.abilities));
-    }
-    for (const ability of inventory.abilities) {
-      checks3.push(checkWorkspaceAbilityConfig(workspace.projectDir, ability));
-      checks3.push(checkExistingFiles(workspace.projectDir, `Ability ${ability.slug}`, getWorkspaceAbilityRequiredFiles(ability)));
-    }
-    if (inventory.aiFeatures.length > 0) {
-      checks3.push(checkWorkspaceAiFeatureBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-    }
-    for (const aiFeature of inventory.aiFeatures) {
-      checks3.push(checkWorkspaceAiFeatureConfig(aiFeature));
-      checks3.push(checkExistingFiles(workspace.projectDir, `AI feature ${aiFeature.slug}`, getWorkspaceAiFeatureRequiredFiles(aiFeature)));
-    }
-    if (inventory.editorPlugins.length > 0) {
-      checks3.push(checkWorkspaceEditorPluginBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-      checks3.push(checkWorkspaceEditorPluginIndex(workspace.projectDir, inventory.editorPlugins));
-    }
-    for (const editorPlugin of inventory.editorPlugins) {
-      checks3.push(checkExistingFiles(workspace.projectDir, `Editor plugin ${editorPlugin.slug}`, getWorkspaceEditorPluginRequiredFiles(editorPlugin)));
-      checks3.push(checkWorkspaceEditorPluginConfig(editorPlugin));
-    }
-    if (inventory.adminViews.length > 0) {
-      checks3.push(checkWorkspaceAdminViewBootstrap(workspace.projectDir, workspace.packageName, workspace.workspace.phpPrefix));
-      checks3.push(checkWorkspaceAdminViewIndex(workspace.projectDir, inventory.adminViews));
-    }
-    for (const adminView of inventory.adminViews) {
-      checks3.push(checkWorkspaceAdminViewConfig(adminView, inventory));
-      checks3.push(checkExistingFiles(workspace.projectDir, `Admin view ${adminView.slug}`, getWorkspaceAdminViewRequiredFiles(adminView)));
-      checks3.push(checkWorkspaceAdminViewPhp(workspace.projectDir, adminView));
-    }
-    const migrationWorkspaceCheck = checkMigrationWorkspaceHint(workspace, workspacePackageJson);
+    checks3.push(createDoctorCheck2("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
+    checks3.push(...getWorkspaceBlockDoctorChecks(workspace, inventory));
+    checks3.push(...getWorkspaceBindingDoctorChecks(workspace, inventory));
+    checks3.push(...getWorkspaceFeatureDoctorChecks(workspace, inventory));
+    const migrationWorkspaceCheck = getMigrationWorkspaceHintCheck(workspace, workspacePackageJson);
     if (migrationWorkspaceCheck) {
       checks3.push(migrationWorkspaceCheck);
     }
@@ -238181,55 +238818,14 @@ function getWorkspaceDoctorChecks(cwd) {
   }
   return checks3;
 }
-var WORKSPACE_COLLECTION_IMPORT_LINE = "import '../../collection';", WORKSPACE_COLLECTION_IMPORT_PATTERN, WORKSPACE_BINDING_SERVER_GLOB = "/src/bindings/*/server.php", WORKSPACE_BINDING_EDITOR_SCRIPT = "build/bindings/index.js", WORKSPACE_BINDING_EDITOR_ASSET = "build/bindings/index.asset.php", WORKSPACE_REST_RESOURCE_GLOB = "/inc/rest/*.php", WORKSPACE_ABILITY_GLOB = "/inc/abilities/*.php", WORKSPACE_ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", WORKSPACE_ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", WORKSPACE_AI_FEATURE_GLOB = "/inc/ai-features/*.php", WORKSPACE_ADMIN_VIEW_GLOB = "/inc/admin-views/*.php", WORKSPACE_ADMIN_VIEW_SCRIPT = "build/admin-views/index.js", WORKSPACE_ADMIN_VIEW_ASSET = "build/admin-views/index.asset.php", WORKSPACE_ADMIN_VIEW_STYLE = "build/admin-views/style-index.css", WORKSPACE_EDITOR_PLUGIN_EDITOR_SCRIPT = "build/editor-plugins/index.js", WORKSPACE_EDITOR_PLUGIN_EDITOR_ASSET = "build/editor-plugins/index.asset.php", WORKSPACE_EDITOR_PLUGIN_EDITOR_STYLE = "build/editor-plugins/style-index.css", WORKSPACE_GENERATED_BLOCK_ARTIFACTS, WORKSPACE_FULL_BLOCK_NAME_PATTERN, WORKSPACE_VARIATIONS_IMPORT_PATTERN, WORKSPACE_VARIATIONS_CALL_PATTERN, WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN, WORKSPACE_BLOCK_STYLES_CALL_PATTERN, WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN, WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN, WORKSPACE_BLOCK_IFRAME_COMPATIBILITY_DOC_URL = "https://developer.wordpress.org/block-editor/reference-guides/block-api/block-api-versions/block-migration-for-iframe-editor-compatibility/", WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES, WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN, WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES, WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES, WORKSPACE_BLOCK_LOCAL_STYLE_FILES, WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN, WORKSPACE_BLOCK_PROPS_PATTERN;
 var init_cli_doctor_workspace = __esm(() => {
-  init_cli_add_shared();
-  init_hooked_blocks();
+  init_cli_doctor_workspace_bindings();
+  init_cli_doctor_workspace_blocks();
+  init_cli_doctor_workspace_features();
+  init_cli_doctor_workspace_package();
+  init_cli_doctor_workspace_shared();
   init_workspace_inventory();
   init_workspace_project();
-  WORKSPACE_COLLECTION_IMPORT_PATTERN = /^\s*import\s+["']\.\.\/\.\.\/collection["']\s*;?\s*$/m;
-  WORKSPACE_GENERATED_BLOCK_ARTIFACTS = [
-    "block.json",
-    "typia.manifest.json",
-    "typia.schema.json",
-    "typia-validator.php",
-    "typia.openapi.json"
-  ];
-  WORKSPACE_FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
-  WORKSPACE_VARIATIONS_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceVariations\s*\}\s*from\s*["']\.\/variations["']\s*;?\s*$/mu;
-  WORKSPACE_VARIATIONS_CALL_PATTERN = /registerWorkspaceVariations\s*\(\s*\)\s*;?/u;
-  WORKSPACE_BLOCK_STYLES_IMPORT_PATTERN = /^\s*import\s*\{\s*registerWorkspaceBlockStyles\s*\}\s*from\s*["']\.\/styles["']\s*;?\s*$/mu;
-  WORKSPACE_BLOCK_STYLES_CALL_PATTERN = /registerWorkspaceBlockStyles\s*\(\s*\)\s*;?/u;
-  WORKSPACE_BLOCK_TRANSFORMS_IMPORT_PATTERN = /^\s*import\s*\{\s*applyWorkspaceBlockTransforms\s*\}\s*from\s*["']\.\/transforms["']\s*;?\s*$/mu;
-  WORKSPACE_BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
-  WORKSPACE_BLOCK_IFRAME_DIAGNOSTIC_CODES = {
-    API_VERSION: "wp-typia.workspace.block.iframe.api-version",
-    BLOCK_PROPS: "wp-typia.workspace.block.iframe.block-props",
-    EDITOR_GLOBALS: "wp-typia.workspace.block.iframe.editor-globals",
-    EDITOR_STYLES: "wp-typia.workspace.block.iframe.editor-styles"
-  };
-  WORKSPACE_BLOCK_EDITOR_SOURCE_FILE_PATTERN = /\.[cm]?[jt]sx?$/u;
-  WORKSPACE_BLOCK_EDITOR_SOURCE_BASENAMES = new Set([
-    "edit",
-    "editor",
-    "index",
-    "save"
-  ]);
-  WORKSPACE_BLOCK_EDITOR_SOURCE_DIRECTORIES = new Set([
-    "components",
-    "controls",
-    "editor",
-    "inspector"
-  ]);
-  WORKSPACE_BLOCK_LOCAL_STYLE_FILES = [
-    "editor.css",
-    "editor.scss",
-    "index.css",
-    "style.css",
-    "style.scss"
-  ];
-  WORKSPACE_BLOCK_IFRAME_GLOBAL_DOM_PATTERN = /\b(?:document|window)\b|\b(?:parent|top)\b(?!\s*:)/gu;
-  WORKSPACE_BLOCK_PROPS_PATTERN = /\buse(?:Block|InnerBlocks)Props(?:\.save)?\s*\(/u;
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor.ts
@@ -238278,19 +238874,19 @@ __export(exports_cli_init, {
   getInitPlan: () => getInitPlan,
   applyInitPlan: () => applyInitPlan
 });
-import fs48 from "fs";
+import fs52 from "fs";
 import { promises as fsp25 } from "fs";
-import path64 from "path";
+import path68 from "path";
 import { analyzeSourceTypes } from "@wp-typia/block-runtime/metadata-parser";
 function normalizeRelativePath2(value2) {
   return value2.replace(/\\/gu, "/");
 }
 function readProjectPackageJson(projectDir) {
-  const packageJsonPath = path64.join(projectDir, "package.json");
-  if (!fs48.existsSync(packageJsonPath)) {
+  const packageJsonPath = path68.join(projectDir, "package.json");
+  if (!fs52.existsSync(packageJsonPath)) {
     return null;
   }
-  const source = fs48.readFileSync(packageJsonPath, "utf8");
+  const source = fs52.readFileSync(packageJsonPath, "utf8");
   try {
     return JSON.parse(source);
   } catch (error48) {
@@ -238302,13 +238898,13 @@ function inferInitPackageManager(projectDir, packageJson) {
   if (packageJson?.packageManager) {
     return parseWorkspacePackageManagerId(packageJson.packageManager);
   }
-  if (fs48.existsSync(path64.join(projectDir, "bun.lock")) || fs48.existsSync(path64.join(projectDir, "bun.lockb"))) {
+  if (fs52.existsSync(path68.join(projectDir, "bun.lock")) || fs52.existsSync(path68.join(projectDir, "bun.lockb"))) {
     return "bun";
   }
-  if (fs48.existsSync(path64.join(projectDir, "pnpm-lock.yaml"))) {
+  if (fs52.existsSync(path68.join(projectDir, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs48.existsSync(path64.join(projectDir, "yarn.lock")) || fs48.existsSync(path64.join(projectDir, ".yarnrc.yml"))) {
+  if (fs52.existsSync(path68.join(projectDir, "yarn.lock")) || fs52.existsSync(path68.join(projectDir, ".yarnrc.yml"))) {
     return "yarn";
   }
   return "npm";
@@ -238392,13 +238988,13 @@ function buildPackageManagerFieldChange(packageJson, packageManager, options = {
   };
 }
 function buildGeneratedArtifactPaths(blockJsonFile, manifestFile) {
-  const manifestDir = path64.dirname(manifestFile);
+  const manifestDir = path68.dirname(manifestFile);
   const artifactPaths = [
     blockJsonFile,
     manifestFile,
-    path64.join(manifestDir, "typia.schema.json"),
-    path64.join(manifestDir, "typia-validator.php"),
-    path64.join(manifestDir, "typia.openapi.json")
+    path68.join(manifestDir, "typia.schema.json"),
+    path68.join(manifestDir, "typia-validator.php"),
+    path68.join(manifestDir, "typia.openapi.json")
   ];
   return Array.from(new Set(artifactPaths.map((filePath) => normalizeRelativePath2(filePath))));
 }
@@ -238419,8 +239015,8 @@ function isObjectLikeSourceType(projectDir, typesFile, sourceTypeName) {
   return analyzedTypes[sourceTypeName]?.kind === "object";
 }
 function inferRetrofitAttributeTypeName(projectDir, block) {
-  const typesPath = path64.join(projectDir, block.typesFile);
-  const typesSource = fs48.readFileSync(typesPath, "utf8");
+  const typesPath = path68.join(projectDir, block.typesFile);
+  const typesSource = fs52.readFileSync(typesPath, "utf8");
   const blockNameSegments = block.blockName.split("/");
   const slug = blockNameSegments[blockNameSegments.length - 1] ?? block.key;
   const candidateNames = collectNamedSourceTypeCandidates(typesSource);
@@ -238725,10 +239321,10 @@ function hasExistingWpTypiaProjectSurface(projectDir, packageJson) {
   const scripts = packageJson?.scripts ?? {};
   const hasSyncSurface = typeof scripts.sync === "string" || typeof scripts["sync-types"] === "string";
   const hasHelperFiles = [
-    path64.join("scripts", "block-config.ts"),
-    path64.join("scripts", "sync-project.ts"),
-    path64.join("scripts", "sync-types-to-block-json.ts")
-  ].every((relativePath) => fs48.existsSync(path64.join(projectDir, relativePath)));
+    path68.join("scripts", "block-config.ts"),
+    path68.join("scripts", "sync-project.ts"),
+    path68.join("scripts", "sync-types-to-block-json.ts")
+  ].every((relativePath) => fs52.existsSync(path68.join(projectDir, relativePath)));
   const hasRuntimeDeps = typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-runtime") === "string" && typeof getExistingDependencyVersion(packageJson, "@wp-typia/block-types") === "string";
   return hasSyncSurface && hasHelperFiles && hasRuntimeDeps;
 }
@@ -238738,17 +239334,17 @@ function buildPlannedFiles(projectDir, layoutKind) {
   }
   return [
     {
-      action: fs48.existsSync(path64.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
+      action: fs52.existsSync(path68.join(projectDir, "scripts", "block-config.ts")) ? "update" : "add",
       path: "scripts/block-config.ts",
       purpose: "Declare the current retrofit block targets so sync-types can regenerate metadata from the existing TypeScript source of truth."
     },
     {
-      action: fs48.existsSync(path64.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
+      action: fs52.existsSync(path68.join(projectDir, "scripts", "sync-types-to-block-json.ts")) ? "update" : "add",
       path: "scripts/sync-types-to-block-json.ts",
       purpose: "Generate block.json and Typia metadata artifacts from the current TypeScript source of truth."
     },
     {
-      action: fs48.existsSync(path64.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
+      action: fs52.existsSync(path68.join(projectDir, "scripts", "sync-project.ts")) ? "update" : "add",
       path: "scripts/sync-project.ts",
       purpose: "Provide one shared sync entrypoint that can grow into sync-rest or workspace-aware refresh steps later."
     }
@@ -238896,14 +239492,14 @@ function buildProjectPackageJsonSource(packageJson) {
 }
 function buildRetrofitHelperFiles(blockTargets) {
   return {
-    [path64.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
-    [path64.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
-    [path64.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
+    [path68.join("scripts", "block-config.ts")]: buildRetrofitBlockConfigSource(blockTargets),
+    [path68.join("scripts", "sync-project.ts")]: buildRetrofitSyncProjectScriptSource(),
+    [path68.join("scripts", "sync-types-to-block-json.ts")]: buildRetrofitSyncTypesScriptSource()
   };
 }
 async function createRetrofitMutationSnapshot(projectDir, filePaths) {
-  const scriptsDir = path64.join(projectDir, "scripts");
-  const scriptsDirExisted = fs48.existsSync(scriptsDir);
+  const scriptsDir = path68.join(projectDir, "scripts");
+  const scriptsDirExisted = fs52.existsSync(scriptsDir);
   const fileSources = await snapshotWorkspaceFiles(filePaths);
   const targetPaths = fileSources.filter((entry) => entry.source === null).map((entry) => entry.filePath);
   if (!scriptsDirExisted) {
@@ -238917,11 +239513,11 @@ async function createRetrofitMutationSnapshot(projectDir, filePaths) {
 }
 async function writeRetrofitFiles(options) {
   const helperFiles = buildRetrofitHelperFiles(options.blockTargets);
-  const scriptsDir = path64.join(options.projectDir, "scripts");
+  const scriptsDir = path68.join(options.projectDir, "scripts");
   await fsp25.mkdir(scriptsDir, { recursive: true });
-  await fsp25.writeFile(path64.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
+  await fsp25.writeFile(path68.join(options.projectDir, "package.json"), buildProjectPackageJsonSource(options.packageJson), "utf8");
   for (const [relativePath, source] of Object.entries(helperFiles)) {
-    await fsp25.writeFile(path64.join(options.projectDir, relativePath), source, "utf8");
+    await fsp25.writeFile(path68.join(options.projectDir, relativePath), source, "utf8");
   }
 }
 function buildApplyFailureError(error48) {
@@ -238929,7 +239525,7 @@ function buildApplyFailureError(error48) {
   return createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.INVALID_ARGUMENT, `Unable to apply the retrofit init plan safely. The command restored the previous package.json/helper-file snapshot. ${message}`, error48 instanceof Error ? { cause: error48 } : undefined);
 }
 function getInitPlan(projectDir, options = {}) {
-  const resolvedProjectDir = path64.resolve(projectDir);
+  const resolvedProjectDir = path68.resolve(projectDir);
   const packageJson = readProjectPackageJson(resolvedProjectDir);
   const packageManager = resolveInitPackageManager(resolvedProjectDir, packageJson, options.packageManager);
   const workspace = tryResolveWorkspaceProject(resolvedProjectDir);
@@ -238965,7 +239561,7 @@ function getInitPlan(projectDir, options = {}) {
       status: "already-initialized"
     });
   }
-  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path64.basename(resolvedProjectDir);
+  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path68.basename(resolvedProjectDir);
   const layout = buildLayoutDetails(resolvedProjectDir);
   const dependencyChanges = buildDependencyChanges(packageJson);
   const scriptChanges = buildScriptChanges(packageJson, packageManager);
@@ -239031,8 +239627,8 @@ async function applyInitPlan(projectDir, options = {}) {
   });
   const helperFiles = buildRetrofitHelperFiles(previewPlan.blockTargets);
   const filePaths = [
-    path64.join(previewPlan.projectDir, "package.json"),
-    ...Object.keys(helperFiles).map((relativePath) => path64.join(previewPlan.projectDir, relativePath))
+    path68.join(previewPlan.projectDir, "package.json"),
+    ...Object.keys(helperFiles).map((relativePath) => path68.join(previewPlan.projectDir, relativePath))
   ];
   const mutationSnapshot = await createRetrofitMutationSnapshot(previewPlan.projectDir, filePaths);
   try {
@@ -239094,27 +239690,27 @@ __export(exports_cli_scaffold, {
   getOptionalOnboarding: () => getOptionalOnboarding,
   getNextSteps: () => getNextSteps
 });
-import fs49 from "fs";
+import fs53 from "fs";
 import { promises as fsp26 } from "fs";
-import path65 from "path";
+import path69 from "path";
 async function listRelativeProjectFiles(rootDir) {
   const relativeFiles = [];
   async function visit2(currentDir) {
     const entries = await fsp26.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = path65.join(currentDir, entry.name);
+      const absolutePath = path69.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         await visit2(absolutePath);
         continue;
       }
-      relativeFiles.push(path65.relative(rootDir, absolutePath).replace(path65.sep === "\\" ? /\\/gu : /\//gu, "/"));
+      relativeFiles.push(path69.relative(rootDir, absolutePath).replace(path69.sep === "\\" ? /\\/gu : /\//gu, "/"));
     }
   }
   await visit2(rootDir);
   return relativeFiles.sort((left, right) => left.localeCompare(right));
 }
 async function assertDryRunTargetDirectoryReady(projectDir, allowExistingDir) {
-  if (!fs49.existsSync(projectDir) || allowExistingDir) {
+  if (!fs53.existsSync(projectDir) || allowExistingDir) {
     return;
   }
   const entries = await fsp26.readdir(projectDir);
@@ -239145,7 +239741,7 @@ async function buildScaffoldDryRunPlan({
 }) {
   await assertDryRunTargetDirectoryReady(projectDir, allowExistingDir);
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-scaffold-plan-");
-  const previewProjectDir = path65.join(tempRoot, "preview-project");
+  const previewProjectDir = path69.join(tempRoot, "preview-project");
   try {
     const result = await scaffoldProject({
       allowExistingDir: false,
@@ -239185,14 +239781,14 @@ function validateCreateProjectInput(projectInput) {
   if (normalizedProjectInput.length === 0) {
     throw new Error("Project directory is required. Usage: wp-typia create <project-dir> (or wp-typia <project-dir> when <project-dir> is the only positional argument).");
   }
-  const normalizedProjectPath = path65.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path65.normalize(normalizedProjectInput);
+  const normalizedProjectPath = path69.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path69.normalize(normalizedProjectInput);
   if (normalizedProjectPath === "." || normalizedProjectPath === "..") {
     throw new Error("`wp-typia create` requires a new project directory. Use an explicit child directory instead of `.` or `..`.");
   }
 }
 function collectProjectDirectoryWarnings(projectDir) {
   const warnings = [];
-  const projectName = path65.basename(projectDir);
+  const projectName = path69.basename(projectDir);
   if (/\s/u.test(projectName)) {
     warnings.push(`Project directory "${projectName}" contains spaces. The generated next-step commands will be quoted, but a simple kebab-case directory name is usually easier to use with shells and downstream tooling.`);
   }
@@ -239347,7 +239943,7 @@ function getNextSteps({
   noInstall,
   templateId
 }) {
-  const cdTarget = path65.isAbsolute(projectInput) ? projectDir : projectInput;
+  const cdTarget = path69.isAbsolute(projectInput) ? projectDir : projectInput;
   const steps = [`cd ${quoteShellValue(cdTarget)}`];
   if (noInstall) {
     steps.push(formatInstallCommand(packageManager));
@@ -239495,8 +240091,8 @@ async function runScaffoldFlow({
       select: selectWithMigrationUi,
       yes
     });
-    const projectDir = path65.resolve(cwd, projectInput);
-    const projectName = path65.basename(projectDir);
+    const projectDir = path69.resolve(cwd, projectInput);
+    const projectName = path69.basename(projectDir);
     const answers = await collectScaffoldAnswers({
       dataStorageMode: resolvedDataStorage,
       namespace,
@@ -239559,7 +240155,7 @@ async function runScaffoldFlow({
     let availableScripts;
     if (!dryRun) {
       try {
-        const parsedPackageJson = JSON.parse(fs49.readFileSync(path65.join(projectDir, "package.json"), "utf8"));
+        const parsedPackageJson = JSON.parse(fs53.readFileSync(path69.join(projectDir, "package.json"), "utf8"));
         const scripts = parsedPackageJson.scripts && typeof parsedPackageJson.scripts === "object" && !Array.isArray(parsedPackageJson.scripts) ? parsedPackageJson.scripts : {};
         availableScripts = Object.entries(scripts).filter(([, value2]) => typeof value2 === "string").map(([scriptName]) => scriptName);
       } catch {
@@ -292682,6 +293278,63 @@ var ADD_KIND_IDS = [
   "editor-plugin"
 ];
 
+// src/cli-string-flags.ts
+init_cli_diagnostics();
+function readOptionalCliStringFlagValue(flags2, name2, mode) {
+  const value2 = flags2[name2];
+  if (value2 === undefined || value2 === null) {
+    return;
+  }
+  if (typeof value2 !== "string") {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name2}\` requires a value.`);
+  }
+  const trimmed = value2.trim();
+  if (trimmed.length === 0) {
+    if (mode === "strict") {
+      throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name2}\` requires a value.`);
+    }
+    return;
+  }
+  return mode === "strict" ? value2 : trimmed;
+}
+function readOptionalLooseStringFlag(flags2, name2) {
+  return readOptionalCliStringFlagValue(flags2, name2, "loose");
+}
+function readOptionalStrictStringFlag(flags2, name2) {
+  return readOptionalCliStringFlagValue(flags2, name2, "strict");
+}
+function requireStrictStringFlag(flags2, name2, message) {
+  const value2 = readOptionalStrictStringFlag(flags2, name2);
+  if (!value2) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return value2;
+}
+function readOptionalPairedStrictStringFlags(flags2, leftName, rightName, message) {
+  const leftValue = readOptionalStrictStringFlag(flags2, leftName);
+  const rightValue = readOptionalStrictStringFlag(flags2, rightName);
+  if (Boolean(leftValue) !== Boolean(rightValue)) {
+    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
+  }
+  return [leftValue, rightValue];
+}
+
+// src/external-layer-prompt-options.ts
+function formatExternalLayerSelectHint(option3) {
+  const details = [
+    option3.description,
+    option3.extends.length > 0 ? `extends ${option3.extends.join(", ")}` : undefined
+  ].filter((value2) => typeof value2 === "string" && value2.length > 0);
+  return details.length > 0 ? details.join(" \xB7 ") : undefined;
+}
+function toExternalLayerPromptOptions(options) {
+  return options.map((option3) => ({
+    hint: formatExternalLayerSelectHint(option3),
+    label: option3.id,
+    value: option3.id
+  }));
+}
+
 // src/add-kind-registry.ts
 var BLOCK_VISIBLE_FIELD_ORDER = [
   "kind",
@@ -292740,51 +293393,12 @@ var NAME_NAMESPACE_VISIBLE_FIELDS = [
   "name",
   "namespace"
 ];
-function readOptionalStringFlag(flags2, name2) {
-  const value2 = flags2[name2];
-  if (value2 === undefined || value2 === null) {
-    return;
-  }
-  if (typeof value2 !== "string" || value2.trim().length === 0) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name2}\` requires a value.`);
-  }
-  return value2;
-}
-function requireStringFlag(flags2, name2, message) {
-  const value2 = readOptionalStringFlag(flags2, name2);
-  if (!value2) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-  }
-  return value2;
-}
-function readOptionalPairedStringFlags(flags2, leftName, rightName, message) {
-  const leftValue = readOptionalStringFlag(flags2, leftName);
-  const rightValue = readOptionalStringFlag(flags2, rightName);
-  if (Boolean(leftValue) !== Boolean(rightValue)) {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
-  }
-  return [leftValue, rightValue];
-}
 function requireAddKindName(context, message) {
   if (!context.name) {
     throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, message);
   }
   return context.name;
 }
-function formatExternalLayerSelectHint(option3) {
-  const details = [
-    option3.description,
-    option3.extends.length > 0 ? `extends ${option3.extends.join(", ")}` : undefined
-  ].filter((value2) => typeof value2 === "string" && value2.length > 0);
-  return details.length > 0 ? details.join(" \xB7 ") : undefined;
-}
-function toExternalLayerPromptOptions(options) {
-  return options.map((option3) => ({
-    hint: formatExternalLayerSelectHint(option3),
-    label: option3.id,
-    value: option3.id
-  }));
-}
 function defineAddKindRegistryEntry(entry) {
   return entry;
 }
@@ -292818,7 +293432,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Admin view name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add admin-view` requires <name>. Usage: wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>].");
-      const source = readOptionalStringFlag(context.flags, "source");
+      const source = readOptionalStrictStringFlag(context.flags, "source");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddAdminViewCommand({
           adminViewName: name3,
@@ -292858,7 +293472,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Binding source name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add binding-source` requires <name>. Usage: wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>].");
-      const [blockName, attributeName] = readOptionalPairedStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
+      const [blockName, attributeName] = readOptionalPairedStrictStringFlags(context.flags, "block", "attribute", "`wp-typia add binding-source` requires --block and --attribute to be provided together.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBindingSourceCommand({
           attributeName,
@@ -292898,15 +293512,15 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Block name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add block` requires <name>. Usage: wp-typia add block <name> [--template <basic|interactivity|persistence|compound>]");
-      const externalLayerId = readOptionalStringFlag(context.flags, "external-layer-id");
-      const externalLayerSource = readOptionalStringFlag(context.flags, "external-layer-source");
+      const externalLayerId = readOptionalStrictStringFlag(context.flags, "external-layer-id");
+      const externalLayerSource = readOptionalStrictStringFlag(context.flags, "external-layer-source");
       const shouldPromptForLayerSelection = Boolean(externalLayerSource) && !Boolean(externalLayerId) && context.isInteractiveSession;
       const selectPrompt = shouldPromptForLayerSelection ? await context.getOrCreatePrompt() : undefined;
-      const alternateRenderTargets = readOptionalStringFlag(context.flags, "alternate-render-targets");
-      const dataStorageMode = readOptionalStringFlag(context.flags, "data-storage");
-      const innerBlocksPreset = readOptionalStringFlag(context.flags, "inner-blocks-preset");
-      const persistencePolicy = readOptionalStringFlag(context.flags, "persistence-policy");
-      let resolvedTemplateId = readOptionalStringFlag(context.flags, "template");
+      const alternateRenderTargets = readOptionalStrictStringFlag(context.flags, "alternate-render-targets");
+      const dataStorageMode = readOptionalStrictStringFlag(context.flags, "data-storage");
+      const innerBlocksPreset = readOptionalStrictStringFlag(context.flags, "inner-blocks-preset");
+      const persistencePolicy = readOptionalStrictStringFlag(context.flags, "persistence-policy");
+      let resolvedTemplateId = readOptionalStrictStringFlag(context.flags, "template");
       if (!resolvedTemplateId && context.isInteractiveSession) {
         const templatePrompt = await context.getOrCreatePrompt();
         resolvedTemplateId = await templatePrompt.select("Select a block template", context.addRuntime.ADD_BLOCK_TEMPLATE_IDS.map((templateId) => ({
@@ -293003,7 +293617,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Editor plugin name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add editor-plugin` requires <name>. Usage: wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>].");
-      const slot = readOptionalStringFlag(context.flags, "slot");
+      const slot = readOptionalStrictStringFlag(context.flags, "slot");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddEditorPluginCommand({
           cwd,
@@ -293041,8 +293655,8 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Target block",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add hooked-block` requires <block-slug>. Usage: wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <before|after|firstChild|lastChild>.");
-      const anchorBlockName = requireStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
-      const position = requireStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
+      const anchorBlockName = requireStrictStringFlag(context.flags, "anchor", "`wp-typia add hooked-block` requires --anchor <anchor-block-name>.");
+      const position = requireStrictStringFlag(context.flags, "position", "`wp-typia add hooked-block` requires --position <before|after|firstChild|lastChild>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddHookedBlockCommand({
           anchorBlockName,
@@ -293112,7 +293726,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Style name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add style` requires <name>. Usage: wp-typia add style <name> --block <block-slug>.");
-      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
+      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add style` requires --block <block-slug>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockStyleCommand({
           blockName: blockSlug,
@@ -293150,8 +293764,8 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Transform name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add transform` requires <name>. Usage: wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>.");
-      const fromBlockName = requireStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
-      const toBlockName = requireStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
+      const fromBlockName = requireStrictStringFlag(context.flags, "from", "`wp-typia add transform` requires --from <namespace/block>.");
+      const toBlockName = requireStrictStringFlag(context.flags, "to", "`wp-typia add transform` requires --to <block-slug|namespace/block-slug>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddBlockTransformCommand({
           cwd,
@@ -293192,8 +293806,8 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "REST resource name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add rest-resource` requires <name>. Usage: wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>].");
-      const methods = readOptionalStringFlag(context.flags, "methods");
-      const namespace = readOptionalStringFlag(context.flags, "namespace");
+      const methods = readOptionalStrictStringFlag(context.flags, "methods");
+      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddRestResourceCommand({
           cwd,
@@ -293232,7 +293846,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "AI feature name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add ai-feature` requires <name>. Usage: wp-typia add ai-feature <name> [--namespace <vendor/v1>].");
-      const namespace = readOptionalStringFlag(context.flags, "namespace");
+      const namespace = readOptionalStrictStringFlag(context.flags, "namespace");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddAiFeatureCommand({
           aiFeatureName: name3,
@@ -293271,7 +293885,7 @@ var ADD_KIND_REGISTRY = {
     nameLabel: "Variation name",
     async prepareExecution(context) {
       const name2 = requireAddKindName(context, "`wp-typia add variation` requires <name>. Usage: wp-typia add variation <name> --block <block-slug>");
-      const blockSlug = requireStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
+      const blockSlug = requireStrictStringFlag(context.flags, "block", "`wp-typia add variation` requires --block <block-slug>.");
       return createNamedExecutionPlan(context, {
         execute: ({ cwd, name: name3 }) => context.addRuntime.runAddVariationCommand({
           blockName: blockSlug,
@@ -293449,7 +294063,7 @@ import path10 from "path";
 // package.json
 var package_default2 = {
   name: "wp-typia",
-  version: "0.22.1",
+  version: "0.22.3",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -293519,7 +294133,7 @@ var package_default2 = {
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/project-tools": "0.22.1",
+    "@wp-typia/project-tools": "0.22.3",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -293874,20 +294488,6 @@ function printBlock(lines, printLine) {
     printLine(line);
   }
 }
-function formatExternalLayerSelectHint2(option3) {
-  const details = [
-    option3.description,
-    option3.extends.length > 0 ? `extends ${option3.extends.join(", ")}` : undefined
-  ].filter((value2) => typeof value2 === "string" && value2.length > 0);
-  return details.length > 0 ? details.join(" \xB7 ") : undefined;
-}
-function toExternalLayerPromptOptions2(options) {
-  return options.map((option3) => ({
-    hint: formatExternalLayerSelectHint2(option3),
-    label: option3.id,
-    value: option3.id
-  }));
-}
 
 // src/runtime-capabilities.ts
 function isInteractiveTerminal({
@@ -294171,17 +294771,6 @@ function shouldWrapCliCommandError(options) {
   }
   return true;
 }
-function readOptionalLooseStringFlag(flags2, name2) {
-  const value2 = flags2[name2];
-  if (value2 === undefined || value2 === null) {
-    return;
-  }
-  if (typeof value2 !== "string") {
-    throw createCliDiagnosticCodeError(CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT, `\`--${name2}\` requires a value.`);
-  }
-  const trimmed = value2.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
 function pushFlag(argv, name2, value2) {
   if (value2 === undefined || value2 === null || value2 === false) {
     return;
@@ -294323,7 +294912,7 @@ async function executeCreateCommand({
       promptText: activePrompt ? (message, defaultValue, validate) => activePrompt.text(message, defaultValue, validate) : undefined,
       queryPostType: readOptionalLooseStringFlag(flags2, "query-post-type"),
       selectDataStorage: activePrompt ? () => activePrompt.select("Select a data storage mode", [...DATA_STORAGE_PROMPT_OPTIONS], 1) : undefined,
-      selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt ? (options) => activePrompt.select("Select an external layer", toExternalLayerPromptOptions2(options), 1) : undefined,
+      selectExternalLayerId: shouldPromptForExternalLayerSelection && activePrompt ? (options) => activePrompt.select("Select an external layer", toExternalLayerPromptOptions(options), 1) : undefined,
       selectPackageManager: activePrompt ? () => activePrompt.select("Select a package manager", [...PACKAGE_MANAGER_PROMPT_OPTIONS], 1) : undefined,
       selectPersistencePolicy: activePrompt ? () => activePrompt.select("Select a persistence policy", [...PERSISTENCE_POLICY_PROMPT_OPTIONS], 1) : undefined,
       selectTemplate: activePrompt ? () => activePrompt.select("Select a template", getTemplateSelectOptions2(), 1) : undefined,
@@ -295183,8 +295772,8 @@ var init_default = initCommand;
 init_cli_diagnostics();
 
 // src/mcp.ts
-import fs50 from "fs/promises";
-import path66 from "path";
+import fs54 from "fs/promises";
+import path70 from "path";
 
 // ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
 class SchemaConversionError extends TaggedError("SchemaConversionError")() {
@@ -295712,8 +296301,8 @@ function isToolGroup(value2) {
   return isObject3(value2) && typeof value2.namespace === "string" && Array.isArray(value2.tools) && value2.tools.every(isTool);
 }
 async function readSchemaSource(cwd, source) {
-  const schemaPath = path66.resolve(cwd, source.path);
-  const raw = await fs50.readFile(schemaPath, "utf8");
+  const schemaPath = path70.resolve(cwd, source.path);
+  const raw = await fs54.readFile(schemaPath, "utf8");
   const parsed = JSON.parse(raw);
   if (isToolGroup(parsed)) {
     return parsed;
@@ -295729,7 +296318,7 @@ async function readSchemaSource(cwd, source) {
 async function loadMcpToolGroups(cwd, schemaSources) {
   return Promise.all(schemaSources.map((source) => readSchemaSource(cwd, source)));
 }
-async function syncMcpSchemas(cwd, schemaSources, outputDir = path66.join(cwd, ".bunli", "mcp")) {
+async function syncMcpSchemas(cwd, schemaSources, outputDir = path70.join(cwd, ".bunli", "mcp")) {
   const groups = await loadMcpToolGroups(cwd, schemaSources);
   const result = await generateMCPTypes({
     outputDir,
@@ -295751,8 +296340,8 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path66.join(cwd, "
       throw convert.error;
     }
   }
-  await fs50.mkdir(outputDir, { recursive: true });
-  await fs50.writeFile(path66.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
+  await fs54.mkdir(outputDir, { recursive: true });
+  await fs54.writeFile(path70.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
 `, "utf8");
   return {
     commandCount: registry2.reduce((count, group) => count + group.tools.length, 0),
@@ -296071,4 +296660,4 @@ export {
   cli
 };
 
-//# debugId=7FC90D52A694344264756E2164756E21
+//# debugId=EB85DB51484D012864756E2164756E21