wp-typia 0.20.2 → 0.20.3

package/dist-bunli/{cli-add-dcr8ek9z.js → cli-add-43f9hqev.js}

@@ -1,5 +1,7 @@
 // @bun
 import {
+  OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY,
+  REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY,
   assertExternalLayerCompositionOptions,
   copyInterpolatedDirectory,
   getDefaultAnswers,
@@ -8,17 +10,22 @@ import {
   parseAlternateRenderTargets,
   parseCompoundInnerBlocksPreset,
   parseTemplateLocator,
+  renderScaffoldCompatibilityConfig,
   resolveExternalTemplateLayers,
   resolveLocalCliPathOption,
   resolveOptionalInteractiveExternalLayerId,
+  resolveScaffoldCompatibilityPolicy,
   resolveTemplateSeed,
   scaffoldProject,
-  syncPersistenceRestArtifacts
-} from "./cli-32rf304y.js";
-import"./cli-tesygdnr.js";
+  syncPersistenceRestArtifacts,
+  updatePluginHeaderCompatibility
+} from "./cli-8rnhjvb8.js";
+import {
+  getPackageVersions
+} from "./cli-tesygdnr.js";
 import {
   snapshotProjectVersion
-} from "./cli-qpt5dt0x.js";
+} from "./cli-2rev5hqm.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
@@ -38,6 +45,8 @@ import {
   ADD_KIND_IDS,
   EDITOR_PLUGIN_SLOT_IDS,
   appendWorkspaceInventoryEntries,
+  assertAbilityDoesNotExist,
+  assertAiFeatureDoesNotExist,
   assertBindingSourceDoesNotExist,
   assertEditorPluginDoesNotExist,
   assertPatternDoesNotExist,
@@ -67,14 +76,16 @@ import {
   snapshotWorkspaceFiles,
   toKebabCase,
   toTitleCase
-} from "./cli-rg481yks.js";
+} from "./cli-3w3qxq9w.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
 import {
   resolveWorkspaceProject
 } from "./cli-pd5pqgre.js";
-import"./cli-xnn9xjcy.js";
+import {
+  __reExport
+} from "./cli-xnn9xjcy.js";
 // ../wp-typia-project-tools/src/runtime/cli-add-block.ts
 import fs2 from "fs";
 import { promises as fsp2 } from "fs";
@@ -746,9 +757,9 @@ async function runAddBlockCommand({
   }
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
-import fs4 from "fs";
-import { promises as fsp5 } from "fs";
-import path8 from "path";
+import fs5 from "fs";
+import { promises as fsp8 } from "fs";
+import path12 from "path";
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
 import fs3 from "fs";
@@ -2799,139 +2810,2150 @@ async function runAddRestResourceCommand({
     throw error;
   }
 }
-
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
-var VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
-var VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
-function buildVariationConfigEntry(blockSlug, variationSlug) {
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+import fs4 from "fs";
+import { promises as fsp5 } from "fs";
+import path8 from "path";
+import { syncTypeSchemas as syncTypeSchemas2 } from "@wp-typia/block-runtime/metadata-core";
+var ABILITY_SERVER_GLOB = "/inc/abilities/*.php";
+var ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
+var ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
+var ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end";
+var ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start";
+var WP_ABILITIES_SCRIPT_HANDLE = "wp-abilities";
+var WP_CORE_ABILITIES_SCRIPT_HANDLE = "wp-core-abilities";
+function escapeRegex3(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function quotePhpString3(value) {
+  return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
+}
+function toPascalCaseFromAbilitySlug(abilitySlug) {
+  return normalizeBlockSlug(abilitySlug).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
+function toAbilityCategorySlug(workspaceNamespace) {
+  const normalizedNamespace = workspaceNamespace.replace(/[^a-z0-9-]+/gu, "-").replace(/-{2,}/gu, "-").replace(/^-|-$/gu, "");
+  return `${normalizedNamespace || "workspace"}-workflows`;
+}
+function buildAbilityConfigEntry(abilitySlug, compatibilityPolicy) {
+  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
   return [
     "\t{",
-    `		block: ${quoteTsString(blockSlug)},`,
-    `		file: ${quoteTsString(`src/blocks/${blockSlug}/variations/${variationSlug}.ts`)},`,
-    `		slug: ${quoteTsString(variationSlug)},`,
+    `		clientFile: ${quoteTsString(`src/abilities/${abilitySlug}/client.ts`)},`,
+    `		compatibility: ${renderScaffoldCompatibilityConfig(compatibilityPolicy)},`,
+    `		configFile: ${quoteTsString(`src/abilities/${abilitySlug}/ability.config.json`)},`,
+    `		dataFile: ${quoteTsString(`src/abilities/${abilitySlug}/data.ts`)},`,
+    `		inputSchemaFile: ${quoteTsString(`src/abilities/${abilitySlug}/input.schema.json`)},`,
+    `		inputTypeName: ${quoteTsString(`${pascalCase}AbilityInput`)},`,
+    `		outputSchemaFile: ${quoteTsString(`src/abilities/${abilitySlug}/output.schema.json`)},`,
+    `		outputTypeName: ${quoteTsString(`${pascalCase}AbilityOutput`)},`,
+    `		phpFile: ${quoteTsString(`inc/abilities/${abilitySlug}.php`)},`,
+    `		slug: ${quoteTsString(abilitySlug)},`,
+    `		typesFile: ${quoteTsString(`src/abilities/${abilitySlug}/types.ts`)},`,
     "\t},"
   ].join(`
 `);
 }
-function buildVariationConstName(variationSlug) {
-  const identifierSegments = toKebabCase(variationSlug).split("-").filter(Boolean);
-  return `workspaceVariation_${identifierSegments.join("_")}`;
-}
-function getVariationConstBindings(variationSlugs) {
-  const seenConstNames = new Map;
-  return variationSlugs.map((variationSlug) => {
-    const constName = buildVariationConstName(variationSlug);
-    const previousSlug = seenConstNames.get(constName);
-    if (previousSlug && previousSlug !== variationSlug) {
-      throw new Error(`Variation slugs "${previousSlug}" and "${variationSlug}" generate the same registry identifier "${constName}". Rename one of the variations.`);
+function buildAbilityConfigSource(abilitySlug, workspaceNamespace) {
+  const abilityTitle = toTitleCase(abilitySlug);
+  return `${JSON.stringify({
+    abilityId: `${workspaceNamespace}/${abilitySlug}`,
+    category: {
+      description: `Typed editor and admin workflows exposed by the ${workspaceNamespace} workspace.`,
+      label: `${toTitleCase(workspaceNamespace)} Workflows`,
+      slug: toAbilityCategorySlug(workspaceNamespace)
+    },
+    description: `Runs the ${abilityTitle} workflow using a typed server callback.`,
+    label: abilityTitle,
+    meta: {
+      annotations: {
+        destructive: false,
+        idempotent: true,
+        readonly: false
+      },
+      mcp: {
+        public: false
+      },
+      showInRest: true
     }
-    seenConstNames.set(constName, variationSlug);
-    return { constName, variationSlug };
-  });
+  }, null, 2)}
+`;
+}
+function buildAbilityTypesSource(abilitySlug) {
+  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+  return `export interface ${pascalCase}AbilityInput {
+	contextId: number;
+	note?: string;
 }
-function buildVariationSource(variationSlug, textDomain) {
-  const variationTitle = toTitleCase(variationSlug);
-  const variationConstName = buildVariationConstName(variationSlug);
-  return `import type { BlockVariation } from '@wp-typia/block-types/blocks/registration';
-import { __ } from '@wordpress/i18n';
 
-export const ${variationConstName} = {
-	name: ${quoteTsString(variationSlug)},
-	title: __( ${quoteTsString(variationTitle)}, ${quoteTsString(textDomain)} ),
-	description: __(
-		${quoteTsString(`A starter variation for ${variationTitle}.`)},
-		${quoteTsString(textDomain)},
-	),
-	attributes: {},
-	scope: ['inserter'],
-} satisfies BlockVariation;
+export interface ${pascalCase}AbilityOutput {
+	processedContextId: number;
+	receivedNote?: string;
+	status: 'ready';
+	summary: string;
+}
 `;
 }
-function buildVariationIndexSource(variationSlugs) {
-  const variationBindings = getVariationConstBindings(variationSlugs);
-  const importLines = variationBindings.map(({ constName, variationSlug }) => {
-    return `import { ${constName} } from './${variationSlug}';`;
-  }).join(`
-`);
-  const variationConstNames = variationBindings.map(({ constName }) => constName).join(`,
-		`);
-  return `import { registerBlockVariation } from '@wordpress/blocks';
-import metadata from '../block.json';
-${importLines ? `
-${importLines}` : ""}
+function buildAbilityDataSource(abilitySlug) {
+  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+  const abilityConstBase = abilitySlug.toUpperCase().replace(/[^A-Z0-9]+/gu, "_").replace(/_{2,}/gu, "_").replace(/^_|_$/gu, "");
+  return `import abilityConfig from './ability.config.json';
 
-const WORKSPACE_VARIATIONS = [
-	${variationConstNames}
-	// wp-typia add variation entries
-];
+import type { ${pascalCase}AbilityInput, ${pascalCase}AbilityOutput } from './types';
 
-export function registerWorkspaceVariations() {
-	for (const variation of WORKSPACE_VARIATIONS) {
-		registerBlockVariation(metadata.name, variation);
+interface WordPressAbilityDefinition {
+	category?: string;
+	description?: string;
+	label?: string;
+	meta?: Record<string, unknown>;
+	name?: string;
+}
+
+interface WordPressAbilitiesClient {
+	executeAbility( name: string, input?: unknown ): Promise< unknown >;
+	getAbilities( args?: { category?: string } ): WordPressAbilityDefinition[];
+	getAbility( name: string ): WordPressAbilityDefinition | undefined;
+}
+
+const ABILITY_CLIENT_UNAVAILABLE_MESSAGE =
+	'The WordPress abilities client is unavailable on this screen. Ensure the Abilities API and @wordpress/core-abilities integration are loaded before using this scaffold.';
+
+export const ${abilityConstBase}_ABILITY = abilityConfig;
+export const ${abilityConstBase}_ABILITY_CATEGORY = abilityConfig.category;
+export const ${abilityConstBase}_ABILITY_ID = abilityConfig.abilityId;
+export const ${abilityConstBase}_ABILITY_META = abilityConfig.meta;
+
+export type {
+	${pascalCase}AbilityInput,
+	${pascalCase}AbilityOutput,
+};
+
+function resolveAbilitiesClient(): WordPressAbilitiesClient {
+	const runtime = globalThis as typeof globalThis & {
+		window?: {
+			wp?: {
+				abilities?: WordPressAbilitiesClient;
+			};
+		};
+	};
+	const client = runtime.window?.wp?.abilities;
+	if ( ! client ) {
+		throw new Error( ABILITY_CLIENT_UNAVAILABLE_MESSAGE );
+	}
+
+	return client;
+}
+
+export function list${pascalCase}CategoryAbilities(): WordPressAbilityDefinition[] {
+	return resolveAbilitiesClient().getAbilities( {
+		category: ${abilityConstBase}_ABILITY_CATEGORY.slug,
+	} );
+}
+
+export function get${pascalCase}Ability():
+	| WordPressAbilityDefinition
+	| undefined {
+	return resolveAbilitiesClient().getAbility( ${abilityConstBase}_ABILITY_ID );
+}
+
+export function require${pascalCase}Ability(): WordPressAbilityDefinition {
+	const ability = get${pascalCase}Ability();
+	if ( ability ) {
+		return ability;
 	}
+
+	throw new Error(
+		[
+			\`Ability "\${ ${abilityConstBase}_ABILITY_ID }" is not available yet.\`,
+			'Load the WordPress core abilities integration on this screen and confirm the server-side registration succeeded.',
+		].join( ' ' )
+	);
+}
+
+export async function run${pascalCase}Ability(
+	input: ${pascalCase}AbilityInput
+): Promise< ${pascalCase}AbilityOutput > {
+	return ( await resolveAbilitiesClient().executeAbility(
+		${abilityConstBase}_ABILITY_ID,
+		input
+	) ) as ${pascalCase}AbilityOutput;
 }
 `;
 }
-async function ensureVariationRegistrationHook(blockIndexPath) {
-  await patchFile(blockIndexPath, (source) => {
-    let nextSource = source;
-    if (!nextSource.includes(VARIATIONS_IMPORT_LINE)) {
-      nextSource = `${VARIATIONS_IMPORT_LINE}
-${nextSource}`;
-    }
-    if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
-      const callInsertionPatterns = [
-        /(registerBlockType<[\s\S]*?\);\s*)/u,
-        /(registerBlockType\([\s\S]*?\);\s*)/u
-      ];
-      let inserted = false;
-      for (const pattern of callInsertionPatterns) {
-        const candidate = nextSource.replace(pattern, (match) => `${match}
-${VARIATIONS_CALL_LINE}
-`);
-        if (candidate !== nextSource) {
-          nextSource = candidate;
-          inserted = true;
-          break;
-        }
-      }
-      if (!inserted) {
-        nextSource = `${nextSource.trimEnd()}
+function buildAbilityClientSource(abilitySlug) {
+  const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+  return `/**
+ * Re-export the typed ${pascalCase} ability client helpers.
+ *
+ * The underlying WordPress abilities client is expected to have been hydrated
+ * by the site's admin/editor bootstrap before these helpers execute.
+ */
+export * from './data';
+`;
+}
+function buildAbilitySyncScriptSource() {
+  return `/* eslint-disable no-console */
+import { syncTypeSchemas } from '@wp-typia/block-runtime/metadata-core';
 
-${VARIATIONS_CALL_LINE}
+import {
+	ABILITIES,
+	type WorkspaceAbilityConfig,
+} from './block-config';
+
+function parseCliOptions( argv: string[] ) {
+	const options = {
+		check: false,
+	};
+
+	for ( const argument of argv ) {
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		throw new Error( \`Unknown sync-abilities flag: \${ argument }\` );
+	}
+
+	return options;
+}
+
+function isWorkspaceAbility(
+	ability: WorkspaceAbilityConfig
+): ability is WorkspaceAbilityConfig & {
+	clientFile: string;
+	configFile: string;
+	dataFile: string;
+	inputSchemaFile: string;
+	inputTypeName: string;
+	outputSchemaFile: string;
+	outputTypeName: string;
+	phpFile: string;
+	typesFile: string;
+} {
+	return (
+		typeof ability.clientFile === 'string' &&
+		typeof ability.configFile === 'string' &&
+		typeof ability.dataFile === 'string' &&
+		typeof ability.inputSchemaFile === 'string' &&
+		typeof ability.inputTypeName === 'string' &&
+		typeof ability.outputSchemaFile === 'string' &&
+		typeof ability.outputTypeName === 'string' &&
+		typeof ability.phpFile === 'string' &&
+		typeof ability.typesFile === 'string'
+	);
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+	const abilities = ABILITIES.filter( isWorkspaceAbility );
+
+	if ( ABILITIES.length > 0 && abilities.length === 0 ) {
+		console.warn(
+			'\u26A0\uFE0F Ability inventory entries exist, but none include the required typed schema files. Check scripts/block-config.ts before relying on sync-abilities.'
+		);
+	}
+
+	if ( abilities.length === 0 ) {
+		console.log(
+			options.check
+				? '\u2139\uFE0F No typed workflow abilities are registered yet. "sync-abilities --check" is already clean.'
+				: '\u2139\uFE0F No typed workflow abilities are registered yet.'
+		);
+		return;
+	}
+
+	for ( const ability of abilities ) {
+		await syncTypeSchemas(
+			{
+				jsonSchemaFile: ability.inputSchemaFile,
+				projectRoot: process.cwd(),
+				sourceTypeName: ability.inputTypeName,
+				typesFile: ability.typesFile,
+			},
+			{
+				check: options.check,
+			}
+		);
+
+		await syncTypeSchemas(
+			{
+				jsonSchemaFile: ability.outputSchemaFile,
+				projectRoot: process.cwd(),
+				sourceTypeName: ability.outputTypeName,
+				typesFile: ability.typesFile,
+			},
+			{
+				check: options.check,
+			}
+		);
+	}
+
+	console.log(
+		options.check
+			? '\u2705 Ability input and output schemas are already up to date for all registered workflow abilities!'
+			: '\u2705 Ability input and output schemas generated for all registered workflow abilities!'
+	);
+}
+
+main().catch( ( error ) => {
+	console.error( '\u274C Ability schema sync failed:', error );
+	process.exit( 1 );
+} );
 `;
-      }
-    }
-    if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
-      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path8.basename(blockIndexPath)}.`);
-    }
-    return nextSource;
-  });
 }
-async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
-  const variationsDir = path8.join(projectDir, "src", "blocks", blockSlug, "variations");
-  const variationsIndexPath = path8.join(variationsDir, "index.ts");
-  await fsp5.mkdir(variationsDir, { recursive: true });
-  const existingVariationSlugs = fs4.readdirSync(variationsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
-  const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
-  await fsp5.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
+function buildAbilityPhpSource(abilitySlug, workspace) {
+  const abilityTitle = toTitleCase(abilitySlug);
+  const abilityPhpId = abilitySlug.replace(/-/g, "_");
+  const categoryRegisterFunctionName = `${workspace.workspace.phpPrefix}_${abilityPhpId}_register_ability_category`;
+  const abilityRegisterFunctionName = `${workspace.workspace.phpPrefix}_${abilityPhpId}_register_ability`;
+  const configLoaderFunctionName = `${workspace.workspace.phpPrefix}_${abilityPhpId}_load_ability_config`;
+  const schemaLoaderFunctionName = `${workspace.workspace.phpPrefix}_${abilityPhpId}_load_ability_schema`;
+  const permissionFunctionName = `${workspace.workspace.phpPrefix}_${abilityPhpId}_can_execute_ability`;
+  const executeFunctionName = `${workspace.workspace.phpPrefix}_${abilityPhpId}_execute_ability`;
+  const metaFactoryFunctionName = `${workspace.workspace.phpPrefix}_${abilityPhpId}_build_ability_meta`;
+  return `<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	return;
 }
-async function runAddVariationCommand({
-  blockName,
-  cwd = process.cwd(),
-  variationName
-}) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const blockSlug = normalizeBlockSlug(blockName);
-  const variationSlug = assertValidGeneratedSlug("Variation name", normalizeBlockSlug(variationName), "wp-typia add variation <name> --block <block-slug>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  resolveWorkspaceBlock(inventory, blockSlug);
-  assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
-  const blockConfigPath = path8.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path8.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const variationsDir = path8.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
-  const variationFilePath = path8.join(variationsDir, `${variationSlug}.ts`);
-  const variationsIndexPath = path8.join(variationsDir, "index.ts");
+
+if ( ! function_exists( '${configLoaderFunctionName}' ) ) {
+	function ${configLoaderFunctionName}() {
+		$project_root = dirname( __DIR__, 2 );
+		$config_path  = $project_root . '/src/abilities/${abilitySlug}/ability.config.json';
+		if ( ! file_exists( $config_path ) ) {
+			return null;
+		}
+
+		$decoded = json_decode( file_get_contents( $config_path ), true );
+		return is_array( $decoded ) ? $decoded : null;
+	}
+}
+
+if ( ! function_exists( '${schemaLoaderFunctionName}' ) ) {
+	function ${schemaLoaderFunctionName}( $schema_name ) {
+		$project_root = dirname( __DIR__, 2 );
+		$schema_path  = $project_root . '/src/abilities/${abilitySlug}/' . $schema_name;
+		if ( ! file_exists( $schema_path ) ) {
+			return null;
+		}
+
+		$decoded = json_decode( file_get_contents( $schema_path ), true );
+		return is_array( $decoded ) ? $decoded : null;
+	}
+}
+
+if ( ! function_exists( '${metaFactoryFunctionName}' ) ) {
+	function ${metaFactoryFunctionName}( array $config ) {
+		$meta = array(
+			'annotations' => isset( $config['meta']['annotations'] ) && is_array( $config['meta']['annotations'] )
+				? $config['meta']['annotations']
+				: array(
+					'destructive' => false,
+					'idempotent'  => true,
+					'readonly'    => false,
+				),
+			'show_in_rest' => ! empty( $config['meta']['showInRest'] ),
+		);
+
+		if ( ! empty( $config['meta']['mcp']['public'] ) ) {
+			$meta['mcp'] = array(
+				'public' => true,
+			);
+		}
+
+		return $meta;
+	}
+}
+
+if ( ! function_exists( '${permissionFunctionName}' ) ) {
+	function ${permissionFunctionName}( $input = array() ) {
+		unset( $input );
+
+		return current_user_can( 'edit_posts' );
+	}
+}
+
+if ( ! function_exists( '${executeFunctionName}' ) ) {
+	function ${executeFunctionName}( $input = array() ) {
+		$payload = is_array( $input ) ? $input : array();
+		$context_id = isset( $payload['contextId'] ) ? (int) $payload['contextId'] : 0;
+		$note = isset( $payload['note'] ) && is_string( $payload['note'] )
+			? trim( $payload['note'] )
+			: '';
+		$result = array(
+			'processedContextId' => $context_id,
+			'status'             => 'ready',
+			'summary'            => sprintf(
+				/* translators: 1: workflow title, 2: context id */
+				__( '%1$s processed context %2$d.', ${quotePhpString3(workspace.workspace.textDomain)} ),
+				${quotePhpString3(abilityTitle)},
+				$context_id
+			),
+		);
+
+		if ( '' !== $note ) {
+			$result['receivedNote'] = $note;
+		}
+
+		return $result;
+	}
+}
+
+if ( ! function_exists( '${categoryRegisterFunctionName}' ) ) {
+	function ${categoryRegisterFunctionName}() {
+		if ( ! function_exists( 'wp_register_ability_category' ) ) {
+			return;
+		}
+
+		$config = ${configLoaderFunctionName}();
+		if (
+			! is_array( $config ) ||
+			empty( $config['category']['slug'] ) ||
+			empty( $config['category']['label'] )
+		) {
+			return;
+		}
+
+		wp_register_ability_category(
+			(string) $config['category']['slug'],
+			array(
+				'description' => isset( $config['category']['description'] ) && is_string( $config['category']['description'] )
+					? $config['category']['description']
+					: '',
+				'label'       => (string) $config['category']['label'],
+			)
+		);
+	}
+}
+
+if ( ! function_exists( '${abilityRegisterFunctionName}' ) ) {
+	function ${abilityRegisterFunctionName}() {
+		if ( ! function_exists( 'wp_register_ability' ) ) {
+			return;
+		}
+
+		$config = ${configLoaderFunctionName}();
+		if (
+			! is_array( $config ) ||
+			empty( $config['abilityId'] ) ||
+			empty( $config['category']['slug'] ) ||
+			empty( $config['label'] ) ||
+			empty( $config['description'] )
+		) {
+			return;
+		}
+
+		$input_schema  = ${schemaLoaderFunctionName}( 'input.schema.json' );
+		$output_schema = ${schemaLoaderFunctionName}( 'output.schema.json' );
+		if ( ! is_array( $output_schema ) ) {
+			return;
+		}
+
+		$args = array(
+			'category'            => (string) $config['category']['slug'],
+			'description'         => (string) $config['description'],
+			'execute_callback'    => ${quotePhpString3(executeFunctionName)},
+			'label'               => (string) $config['label'],
+			'meta'                => ${metaFactoryFunctionName}( $config ),
+			'output_schema'       => $output_schema,
+			'permission_callback' => ${quotePhpString3(permissionFunctionName)},
+		);
+
+		if ( is_array( $input_schema ) ) {
+			$args['input_schema'] = $input_schema;
+		}
+
+		wp_register_ability(
+			(string) $config['abilityId'],
+			$args
+		);
+	}
+}
+
+add_action( 'wp_abilities_api_categories_init', '${categoryRegisterFunctionName}' );
+add_action( 'wp_abilities_api_init', '${abilityRegisterFunctionName}' );
+`;
+}
+function buildAbilityRegistrySource(abilitySlugs) {
+  const exportLines = abilitySlugs.map((abilitySlug) => `export * from './${abilitySlug}/client';`).join(`
+`);
+  return [
+    ABILITY_REGISTRY_START_MARKER,
+    exportLines,
+    ABILITY_REGISTRY_END_MARKER
+  ].filter((line) => line.length > 0).join(`
+`).concat(`
+`);
+}
+function resolveAbilityRegistryPath(projectDir) {
+  const abilitiesDir = path8.join(projectDir, "src", "abilities");
+  return [path8.join(abilitiesDir, "index.ts"), path8.join(abilitiesDir, "index.js")].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path8.join(abilitiesDir, "index.ts");
+}
+function readAbilityRegistrySlugs(registryPath) {
+  if (!fs4.existsSync(registryPath)) {
+    return [];
+  }
+  const source = fs4.readFileSync(registryPath, "utf8");
+  return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match) => match[1]);
+}
+async function writeAbilityRegistry(projectDir, abilitySlug) {
+  const abilitiesDir = path8.join(projectDir, "src", "abilities");
+  const registryPath = resolveAbilityRegistryPath(projectDir);
+  await fsp5.mkdir(abilitiesDir, { recursive: true });
+  const existingAbilitySlugs = readWorkspaceInventory(projectDir).abilities.map((entry) => entry.slug);
+  const existingRegistrySlugs = readAbilityRegistrySlugs(registryPath);
+  const nextAbilitySlugs = Array.from(new Set([...existingAbilitySlugs, ...existingRegistrySlugs, abilitySlug])).sort();
+  const generatedSection = buildAbilityRegistrySource(nextAbilitySlugs);
+  const existingSource = fs4.existsSync(registryPath) ? fs4.readFileSync(registryPath, "utf8") : "";
+  const generatedSectionPattern = new RegExp(`${escapeRegex3(ABILITY_REGISTRY_START_MARKER)}[\\s\\S]*?${escapeRegex3(ABILITY_REGISTRY_END_MARKER)}\\n?`, "u");
+  const nextSource = existingSource ? generatedSectionPattern.test(existingSource) ? existingSource.replace(generatedSectionPattern, generatedSection) : `${existingSource.trimEnd()}
+
+${generatedSection}` : generatedSection;
+  await fsp5.writeFile(registryPath, nextSource, "utf8");
+}
+async function ensureAbilityBootstrapAnchors(workspace) {
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  await patchFile(bootstrapPath, (source) => {
+    let nextSource = source;
+    const workspaceBaseName = workspace.packageName.split("/").pop() ?? workspace.packageName;
+    const loadFunctionName = `${workspace.workspace.phpPrefix}_load_workflow_abilities`;
+    const enqueueFunctionName = `${workspace.workspace.phpPrefix}_enqueue_workflow_abilities`;
+    const loadHook = `add_action( 'plugins_loaded', '${loadFunctionName}' );`;
+    const adminEnqueueHook = `add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );`;
+    const editorEnqueueHook = `add_action( 'enqueue_block_editor_assets', '${enqueueFunctionName}' );`;
+    const loadFunction = `
+
+function ${loadFunctionName}() {
+	foreach ( glob( __DIR__ . '${ABILITY_SERVER_GLOB}' ) ?: array() as $ability_module ) {
+		require_once $ability_module;
+	}
+}
+`;
+    const enqueueFunction = `
+
+function ${enqueueFunctionName}() {
+	if ( ! class_exists( 'WP_Ability' ) ) {
+		return;
+	}
+
+	$script_path = __DIR__ . '/${ABILITY_EDITOR_SCRIPT}';
+	$asset_path  = __DIR__ . '/${ABILITY_EDITOR_ASSET}';
+
+	if ( ! file_exists( $script_path ) || ! file_exists( $asset_path ) ) {
+		return;
+	}
+
+	$asset = require $asset_path;
+	if ( ! is_array( $asset ) ) {
+		$asset = array();
+	}
+
+	$dependencies = isset( $asset['dependencies'] ) && is_array( $asset['dependencies'] )
+		? $asset['dependencies']
+		: array();
+
+	foreach ( array( '${WP_CORE_ABILITIES_SCRIPT_HANDLE}', '${WP_ABILITIES_SCRIPT_HANDLE}' ) as $ability_dependency ) {
+		if (
+			function_exists( 'wp_script_is' ) &&
+			wp_script_is( $ability_dependency, 'registered' ) &&
+			! in_array( $ability_dependency, $dependencies, true )
+		) {
+			$dependencies[] = $ability_dependency;
+		}
+	}
+
+	wp_enqueue_script(
+		'${workspaceBaseName}-abilities',
+		plugins_url( '${ABILITY_EDITOR_SCRIPT}', __FILE__ ),
+		$dependencies,
+		isset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
+		true
+	);
+}
+`;
+    const insertionAnchors = [
+      /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
+      /\?>\s*$/u
+    ];
+    const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex3(functionName)}\\s*\\(`, "u").test(nextSource);
+    const insertPhpSnippet = (snippet) => {
+      for (const anchor of insertionAnchors) {
+        const candidate = nextSource.replace(anchor, (match) => `${snippet}
+${match}`);
+        if (candidate !== nextSource) {
+          nextSource = candidate;
+          return;
+        }
+      }
+      nextSource = `${nextSource.trimEnd()}
+${snippet}
+`;
+    };
+    const appendPhpSnippet = (snippet) => {
+      const closingTagPattern = /\?>\s*$/u;
+      if (closingTagPattern.test(nextSource)) {
+        nextSource = nextSource.replace(closingTagPattern, `${snippet}
+?>`);
+        return;
+      }
+      nextSource = `${nextSource.trimEnd()}
+${snippet}
+`;
+    };
+    if (!hasPhpFunctionDefinition(loadFunctionName)) {
+      insertPhpSnippet(loadFunction);
+    }
+    if (!hasPhpFunctionDefinition(enqueueFunctionName)) {
+      insertPhpSnippet(enqueueFunction);
+    }
+    if (!nextSource.includes(loadHook)) {
+      appendPhpSnippet(loadHook);
+    }
+    if (!nextSource.includes(adminEnqueueHook)) {
+      appendPhpSnippet(adminEnqueueHook);
+    }
+    if (!nextSource.includes(editorEnqueueHook)) {
+      appendPhpSnippet(editorEnqueueHook);
+    }
+    return nextSource;
+  });
+}
+async function ensureAbilityPackageScripts(workspace) {
+  const packageJsonPath = path8.join(workspace.projectDir, "package.json");
+  const packageJson = JSON.parse(await fsp5.readFile(packageJsonPath, "utf8"));
+  const nextScripts = {
+    ...packageJson.scripts ?? {},
+    "sync-abilities": packageJson.scripts?.["sync-abilities"] ?? "tsx scripts/sync-abilities.ts"
+  };
+  if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {})) {
+    return;
+  }
+  packageJson.scripts = nextScripts;
+  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+`, "utf8");
+}
+async function ensureAbilitySyncProjectAnchors(workspace) {
+  const syncProjectScriptPath = path8.join(workspace.projectDir, "scripts", "sync-project.ts");
+  await patchFile(syncProjectScriptPath, (source) => {
+    let nextSource = source;
+    const syncRestConst = "const syncRestScriptPath = path.join( 'scripts', 'sync-rest-contracts.ts' );";
+    const syncAbilitiesConst = "const syncAbilitiesScriptPath = path.join( 'scripts', 'sync-abilities.ts' );";
+    const syncRestBlockPattern = /if \( fs\.existsSync\( path\.resolve\( process\.cwd\(\), syncRestScriptPath \) \) \) \{\n\s*runSyncScript\( syncRestScriptPath, options \);\n\s*\}/u;
+    const syncAbilitiesBlock = [
+      "if ( fs.existsSync( path.resolve( process.cwd(), syncAbilitiesScriptPath ) ) ) {",
+      "\trunSyncScript( syncAbilitiesScriptPath, options );",
+      "}"
+    ].join(`
+`);
+    if (!nextSource.includes(syncAbilitiesConst)) {
+      if (!nextSource.includes(syncRestConst)) {
+        throw new Error([
+          `ensureAbilitySyncProjectAnchors could not patch ${path8.basename(syncProjectScriptPath)}.`,
+          "Missing the expected sync-rest script constant in scripts/sync-project.ts.",
+          "Restore the generated template or wire sync-abilities manually before retrying."
+        ].join(" "));
+      }
+      nextSource = nextSource.replace(syncRestConst, `${syncRestConst}
+${syncAbilitiesConst}`);
+    }
+    if (!nextSource.includes("runSyncScript( syncAbilitiesScriptPath, options );")) {
+      if (!syncRestBlockPattern.test(nextSource)) {
+        throw new Error([
+          `ensureAbilitySyncProjectAnchors could not patch ${path8.basename(syncProjectScriptPath)}.`,
+          "Missing the expected sync-rest invocation block in scripts/sync-project.ts.",
+          "Restore the generated template or wire sync-abilities manually before retrying."
+        ].join(" "));
+      }
+      nextSource = nextSource.replace(syncRestBlockPattern, (match) => `${match}
+
+${syncAbilitiesBlock}`);
+    }
+    return nextSource;
+  });
+}
+async function ensureAbilityBuildScriptAnchors(workspace) {
+  const buildScriptPath = path8.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  await patchFile(buildScriptPath, (source) => {
+    let nextSource = source;
+    if (/['"]src\/abilities\/index\.(?:ts|js)['"]/u.test(nextSource)) {
+      return nextSource;
+    }
+    const sharedEntriesPattern = /(for\s*\(\s*const\s+relativePath\s+of\s+\[)([\s\S]*?)(\]\s*\)\s*\{)/u;
+    const match = nextSource.match(sharedEntriesPattern);
+    if (!match || !match[2].includes("src/bindings/index.ts") || !match[2].includes("src/editor-plugins/index.ts")) {
+      throw new Error([
+        `ensureAbilityBuildScriptAnchors could not patch ${path8.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`);
+    return nextSource;
+  });
+}
+async function ensureAbilityWebpackAnchors(workspace) {
+  const webpackConfigPath = path8.join(workspace.projectDir, "webpack.config.js");
+  await patchFile(webpackConfigPath, (source) => {
+    if (/['"]abilities\/index['"]/u.test(source)) {
+      return source;
+    }
+    const sharedEntriesPattern = /for\s*\(\s*const\s+\[\s*entryName\s*,\s*candidates\s*\]\s+of\s+\[([\s\S]*?)\]\s*\)\s*\{/u;
+    const match = source.match(sharedEntriesPattern);
+    if (!match || !match[1].includes("bindings/index") || !match[1].includes("editor-plugins/index")) {
+      throw new Error([
+        `ensureAbilityWebpackAnchors could not patch ${path8.basename(webpackConfigPath)}.`,
+        "Missing the expected shared editor entries block in webpack.config.js.",
+        "Restore the generated template or wire abilities/index manually before retrying."
+      ].join(" "));
+    }
+    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' ],
+		],
+	] ) {`);
+  });
+}
+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);
+  const blockConfigPath = path8.join(workspace.projectDir, "scripts", "block-config.ts");
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  const buildScriptPath = path8.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path8.join(workspace.projectDir, "package.json");
+  const syncAbilitiesScriptPath = path8.join(workspace.projectDir, "scripts", "sync-abilities.ts");
+  const syncProjectScriptPath = path8.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const webpackConfigPath = path8.join(workspace.projectDir, "webpack.config.js");
+  const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
+  const abilityDir = path8.join(workspace.projectDir, "src", "abilities", abilitySlug);
+  const configFilePath = path8.join(abilityDir, "ability.config.json");
+  const typesFilePath = path8.join(abilityDir, "types.ts");
+  const dataFilePath = path8.join(abilityDir, "data.ts");
+  const clientFilePath = path8.join(abilityDir, "client.ts");
+  const phpFilePath = path8.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles([
+      blockConfigPath,
+      bootstrapPath,
+      buildScriptPath,
+      packageJsonPath,
+      syncAbilitiesScriptPath,
+      syncProjectScriptPath,
+      webpackConfigPath,
+      abilitiesIndexPath
+    ]),
+    snapshotDirs: [],
+    targetPaths: [abilityDir, phpFilePath, syncAbilitiesScriptPath]
+  };
+  try {
+    await fsp5.mkdir(abilityDir, { recursive: true });
+    await fsp5.mkdir(path8.dirname(phpFilePath), { recursive: true });
+    await ensureAbilityBootstrapAnchors(workspace);
+    await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
+    await ensureAbilityPackageScripts(workspace);
+    await ensureAbilitySyncProjectAnchors(workspace);
+    await ensureAbilityBuildScriptAnchors(workspace);
+    await ensureAbilityWebpackAnchors(workspace);
+    await fsp5.writeFile(syncAbilitiesScriptPath, buildAbilitySyncScriptSource(), "utf8");
+    await fsp5.writeFile(configFilePath, buildAbilityConfigSource(abilitySlug, workspace.workspace.namespace), "utf8");
+    await fsp5.writeFile(typesFilePath, buildAbilityTypesSource(abilitySlug), "utf8");
+    await fsp5.writeFile(dataFilePath, buildAbilityDataSource(abilitySlug), "utf8");
+    await fsp5.writeFile(clientFilePath, buildAbilityClientSource(abilitySlug), "utf8");
+    await fsp5.writeFile(phpFilePath, buildAbilityPhpSource(abilitySlug, workspace), "utf8");
+    const pascalCase = toPascalCaseFromAbilitySlug(abilitySlug);
+    await syncTypeSchemas2({
+      jsonSchemaFile: `src/abilities/${abilitySlug}/input.schema.json`,
+      projectRoot: workspace.projectDir,
+      sourceTypeName: `${pascalCase}AbilityInput`,
+      typesFile: `src/abilities/${abilitySlug}/types.ts`
+    });
+    await syncTypeSchemas2({
+      jsonSchemaFile: `src/abilities/${abilitySlug}/output.schema.json`,
+      projectRoot: workspace.projectDir,
+      sourceTypeName: `${pascalCase}AbilityOutput`,
+      typesFile: `src/abilities/${abilitySlug}/types.ts`
+    });
+    await writeAbilityRegistry(workspace.projectDir, abilitySlug);
+    await appendWorkspaceInventoryEntries(workspace.projectDir, {
+      abilityEntries: [buildAbilityConfigEntry(abilitySlug, compatibilityPolicy)]
+    });
+    return {
+      abilitySlug,
+      projectDir: workspace.projectDir
+    };
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw error;
+  }
+}
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+import { promises as fsp7 } from "fs";
+import path11 from "path";
+
+// ../wp-typia-project-tools/src/runtime/ai-feature-artifacts.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path9 from "path";
+import {
+  defineEndpointManifest as defineEndpointManifest2,
+  syncEndpointClient as syncEndpointClient2,
+  syncRestOpenApi as syncRestOpenApi2,
+  syncTypeSchemas as syncTypeSchemas3
+} from "@wp-typia/block-runtime/metadata-core";
+
+// ../wp-typia-project-tools/src/runtime/schema-core.ts
+var exports_schema_core = {};
+__reExport(exports_schema_core, schema_core);
+import"@wp-typia/block-runtime/schema-core";
+
+// ../wp-typia-project-tools/src/runtime/wordpress-ai.ts
+function projectWordPressAiSchema(schema) {
+  return exports_schema_core.projectJsonSchemaDocument(schema, {
+    profile: "ai-structured-output"
+  });
+}
+// ../wp-typia-project-tools/src/runtime/ai-feature-artifacts.ts
+function normalizeGeneratedArtifactContent(content) {
+  return content.replace(/\r\n?/g, `
+`);
+}
+async function reconcileGeneratedArtifact(options) {
+  if (!options.check) {
+    await mkdir(path9.dirname(options.filePath), {
+      recursive: true
+    });
+    await writeFile(options.filePath, options.content, "utf8");
+    return;
+  }
+  try {
+    const current = normalizeGeneratedArtifactContent(await readFile(options.filePath, "utf8"));
+    const expected = normalizeGeneratedArtifactContent(options.content);
+    if (current !== expected) {
+      throw new Error(`Generated AI feature artifact is stale: ${options.label} (${options.filePath}).`);
+    }
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : undefined;
+    if (code === "ENOENT") {
+      throw new Error(`Generated AI feature artifact is missing: ${options.label} (${options.filePath}).`);
+    }
+    throw error;
+  }
+}
+function assertJsonObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`Expected ${label} to decode to a JSON object.`);
+  }
+  return value;
+}
+function buildAiFeatureEndpointManifest(variables) {
+  return defineEndpointManifest2({
+    contracts: {
+      "feature-request": {
+        sourceTypeName: `${variables.pascalCase}AiFeatureRequest`
+      },
+      "feature-response": {
+        sourceTypeName: `${variables.pascalCase}AiFeatureResponse`
+      },
+      "feature-result": {
+        sourceTypeName: `${variables.pascalCase}AiFeatureResult`
+      }
+    },
+    endpoints: [
+      {
+        auth: "authenticated",
+        bodyContract: "feature-request",
+        method: "POST",
+        operationId: `run${variables.pascalCase}AiFeature`,
+        path: `/${variables.namespace}/ai/${variables.slugKebabCase}`,
+        responseContract: "feature-response",
+        summary: `Run the ${variables.title} AI feature endpoint.`,
+        tags: [`${variables.title} AI`],
+        wordpressAuth: {
+          mechanism: "rest-nonce"
+        }
+      }
+    ],
+    info: {
+      title: `${variables.title} AI Feature API`,
+      version: "1.0.0"
+    }
+  });
+}
+async function syncAiFeatureRestArtifacts({
+  clientFile,
+  executionOptions,
+  outputDir,
+  projectDir,
+  typesFile,
+  validatorsFile,
+  variables
+}) {
+  const manifest = buildAiFeatureEndpointManifest(variables);
+  for (const [baseName, contract] of Object.entries(manifest.contracts)) {
+    await syncTypeSchemas3({
+      jsonSchemaFile: path9.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path9.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      projectRoot: projectDir,
+      sourceTypeName: contract.sourceTypeName,
+      typesFile
+    }, executionOptions);
+  }
+  await syncRestOpenApi2({
+    manifest,
+    openApiFile: path9.join(outputDir, "api.openapi.json"),
+    projectRoot: projectDir,
+    typesFile
+  }, executionOptions);
+  await syncEndpointClient2({
+    clientFile,
+    manifest,
+    projectRoot: projectDir,
+    typesFile,
+    validatorsFile
+  }, executionOptions);
+}
+async function syncAiFeatureSchemaArtifact({
+  aiSchemaFile,
+  check = false,
+  outputDir,
+  projectDir
+}) {
+  const sourceSchemaPath = path9.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
+  const responseSchema = assertJsonObject(JSON.parse(await readFile(sourceSchemaPath, "utf8")), sourceSchemaPath);
+  const aiSchema = projectWordPressAiSchema(responseSchema);
+  await reconcileGeneratedArtifact({
+    check,
+    content: `${JSON.stringify(aiSchema, null, 2)}
+`,
+    filePath: path9.join(projectDir, aiSchemaFile),
+    label: "AI feature schema"
+  });
+  return {
+    aiSchema,
+    aiSchemaPath: path9.join(projectDir, aiSchemaFile),
+    check,
+    sourceSchemaPath
+  };
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-source-emitters.ts
+function toPascalCaseFromAiFeatureSlug(slug) {
+  return normalizeBlockSlug(slug).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
+function indentMultiline2(source, prefix) {
+  return source.split(`
+`).map((line) => `${prefix}${line}`).join(`
+`);
+}
+function buildAiFeatureConfigEntry(aiFeatureSlug, namespace) {
+  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  const title = toTitleCase(aiFeatureSlug);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
+  const manifest = buildAiFeatureEndpointManifest({
+    namespace,
+    pascalCase,
+    slugKebabCase: aiFeatureSlug,
+    title
+  });
+  return [
+    "\t{",
+    `		aiSchemaFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`)},`,
+    `		apiFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api.ts`)},`,
+    `		clientFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api-client.ts`)},`,
+    `		compatibility: ${renderScaffoldCompatibilityConfig(compatibilityPolicy)},`,
+    `		dataFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/data.ts`)},`,
+    `		namespace: ${quoteTsString(namespace)},`,
+    `		openApiFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api.openapi.json`)},`,
+    `		phpFile: ${quoteTsString(`inc/ai-features/${aiFeatureSlug}.php`)},`,
+    "\t\trestManifest: defineEndpointManifest(",
+    indentMultiline2(JSON.stringify(manifest, null, "\t"), "\t\t\t"),
+    "\t\t),",
+    `		slug: ${quoteTsString(aiFeatureSlug)},`,
+    `		typesFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api-types.ts`)},`,
+    `		validatorsFile: ${quoteTsString(`src/ai-features/${aiFeatureSlug}/api-validators.ts`)},`,
+    "\t},"
+  ].join(`
+`);
+}
+function buildAiFeatureTypesSource(aiFeatureSlug) {
+  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  return `import { tags } from 'typia';
+
+export interface ${pascalCase}AiFeatureRequest {
+	brief: string & tags.MinLength< 1 > & tags.MaxLength< 4000 >;
+	context?: string & tags.MaxLength< 4000 >;
+}
+
+export interface ${pascalCase}AiFeatureResult {
+	title: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	summary: string & tags.MinLength< 1 > & tags.MaxLength< 2000 >;
+	confidence?: number & tags.Minimum< 0 > & tags.Maximum< 1 >;
+}
+
+export interface ${pascalCase}AiFeatureTokenUsage {
+	completionTokens: number & tags.Type< 'uint32' >;
+	promptTokens: number & tags.Type< 'uint32' >;
+	totalTokens: number & tags.Type< 'uint32' >;
+	thoughtTokens?: number & tags.Type< 'uint32' >;
+}
+
+export interface ${pascalCase}AiFeatureTelemetry {
+	modelId: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	modelName: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	providerId: string & tags.MinLength< 1 > & tags.MaxLength< 80 >;
+	providerName: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	providerType: 'client' | 'cloud' | 'server';
+	resultId: string & tags.MinLength< 1 > & tags.MaxLength< 160 >;
+	tokenUsage: ${pascalCase}AiFeatureTokenUsage;
+}
+
+export interface ${pascalCase}AiFeatureResponse {
+	result: ${pascalCase}AiFeatureResult;
+	telemetry: ${pascalCase}AiFeatureTelemetry;
+}
+`;
+}
+function buildAiFeatureValidatorsSource(aiFeatureSlug) {
+  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  return `import typia from 'typia';
+
+import { toValidationResult } from '@wp-typia/rest';
+import type {
+	${pascalCase}AiFeatureRequest,
+	${pascalCase}AiFeatureResponse,
+	${pascalCase}AiFeatureResult,
+} from './api-types';
+
+const validateFeatureRequest = typia.createValidate< ${pascalCase}AiFeatureRequest >();
+const validateFeatureResult = typia.createValidate< ${pascalCase}AiFeatureResult >();
+const validateFeatureResponse = typia.createValidate< ${pascalCase}AiFeatureResponse >();
+
+export const apiValidators = {
+	featureRequest: ( input: unknown ) =>
+		toValidationResult< ${pascalCase}AiFeatureRequest >(
+			validateFeatureRequest( input )
+		),
+	featureResult: ( input: unknown ) =>
+		toValidationResult< ${pascalCase}AiFeatureResult >(
+			validateFeatureResult( input )
+		),
+	featureResponse: ( input: unknown ) =>
+		toValidationResult< ${pascalCase}AiFeatureResponse >(
+			validateFeatureResponse( input )
+		),
+};
+`;
+}
+function buildAiFeatureApiSource(aiFeatureSlug) {
+  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  return `import {
+	callEndpoint,
+	resolveRestRouteUrl,
+} from '@wp-typia/rest';
+
+import type {
+	${pascalCase}AiFeatureRequest,
+} from './api-types';
+import {
+	run${pascalCase}AiFeatureEndpoint,
+} from './api-client';
+
+function resolveRestNonce( fallback?: string ): string | undefined {
+	if ( typeof fallback === 'string' && fallback.length > 0 ) {
+		return fallback;
+	}
+
+	if ( typeof window === 'undefined' ) {
+		return undefined;
+	}
+
+	const wpApiSettings = (
+		window as typeof window & {
+			wpApiSettings?: { nonce?: string };
+		}
+	).wpApiSettings;
+
+	return typeof wpApiSettings?.nonce === 'string' &&
+		wpApiSettings.nonce.length > 0
+		? wpApiSettings.nonce
+		: undefined;
+}
+
+export const aiFeatureRunEndpoint = {
+	...run${pascalCase}AiFeatureEndpoint,
+	buildRequestOptions: () => {
+		const nonce = resolveRestNonce();
+		return {
+			headers: nonce
+				? {
+					'X-WP-Nonce': nonce,
+				}
+				: undefined,
+			url: resolveRestRouteUrl( run${pascalCase}AiFeatureEndpoint.path ),
+		};
+	},
+};
+
+export function runAiFeature( request: ${pascalCase}AiFeatureRequest ) {
+	return callEndpoint( aiFeatureRunEndpoint, request );
+}
+`;
+}
+function buildAiFeatureDataSource(aiFeatureSlug) {
+  const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+  return `import {
+	useEndpointMutation,
+	type UseEndpointMutationOptions,
+} from '@wp-typia/rest/react';
+
+import type {
+	${pascalCase}AiFeatureRequest,
+	${pascalCase}AiFeatureResponse,
+} from './api-types';
+import {
+	aiFeatureRunEndpoint,
+} from './api';
+
+export type UseRun${pascalCase}AiFeatureMutationOptions =
+	UseEndpointMutationOptions<
+		${pascalCase}AiFeatureRequest,
+		${pascalCase}AiFeatureResponse,
+		unknown
+	>;
+
+export function useRun${pascalCase}AiFeatureMutation(
+	options: UseRun${pascalCase}AiFeatureMutationOptions = {}
+) {
+	return useEndpointMutation( aiFeatureRunEndpoint, options );
+}
+`;
+}
+function buildAiFeatureSyncScriptSource() {
+  return `/* eslint-disable no-console */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { projectWordPressAiSchema } from '@wp-typia/project-tools/ai-artifacts';
+
+import {
+	AI_FEATURES,
+	type WorkspaceAiFeatureConfig,
+} from './block-config';
+
+function parseCliOptions( argv: string[] ) {
+	const options = {
+		check: false,
+	};
+
+	for ( const argument of argv ) {
+		if ( argument === '--check' ) {
+			options.check = true;
+			continue;
+		}
+
+		throw new Error( \`Unknown sync-ai flag: \${ argument }\` );
+	}
+
+	return options;
+}
+
+function isWorkspaceAiFeature(
+	feature: WorkspaceAiFeatureConfig
+): feature is WorkspaceAiFeatureConfig & {
+	aiSchemaFile: string;
+	typesFile: string;
+} {
+	return (
+		typeof feature.aiSchemaFile === 'string' &&
+		typeof feature.typesFile === 'string'
+	);
+}
+
+function normalizeGeneratedArtifactContent( content: string ) {
+	return content.replace( /\\r\\n?/g, '\\n' );
+}
+
+async function reconcileGeneratedArtifact( options: {
+	check: boolean;
+	content: string;
+	filePath: string;
+	label: string;
+} ) {
+	if ( ! options.check ) {
+		await mkdir( path.dirname( options.filePath ), {
+			recursive: true,
+		} );
+		await writeFile( options.filePath, options.content, 'utf8' );
+		return;
+	}
+
+	const current = normalizeGeneratedArtifactContent(
+		await readFile( options.filePath, 'utf8' )
+	);
+	const expected = normalizeGeneratedArtifactContent( options.content );
+	if ( current !== expected ) {
+		throw new Error(
+			\`Generated AI feature artifact is stale: \${ options.label } (\${ options.filePath }).\`
+		);
+	}
+}
+
+async function loadJsonDocument( filePath: string ) {
+	const decoded = JSON.parse( await readFile( filePath, 'utf8' ) ) as unknown;
+	if ( ! decoded || typeof decoded !== 'object' || Array.isArray( decoded ) ) {
+		throw new Error( \`Expected \${ filePath } to decode to a JSON object.\` );
+	}
+
+	return decoded as Parameters< typeof projectWordPressAiSchema >[ 0 ];
+}
+
+async function main() {
+	const options = parseCliOptions( process.argv.slice( 2 ) );
+	const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );
+	if ( AI_FEATURES.length > 0 && aiFeatures.length === 0 ) {
+		console.warn(
+			'\u26A0\uFE0F AI_FEATURES entries exist, but none satisfied the generated sync-ai guard. Check for missing aiSchemaFile/typesFile fields in scripts/block-config.ts.'
+		);
+	}
+
+	if ( aiFeatures.length === 0 ) {
+		console.log(
+			options.check
+				? '\u2139\uFE0F No workspace AI features are registered yet. \`sync-ai --check\` is already clean.'
+				: '\u2139\uFE0F No workspace AI features are registered yet.'
+		);
+		return;
+	}
+
+	for ( const feature of aiFeatures ) {
+		const sourceSchemaPath = path.join(
+			path.dirname( feature.typesFile ),
+			'api-schemas',
+			'feature-result.schema.json'
+		);
+		const sourceSchema = await loadJsonDocument( sourceSchemaPath );
+		const aiSchema = projectWordPressAiSchema( sourceSchema );
+		await reconcileGeneratedArtifact( {
+			check: options.check,
+			content: \`\${ JSON.stringify( aiSchema, null, 2 ) }\\n\`,
+			filePath: feature.aiSchemaFile,
+			label: feature.slug,
+		} );
+	}
+
+	console.log(
+		options.check
+			? '\u2705 AI feature structured-output schemas are already synchronized.'
+			: '\u2705 AI feature structured-output schemas were synchronized.'
+	);
+}
+
+main().catch( ( error ) => {
+	console.error( '\u274C AI feature sync failed:', error );
+	process.exit( 1 );
+} );
+`;
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-anchors.ts
+import { promises as fsp6 } from "fs";
+import path10 from "path";
+var AI_FEATURE_SERVER_GLOB = "/inc/ai-features/*.php";
+function escapeRegex4(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+async function ensureAiFeatureBootstrapAnchors(workspace) {
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  await patchFile(bootstrapPath, (source) => {
+    let nextSource = source;
+    const registerFunctionName = `${workspace.workspace.phpPrefix}_register_ai_features`;
+    const registerHook = `add_action( 'init', '${registerFunctionName}', 20 );`;
+    const registerFunction = `
+
+function ${registerFunctionName}() {
+	foreach ( glob( __DIR__ . '${AI_FEATURE_SERVER_GLOB}' ) ?: array() as $ai_feature_module ) {
+		require_once $ai_feature_module;
+	}
+}
+`;
+    const insertionAnchors = [
+      /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
+      /\?>\s*$/u
+    ];
+    const hasPhpFunctionDefinition = (functionName) => new RegExp(`function\\s+${escapeRegex4(functionName)}\\s*\\(`, "u").test(nextSource);
+    const insertPhpSnippet = (snippet) => {
+      for (const anchor of insertionAnchors) {
+        const candidate = nextSource.replace(anchor, (match) => `${snippet}
+${match}`);
+        if (candidate !== nextSource) {
+          nextSource = candidate;
+          return;
+        }
+      }
+      nextSource = `${nextSource.trimEnd()}
+${snippet}
+`;
+    };
+    const appendPhpSnippet = (snippet) => {
+      const closingTagPattern = /\?>\s*$/u;
+      if (closingTagPattern.test(nextSource)) {
+        nextSource = nextSource.replace(closingTagPattern, `${snippet}
+?>`);
+        return;
+      }
+      nextSource = `${nextSource.trimEnd()}
+${snippet}
+`;
+    };
+    if (!hasPhpFunctionDefinition(registerFunctionName)) {
+      insertPhpSnippet(registerFunction);
+    } else if (!nextSource.includes(AI_FEATURE_SERVER_GLOB)) {
+      throw new Error([
+        `Unable to patch ${path10.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
+        `The existing ${registerFunctionName}() definition does not include ${AI_FEATURE_SERVER_GLOB}.`,
+        "Restore the generated bootstrap shape or wire the AI feature loader manually before retrying."
+      ].join(" "));
+    }
+    if (!nextSource.includes(registerHook)) {
+      appendPhpSnippet(registerHook);
+    }
+    return nextSource;
+  });
+}
+async function ensureAiFeaturePackageScripts(workspace) {
+  const packageJsonPath = path10.join(workspace.projectDir, "package.json");
+  const packageJson = JSON.parse(await fsp6.readFile(packageJsonPath, "utf8"));
+  const nextScripts = {
+    ...packageJson.scripts ?? {},
+    "sync-ai": packageJson.scripts?.["sync-ai"] ?? "tsx scripts/sync-ai-features.ts"
+  };
+  const nextDevDependencies = {
+    ...packageJson.devDependencies ?? {},
+    "@wp-typia/project-tools": packageJson.devDependencies?.["@wp-typia/project-tools"] ?? getPackageVersions().projectToolsPackageVersion
+  };
+  const addedSyncAiScript = packageJson.scripts?.["sync-ai"] === undefined;
+  const addedProjectToolsDependency = packageJson.devDependencies?.["@wp-typia/project-tools"] === undefined;
+  if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {}) && JSON.stringify(nextDevDependencies) === JSON.stringify(packageJson.devDependencies ?? {})) {
+    return {
+      addedProjectToolsDependency: false,
+      addedSyncAiScript: false
+    };
+  }
+  packageJson.scripts = nextScripts;
+  packageJson.devDependencies = nextDevDependencies;
+  await fsp6.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+`, "utf8");
+  return {
+    addedProjectToolsDependency,
+    addedSyncAiScript
+  };
+}
+async function ensureAiFeatureSyncProjectAnchors(workspace) {
+  const syncProjectScriptPath = path10.join(workspace.projectDir, "scripts", "sync-project.ts");
+  await patchFile(syncProjectScriptPath, (source) => {
+    let nextSource = source;
+    const syncRestConst = "const syncRestScriptPath = path.join( 'scripts', 'sync-rest-contracts.ts' );";
+    const syncAiConst = "const syncAiScriptPath = path.join( 'scripts', 'sync-ai-features.ts' );";
+    const syncRestBlockPattern = /if \( fs\.existsSync\( path\.resolve\( process\.cwd\(\), syncRestScriptPath \) \) \) \{\n\s*runSyncScript\( syncRestScriptPath, options \);\n\s*\}/u;
+    const syncAiBlock = [
+      "if ( fs.existsSync( path.resolve( process.cwd(), syncAiScriptPath ) ) ) {",
+      "\trunSyncScript( syncAiScriptPath, options );",
+      "}"
+    ].join(`
+`);
+    if (!nextSource.includes(syncAiConst)) {
+      if (!nextSource.includes(syncRestConst)) {
+        throw new Error([
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path10.basename(syncProjectScriptPath)}.`,
+          "Missing the expected sync-rest script constant in scripts/sync-project.ts.",
+          "Restore the generated template or wire sync-ai manually before retrying."
+        ].join(" "));
+      }
+      nextSource = nextSource.replace(syncRestConst, `${syncRestConst}
+${syncAiConst}`);
+    }
+    if (!nextSource.includes("runSyncScript( syncAiScriptPath, options );")) {
+      if (!syncRestBlockPattern.test(nextSource)) {
+        throw new Error([
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path10.basename(syncProjectScriptPath)}.`,
+          "Missing the expected sync-rest invocation block in scripts/sync-project.ts.",
+          "Restore the generated template or wire sync-ai manually before retrying."
+        ].join(" "));
+      }
+      nextSource = nextSource.replace(syncRestBlockPattern, (match) => `${match}
+
+${syncAiBlock}`);
+    }
+    return nextSource;
+  });
+}
+function assertSyncRestAnchor2(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
+  if (!nextSource.includes(target) && !hasAnchor) {
+    throw new Error([
+      `ensureAiFeatureSyncRestAnchors could not patch ${path10.basename(syncRestScriptPath)}.`,
+      `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
+      "Restore the generated template or add the AI feature wiring manually before retrying."
+    ].join(" "));
+  }
+}
+function replaceRequiredSyncRestSource2(nextSource, target, anchor, replacement, anchorDescription, syncRestScriptPath) {
+  if (nextSource.includes(target)) {
+    return nextSource;
+  }
+  const hasAnchor = typeof anchor === "string" ? nextSource.includes(anchor) : anchor.test(nextSource);
+  assertSyncRestAnchor2(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath);
+  return nextSource.replace(anchor, replacement);
+}
+async function ensureAiFeatureSyncRestAnchors(workspace) {
+  const syncRestScriptPath = path10.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  await patchFile(syncRestScriptPath, (source) => {
+    let nextSource = source;
+    const importAnchor = [
+      "import {",
+      "\tBLOCKS,",
+      "\tREST_RESOURCES,",
+      "\ttype WorkspaceBlockConfig,",
+      "\ttype WorkspaceRestResourceConfig,",
+      "} from './block-config';"
+    ].join(`
+`);
+    const helperInsertionAnchor = "async function assertTypeArtifactsCurrent";
+    const restResourcesAnchor = "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );";
+    const noResourcesPattern = /if \( restBlocks.length === 0 && restResources.length === 0 \) \{[\s\S]*?\n\t\treturn;\n\t\}/u;
+    const consoleLogPattern = /\n\tconsole\.log\(\n\t\toptions\.check/u;
+    nextSource = replaceRequiredSyncRestSource2(nextSource, "AI_FEATURES", importAnchor, [
+      "import {",
+      "\tAI_FEATURES,",
+      "\tBLOCKS,",
+      "\tREST_RESOURCES,",
+      "\ttype WorkspaceAiFeatureConfig,",
+      "\ttype WorkspaceBlockConfig,",
+      "\ttype WorkspaceRestResourceConfig,",
+      "} from './block-config';"
+    ].join(`
+`), "workspace inventory import", syncRestScriptPath);
+    nextSource = replaceRequiredSyncRestSource2(nextSource, "function isWorkspaceAiFeature(", helperInsertionAnchor, [
+      "function isWorkspaceAiFeature(",
+      "\tfeature: WorkspaceAiFeatureConfig",
+      "): feature is WorkspaceAiFeatureConfig & {",
+      "\taiSchemaFile: string;",
+      "\tclientFile: string;",
+      "\topenApiFile: string;",
+      "\trestManifest: NonNullable< WorkspaceAiFeatureConfig[ 'restManifest' ] >;",
+      "\ttypesFile: string;",
+      "\tvalidatorsFile: string;",
+      "} {",
+      "\treturn (",
+      "\t\ttypeof feature.aiSchemaFile === 'string' &&",
+      "\t\ttypeof feature.clientFile === 'string' &&",
+      "\t\ttypeof feature.openApiFile === 'string' &&",
+      "\t\ttypeof feature.typesFile === 'string' &&",
+      "\t\ttypeof feature.validatorsFile === 'string' &&",
+      "\t\ttypeof feature.restManifest === 'object' &&",
+      "\t\tfeature.restManifest !== null",
+      "\t);",
+      "}",
+      "",
+      "async function assertTypeArtifactsCurrent"
+    ].join(`
+`), "type artifact assertion helper", syncRestScriptPath);
+    nextSource = replaceRequiredSyncRestSource2(nextSource, "const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );", restResourcesAnchor, [
+      "const restResources = REST_RESOURCES.filter( isWorkspaceRestResource );",
+      "const aiFeatures = AI_FEATURES.filter( isWorkspaceAiFeature );"
+    ].join(`
+`), "rest resource filter", syncRestScriptPath);
+    nextSource = replaceRequiredSyncRestSource2(nextSource, "restBlocks.length === 0 && restResources.length === 0 && aiFeatures.length === 0", noResourcesPattern, [
+      "if ( restBlocks.length === 0 && restResources.length === 0 && aiFeatures.length === 0 ) {",
+      "\t\tconsole.log(",
+      "\t\t\toptions.check",
+      "\t\t\t\t? '\u2139\uFE0F No REST-enabled workspace blocks, plugin-level REST resources, or AI features are registered yet. `sync-rest --check` is already clean.'",
+      "\t\t\t\t: '\u2139\uFE0F No REST-enabled workspace blocks, plugin-level REST resources, or AI features are registered yet.'",
+      "\t\t);",
+      "\t\treturn;",
+      "\t}"
+    ].join(`
+`), "no-resources guard", syncRestScriptPath);
+    nextSource = replaceRequiredSyncRestSource2(nextSource, "for ( const feature of aiFeatures ) {", consoleLogPattern, [
+      "",
+      "\tfor ( const feature of aiFeatures ) {",
+      "\t\tconst contracts = feature.restManifest.contracts;",
+      "",
+      "\t\tfor ( const [ baseName, contract ] of Object.entries( contracts ) ) {",
+      "\t\t\tawait syncTypeSchemas(",
+      "\t\t\t\t{",
+      "\t\t\t\t\tjsonSchemaFile: path.join(",
+      "\t\t\t\t\t\tpath.dirname( feature.typesFile ),",
+      "\t\t\t\t\t\t'api-schemas',",
+      "\t\t\t\t\t\t`${ baseName }.schema.json`",
+      "\t\t\t\t\t),",
+      "\t\t\t\t\topenApiFile: path.join(",
+      "\t\t\t\t\t\tpath.dirname( feature.typesFile ),",
+      "\t\t\t\t\t\t'api-schemas',",
+      "\t\t\t\t\t\t`${ baseName }.openapi.json`",
+      "\t\t\t\t\t),",
+      "\t\t\t\t\tsourceTypeName: contract.sourceTypeName,",
+      "\t\t\t\t\ttypesFile: feature.typesFile,",
+      "\t\t\t\t},",
+      "\t\t\t\t{",
+      "\t\t\t\t\tcheck: options.check,",
+      "\t\t\t\t}",
+      "\t\t\t);",
+      "\t\t}",
+      "",
+      "\t\tawait syncRestOpenApi(",
+      "\t\t\t{",
+      "\t\t\t\tmanifest: feature.restManifest,",
+      "\t\t\t\topenApiFile: feature.openApiFile,",
+      "\t\t\t\ttypesFile: feature.typesFile,",
+      "\t\t\t},",
+      "\t\t\t{",
+      "\t\t\t\tcheck: options.check,",
+      "\t\t\t}",
+      "\t\t);",
+      "",
+      "\t\tawait syncEndpointClient(",
+      "\t\t\t{",
+      "\t\t\t\tclientFile: feature.clientFile,",
+      "\t\t\t\tmanifest: feature.restManifest,",
+      "\t\t\t\ttypesFile: feature.typesFile,",
+      "\t\t\t\tvalidatorsFile: feature.validatorsFile,",
+      "\t\t\t},",
+      "\t\t\t{",
+      "\t\t\t\tcheck: options.check,",
+      "\t\t\t}",
+      "\t\t);",
+      "\t}",
+      "",
+      "\tconsole.log(",
+      "\t\toptions.check"
+    ].join(`
+`), "final sync summary", syncRestScriptPath);
+    nextSource = replaceRequiredSyncRestSource2(nextSource, "workspace blocks, plugin-level resources, and AI features", "workspace blocks and plugin-level resources", "workspace blocks, plugin-level resources, and AI features", "sync summary copy", syncRestScriptPath);
+    return nextSource;
+  });
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+function quotePhpString4(value) {
+  return `'${value.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
+}
+function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
+  const aiFeatureTitle = toTitleCase(aiFeatureSlug);
+  const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
+  const loadSchemaFunctionName = `${phpPrefix}_${aiFeaturePhpId}_load_ai_feature_schema`;
+  const loadAiSchemaFunctionName = `${phpPrefix}_${aiFeaturePhpId}_load_ai_response_schema`;
+  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 buildPromptFunctionName = `${phpPrefix}_${aiFeaturePhpId}_build_ai_feature_prompt`;
+  const normalizeProviderTypeFunctionName = `${phpPrefix}_${aiFeaturePhpId}_normalize_provider_type`;
+  const buildTelemetryFunctionName = `${phpPrefix}_${aiFeaturePhpId}_build_ai_feature_telemetry`;
+  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`;
+  return `<?php
+if ( ! defined( 'ABSPATH' ) ) {
+	return;
+}
+
+if ( ! function_exists( '${loadSchemaFunctionName}' ) ) {
+	function ${loadSchemaFunctionName}( $schema_name ) {
+		$project_root = dirname( __DIR__, 2 );
+		$schema_path  = $project_root . '/src/ai-features/${aiFeatureSlug}/api-schemas/' . $schema_name . '.schema.json';
+		if ( ! file_exists( $schema_path ) ) {
+			return null;
+		}
+
+		$decoded = json_decode( file_get_contents( $schema_path ), true );
+		return is_array( $decoded ) ? $decoded : null;
+	}
+}
+
+if ( ! function_exists( '${loadAiSchemaFunctionName}' ) ) {
+	function ${loadAiSchemaFunctionName}() {
+		$project_root = dirname( __DIR__, 2 );
+		$schema_path  = $project_root . '/src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json';
+		if ( ! file_exists( $schema_path ) ) {
+			return null;
+		}
+
+		$decoded = json_decode( file_get_contents( $schema_path ), true );
+		return is_array( $decoded ) ? $decoded : null;
+	}
+}
+
+if ( ! function_exists( '${normalizeSchemaFunctionName}' ) ) {
+	function ${normalizeSchemaFunctionName}( $schema ) {
+		if ( ! is_array( $schema ) ) {
+			return $schema;
+		}
+
+		unset( $schema['$schema'], $schema['title'] );
+
+		if ( isset( $schema['properties'] ) && is_array( $schema['properties'] ) ) {
+			foreach ( $schema['properties'] as $key => $property_schema ) {
+				$schema['properties'][ $key ] = ${normalizeSchemaFunctionName}( $property_schema );
+			}
+		}
+
+		if ( isset( $schema['items'] ) && is_array( $schema['items'] ) ) {
+			$schema['items'] = ${normalizeSchemaFunctionName}( $schema['items'] );
+		}
+
+		return $schema;
+	}
+}
+
+if ( ! function_exists( '${validatePayloadFunctionName}' ) ) {
+	function ${validatePayloadFunctionName}( $value, $schema_name, $param_name ) {
+		$schema = ${loadSchemaFunctionName}( $schema_name );
+		if ( ! is_array( $schema ) ) {
+			return new WP_Error( 'missing_schema', 'Missing AI feature schema.', array( 'status' => 500 ) );
+		}
+
+		$rest_schema = ${normalizeSchemaFunctionName}( $schema );
+		$validation  = rest_validate_value_from_schema( $value, $rest_schema, $param_name );
+		if ( is_wp_error( $validation ) ) {
+			return $validation;
+		}
+
+		return rest_sanitize_value_from_schema( $value, $rest_schema, $param_name );
+	}
+}
+
+if ( ! function_exists( '${canManageFunctionName}' ) ) {
+	function ${canManageFunctionName}() {
+		return current_user_can( 'edit_posts' );
+	}
+}
+
+if ( ! function_exists( '${buildPromptFunctionName}' ) ) {
+	function ${buildPromptFunctionName}( array $payload ) {
+		return 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',
+			${quotePhpString4(aiFeatureTitle)},
+			wp_json_encode( $payload )
+		);
+	}
+}
+
+if ( ! function_exists( '${normalizeProviderTypeFunctionName}' ) ) {
+	function ${normalizeProviderTypeFunctionName}( $provider_type ) {
+		if ( is_object( $provider_type ) && isset( $provider_type->value ) && is_string( $provider_type->value ) ) {
+			return $provider_type->value;
+		}
+
+		return is_string( $provider_type ) && '' !== $provider_type ? $provider_type : 'cloud';
+	}
+}
+
+if ( ! function_exists( '${buildTelemetryFunctionName}' ) ) {
+	function ${buildTelemetryFunctionName}( $result ) {
+		if (
+			! is_object( $result ) ||
+			! method_exists( $result, 'getId' ) ||
+			! method_exists( $result, 'getModelMetadata' ) ||
+			! method_exists( $result, 'getProviderMetadata' ) ||
+			! method_exists( $result, 'getTokenUsage' )
+		) {
+			return new WP_Error(
+				'ai_client_result_shape',
+				'The current WordPress AI Client result object is missing telemetry helpers.',
+				array( 'status' => 502 )
+			);
+		}
+
+		$model_metadata    = $result->getModelMetadata();
+		$provider_metadata = $result->getProviderMetadata();
+		$token_usage       = $result->getTokenUsage();
+
+		if (
+			! is_object( $model_metadata ) ||
+			! method_exists( $model_metadata, 'getId' ) ||
+			! method_exists( $model_metadata, 'getName' ) ||
+			! is_object( $provider_metadata ) ||
+			! method_exists( $provider_metadata, 'getId' ) ||
+			! method_exists( $provider_metadata, 'getName' ) ||
+			! method_exists( $provider_metadata, 'getType' ) ||
+			! is_object( $token_usage ) ||
+			! method_exists( $token_usage, 'getCompletionTokens' ) ||
+			! method_exists( $token_usage, 'getPromptTokens' ) ||
+			! method_exists( $token_usage, 'getTotalTokens' )
+		) {
+			return new WP_Error(
+				'ai_client_result_shape',
+				'The current WordPress AI Client telemetry objects are missing expected getters.',
+				array( 'status' => 502 )
+			);
+		}
+
+		$telemetry = array(
+			'modelId'      => (string) $model_metadata->getId(),
+			'modelName'    => (string) $model_metadata->getName(),
+			'providerId'   => (string) $provider_metadata->getId(),
+			'providerName' => (string) $provider_metadata->getName(),
+			'providerType' => ${normalizeProviderTypeFunctionName}( $provider_metadata->getType() ),
+			'resultId'     => (string) $result->getId(),
+			'tokenUsage'   => array(
+				'completionTokens' => (int) $token_usage->getCompletionTokens(),
+				'promptTokens'     => (int) $token_usage->getPromptTokens(),
+				'totalTokens'      => (int) $token_usage->getTotalTokens(),
+			),
+		);
+
+		if ( method_exists( $token_usage, 'getThoughtTokens' ) ) {
+			$thought_tokens = $token_usage->getThoughtTokens();
+			if ( null !== $thought_tokens ) {
+				$telemetry['tokenUsage']['thoughtTokens'] = (int) $thought_tokens;
+			}
+		}
+
+		return $telemetry;
+	}
+}
+
+if ( ! function_exists( '${isSupportedFunctionName}' ) ) {
+	function ${isSupportedFunctionName}() {
+		static $is_supported = null;
+		if ( null !== $is_supported ) {
+			return $is_supported;
+		}
+
+		if ( ! function_exists( 'wp_ai_client_prompt' ) ) {
+			$is_supported = false;
+			return $is_supported;
+		}
+
+		$schema = ${loadAiSchemaFunctionName}();
+		if ( ! is_array( $schema ) ) {
+			$is_supported = false;
+			return $is_supported;
+		}
+
+		$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;
+		}
+
+		$structured_prompt = $prompt->as_json_response( $schema );
+		if ( ! is_object( $structured_prompt ) ) {
+			$is_supported = false;
+			return $is_supported;
+		}
+
+		if ( method_exists( $structured_prompt, 'is_supported_for_text_generation' ) ) {
+			$is_supported = (bool) $structured_prompt->is_supported_for_text_generation();
+			return $is_supported;
+		}
+
+		$is_supported = method_exists( $structured_prompt, 'generate_text_result' );
+		return $is_supported;
+	}
+}
+
+if ( ! function_exists( '${adminNoticeFunctionName}' ) ) {
+	function ${adminNoticeFunctionName}() {
+		if ( ! current_user_can( 'manage_options' ) || ${isSupportedFunctionName}() ) {
+			return;
+		}
+
+		$message = sprintf(
+			/* translators: %s: AI feature name. */
+			__( '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.', ${quotePhpString4(textDomain)} ),
+			${quotePhpString4(aiFeatureTitle)}
+		);
+		printf( '<div class="notice notice-warning"><p>%s</p></div>', esc_html( $message ) );
+	}
+}
+
+if ( ! function_exists( '${handlerFunctionName}' ) ) {
+	function ${handlerFunctionName}( WP_REST_Request $request ) {
+		$payload = ${validatePayloadFunctionName}( $request->get_json_params(), 'feature-request', 'body' );
+		if ( is_wp_error( $payload ) ) {
+			return $payload;
+		}
+
+		if ( ! ${isSupportedFunctionName}() ) {
+			return new WP_Error(
+				'ai_client_unavailable',
+				'The WordPress AI Client is unavailable or does not support this feature endpoint.',
+				array( 'status' => 501 )
+			);
+		}
+
+		$ai_schema = ${loadAiSchemaFunctionName}();
+		if ( ! is_array( $ai_schema ) ) {
+			return new WP_Error(
+				'ai_client_schema_missing',
+				'The generated AI response schema is missing for this feature endpoint.',
+				array( 'status' => 500 )
+			);
+		}
+
+		$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.',
+				array( 'status' => 501 )
+			);
+		}
+
+		if ( method_exists( $prompt, 'using_temperature' ) ) {
+			$prompt = $prompt->using_temperature( 0.2 );
+		}
+		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().',
+				array( 'status' => 501 )
+			);
+		}
+
+		$structured_prompt = $prompt->as_json_response( $ai_schema );
+		if ( ! is_object( $structured_prompt ) ) {
+			return new WP_Error(
+				'ai_client_unavailable',
+				'The current WordPress AI Client could not prepare a structured-output prompt.',
+				array( 'status' => 501 )
+			);
+		}
+
+		if (
+			method_exists( $structured_prompt, 'is_supported_for_text_generation' ) &&
+			! $structured_prompt->is_supported_for_text_generation()
+		) {
+			return new WP_Error(
+				'ai_client_unavailable',
+				'The current WordPress AI Client provider or model does not support this structured-output feature.',
+				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().',
+				array( 'status' => 501 )
+			);
+		}
+
+		$result = $structured_prompt->generate_text_result();
+		if ( is_wp_error( $result ) ) {
+			return $result;
+		}
+		if ( ! is_object( $result ) || ! method_exists( $result, 'toText' ) ) {
+			return new WP_Error(
+				'ai_client_result_shape',
+				'The current WordPress AI Client result does not expose toText().',
+				array( 'status' => 502 )
+			);
+		}
+
+		$decoded_result = json_decode( $result->toText(), true );
+		if ( ! is_array( $decoded_result ) ) {
+			return new WP_Error(
+				'ai_client_invalid_json',
+				'The AI feature response did not decode to a JSON object.',
+				array( 'status' => 502 )
+			);
+		}
+
+		$normalized_result = ${validatePayloadFunctionName}( $decoded_result, 'feature-result', 'result' );
+		if ( is_wp_error( $normalized_result ) ) {
+			return new WP_Error(
+				'ai_client_invalid_response',
+				$normalized_result->get_error_message(),
+				array( 'status' => 502 )
+			);
+		}
+
+		$telemetry = ${buildTelemetryFunctionName}( $result );
+		if ( is_wp_error( $telemetry ) ) {
+			return $telemetry;
+		}
+
+		$response = ${validatePayloadFunctionName}(
+			array(
+				'result'    => $normalized_result,
+				'telemetry' => $telemetry,
+			),
+			'feature-response',
+			'response'
+		);
+		if ( is_wp_error( $response ) ) {
+			return new WP_Error(
+				'ai_client_invalid_response',
+				$response->get_error_message(),
+				array( 'status' => 502 )
+			);
+		}
+
+		return rest_ensure_response( $response );
+	}
+}
+
+if ( ! function_exists( '${registerRoutesFunctionName}' ) ) {
+	function ${registerRoutesFunctionName}() {
+		register_rest_route(
+			${quotePhpString4(namespace)},
+			'/ai/${aiFeatureSlug}',
+			array(
+				array(
+					'methods'             => WP_REST_Server::CREATABLE,
+					'callback'            => '${handlerFunctionName}',
+					'permission_callback' => '${canManageFunctionName}',
+				)
+			)
+		);
+	}
+}
+
+add_action( 'admin_notices', '${adminNoticeFunctionName}' );
+add_action( 'rest_api_init', '${registerRoutesFunctionName}' );
+`;
+}
+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 blockConfigPath = path11.join(workspace.projectDir, "scripts", "block-config.ts");
+  const bootstrapPath = getWorkspaceBootstrapPath(workspace);
+  const packageJsonPath = path11.join(workspace.projectDir, "package.json");
+  const syncAiScriptPath = path11.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
+  const syncProjectScriptPath = path11.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncRestScriptPath = path11.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const aiFeatureDir = path11.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
+  const typesFilePath = path11.join(aiFeatureDir, "api-types.ts");
+  const validatorsFilePath = path11.join(aiFeatureDir, "api-validators.ts");
+  const apiFilePath = path11.join(aiFeatureDir, "api.ts");
+  const dataFilePath = path11.join(aiFeatureDir, "data.ts");
+  const phpFilePath = path11.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles([
+      blockConfigPath,
+      bootstrapPath,
+      packageJsonPath,
+      syncAiScriptPath,
+      syncProjectScriptPath,
+      syncRestScriptPath
+    ]),
+    snapshotDirs: [],
+    targetPaths: [aiFeatureDir, phpFilePath, syncAiScriptPath]
+  };
+  try {
+    await fsp7.mkdir(aiFeatureDir, { recursive: true });
+    await fsp7.mkdir(path11.dirname(phpFilePath), { recursive: true });
+    await ensureAiFeatureBootstrapAnchors(workspace);
+    await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
+    const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
+    await ensureAiFeatureSyncProjectAnchors(workspace);
+    await ensureAiFeatureSyncRestAnchors(workspace);
+    await fsp7.writeFile(syncAiScriptPath, buildAiFeatureSyncScriptSource(), "utf8");
+    await fsp7.writeFile(typesFilePath, buildAiFeatureTypesSource(aiFeatureSlug), "utf8");
+    await fsp7.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
+    await fsp7.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
+    await fsp7.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
+    await fsp7.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
+    const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
+    await syncAiFeatureRestArtifacts({
+      clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
+      outputDir: path11.join("src", "ai-features", aiFeatureSlug),
+      projectDir: workspace.projectDir,
+      typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
+      validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
+      variables: {
+        namespace: resolvedNamespace,
+        pascalCase,
+        slugKebabCase: aiFeatureSlug,
+        title: toTitleCase(aiFeatureSlug)
+      }
+    });
+    await syncAiFeatureSchemaArtifact({
+      aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
+      outputDir: path11.join("src", "ai-features", aiFeatureSlug),
+      projectDir: workspace.projectDir
+    });
+    await appendWorkspaceInventoryEntries(workspace.projectDir, {
+      aiFeatureEntries: [
+        buildAiFeatureConfigEntry(aiFeatureSlug, resolvedNamespace)
+      ],
+      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`."
+      ] : []
+    };
+  } catch (error) {
+    await rollbackWorkspaceMutation(mutationSnapshot);
+    throw error;
+  }
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
+var VARIATIONS_IMPORT_LINE = "import { registerWorkspaceVariations } from './variations';";
+var VARIATIONS_CALL_LINE = "registerWorkspaceVariations();";
+function buildVariationConfigEntry(blockSlug, variationSlug) {
+  return [
+    "\t{",
+    `		block: ${quoteTsString(blockSlug)},`,
+    `		file: ${quoteTsString(`src/blocks/${blockSlug}/variations/${variationSlug}.ts`)},`,
+    `		slug: ${quoteTsString(variationSlug)},`,
+    "\t},"
+  ].join(`
+`);
+}
+function buildVariationConstName(variationSlug) {
+  const identifierSegments = toKebabCase(variationSlug).split("-").filter(Boolean);
+  return `workspaceVariation_${identifierSegments.join("_")}`;
+}
+function getVariationConstBindings(variationSlugs) {
+  const seenConstNames = new Map;
+  return variationSlugs.map((variationSlug) => {
+    const constName = buildVariationConstName(variationSlug);
+    const previousSlug = seenConstNames.get(constName);
+    if (previousSlug && previousSlug !== variationSlug) {
+      throw new Error(`Variation slugs "${previousSlug}" and "${variationSlug}" generate the same registry identifier "${constName}". Rename one of the variations.`);
+    }
+    seenConstNames.set(constName, variationSlug);
+    return { constName, variationSlug };
+  });
+}
+function buildVariationSource(variationSlug, textDomain) {
+  const variationTitle = toTitleCase(variationSlug);
+  const variationConstName = buildVariationConstName(variationSlug);
+  return `import type { BlockVariation } from '@wp-typia/block-types/blocks/registration';
+import { __ } from '@wordpress/i18n';
+
+export const ${variationConstName} = {
+	name: ${quoteTsString(variationSlug)},
+	title: __( ${quoteTsString(variationTitle)}, ${quoteTsString(textDomain)} ),
+	description: __(
+		${quoteTsString(`A starter variation for ${variationTitle}.`)},
+		${quoteTsString(textDomain)},
+	),
+	attributes: {},
+	scope: ['inserter'],
+} satisfies BlockVariation;
+`;
+}
+function buildVariationIndexSource(variationSlugs) {
+  const variationBindings = getVariationConstBindings(variationSlugs);
+  const importLines = variationBindings.map(({ constName, variationSlug }) => {
+    return `import { ${constName} } from './${variationSlug}';`;
+  }).join(`
+`);
+  const variationConstNames = variationBindings.map(({ constName }) => constName).join(`,
+		`);
+  return `import { registerBlockVariation } from '@wordpress/blocks';
+import metadata from '../block.json';
+${importLines ? `
+${importLines}` : ""}
+
+const WORKSPACE_VARIATIONS = [
+	${variationConstNames}
+	// wp-typia add variation entries
+];
+
+export function registerWorkspaceVariations() {
+	for (const variation of WORKSPACE_VARIATIONS) {
+		registerBlockVariation(metadata.name, variation);
+	}
+}
+`;
+}
+async function ensureVariationRegistrationHook(blockIndexPath) {
+  await patchFile(blockIndexPath, (source) => {
+    let nextSource = source;
+    if (!nextSource.includes(VARIATIONS_IMPORT_LINE)) {
+      nextSource = `${VARIATIONS_IMPORT_LINE}
+${nextSource}`;
+    }
+    if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
+      const callInsertionPatterns = [
+        /(registerBlockType<[\s\S]*?\);\s*)/u,
+        /(registerBlockType\([\s\S]*?\);\s*)/u
+      ];
+      let inserted = false;
+      for (const pattern of callInsertionPatterns) {
+        const candidate = nextSource.replace(pattern, (match) => `${match}
+${VARIATIONS_CALL_LINE}
+`);
+        if (candidate !== nextSource) {
+          nextSource = candidate;
+          inserted = true;
+          break;
+        }
+      }
+      if (!inserted) {
+        nextSource = `${nextSource.trimEnd()}
+
+${VARIATIONS_CALL_LINE}
+`;
+      }
+    }
+    if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
+      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path12.basename(blockIndexPath)}.`);
+    }
+    return nextSource;
+  });
+}
+async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
+  const variationsDir = path12.join(projectDir, "src", "blocks", blockSlug, "variations");
+  const variationsIndexPath = path12.join(variationsDir, "index.ts");
+  await fsp8.mkdir(variationsDir, { recursive: true });
+  const existingVariationSlugs = fs5.readdirSync(variationsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
+  await fsp8.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
+}
+async function runAddVariationCommand({
+  blockName,
+  cwd = process.cwd(),
+  variationName
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const blockSlug = normalizeBlockSlug(blockName);
+  const variationSlug = assertValidGeneratedSlug("Variation name", normalizeBlockSlug(variationName), "wp-typia add variation <name> --block <block-slug>");
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  resolveWorkspaceBlock(inventory, blockSlug);
+  assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
+  const blockConfigPath = path12.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path12.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const variationsDir = path12.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
+  const variationFilePath = path12.join(variationsDir, `${variationSlug}.ts`);
+  const variationsIndexPath = path12.join(variationsDir, "index.ts");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -2942,8 +4964,8 @@ async function runAddVariationCommand({
     targetPaths: [variationFilePath]
   };
   try {
-    await fsp5.mkdir(variationsDir, { recursive: true });
-    await fsp5.writeFile(variationFilePath, buildVariationSource(variationSlug, workspace.workspace.textDomain), "utf8");
+    await fsp8.mkdir(variationsDir, { recursive: true });
+    await fsp8.writeFile(variationFilePath, buildVariationSource(variationSlug, workspace.workspace.textDomain), "utf8");
     await writeVariationRegistry(workspace.projectDir, blockSlug, variationSlug);
     await ensureVariationRegistrationHook(blockIndexPath);
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -2976,7 +4998,7 @@ async function runAddHookedBlockCommand({
     throw new Error("`wp-typia add hooked-block` cannot hook a block relative to its own block name.");
   }
   const { blockJson, blockJsonPath } = readWorkspaceBlockJson(workspace.projectDir, blockSlug);
-  const blockJsonRelativePath = path8.relative(workspace.projectDir, blockJsonPath);
+  const blockJsonRelativePath = path12.relative(workspace.projectDir, blockJsonPath);
   const blockHooks = getMutableBlockHooks(blockJson, blockJsonRelativePath);
   if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {
     throw new Error(`${blockJsonRelativePath} already defines a blockHooks entry for "${resolvedAnchorBlockName}".`);
@@ -2988,7 +5010,7 @@ async function runAddHookedBlockCommand({
   };
   try {
     blockHooks[resolvedAnchorBlockName] = resolvedPosition;
-    await fsp5.writeFile(blockJsonPath, JSON.stringify(blockJson, null, "\t"), "utf8");
+    await fsp8.writeFile(blockJsonPath, JSON.stringify(blockJson, null, "\t"), "utf8");
     return {
       anchorBlockName: resolvedAnchorBlockName,
       blockSlug,
@@ -3009,6 +5031,8 @@ export {
   runAddEditorPluginCommand,
   runAddBlockCommand,
   runAddBindingSourceCommand,
+  runAddAiFeatureCommand,
+  runAddAbilityCommand,
   getWorkspaceBlockSelectOptions,
   formatAddHelpText,
   EDITOR_PLUGIN_SLOT_IDS,
@@ -3016,4 +5040,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=862EE94117F7BF5964756E2164756E21
+//# debugId=2B54B495F629D39264756E2164756E21