wp-typia 0.20.2 → 0.20.3

package/dist-bunli/{cli-qpt5dt0x.js → cli-2rev5hqm.js}

@@ -54,7 +54,7 @@ import {
 } from "./cli-sj5mtyzj.js";
 import {
   readWorkspaceInventory
-} from "./cli-rg481yks.js";
+} from "./cli-3w3qxq9w.js";
 import {
   getInvalidWorkspaceProjectReason,
   tryResolveWorkspaceProject

package/dist-bunli/{cli-rg481yks.js → cli-3w3qxq9w.js}

@@ -171027,6 +171027,8 @@ var ADD_KIND_IDS = [
   "pattern",
   "binding-source",
   "rest-resource",
+  "ability",
+  "ai-feature",
   "hooked-block",
   "editor-plugin"
 ];
@@ -171229,6 +171231,32 @@ function assertRestResourceDoesNotExist(projectDir, restResourceSlug, inventory)
     throw new Error(`A REST resource inventory entry already exists for ${restResourceSlug}. Choose a different name.`);
   }
 }
+function assertAbilityDoesNotExist(projectDir, abilitySlug, inventory) {
+  const abilityDir = path.join(projectDir, "src", "abilities", abilitySlug);
+  const abilityPhpPath = path.join(projectDir, "inc", "abilities", `${abilitySlug}.php`);
+  if (fs.existsSync(abilityDir)) {
+    throw new Error(`An ability scaffold already exists at ${path.relative(projectDir, abilityDir)}. Choose a different name.`);
+  }
+  if (fs.existsSync(abilityPhpPath)) {
+    throw new Error(`An ability bootstrap already exists at ${path.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.`);
+  }
+}
+function assertAiFeatureDoesNotExist(projectDir, aiFeatureSlug, inventory) {
+  const aiFeatureDir = path.join(projectDir, "src", "ai-features", aiFeatureSlug);
+  const aiFeaturePhpPath = path.join(projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
+  if (fs.existsSync(aiFeatureDir)) {
+    throw new Error(`An AI feature already exists at ${path.relative(projectDir, aiFeatureDir)}. Choose a different name.`);
+  }
+  if (fs.existsSync(aiFeaturePhpPath)) {
+    throw new Error(`An AI feature bootstrap already exists at ${path.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.`);
+  }
+}
 function assertEditorPluginDoesNotExist(projectDir, editorPluginSlug, inventory) {
   const editorPluginDir = path.join(projectDir, "src", "editor-plugins", editorPluginSlug);
   if (fs.existsSync(editorPluginDir)) {
@@ -171245,6 +171273,8 @@ function formatAddHelpText() {
   wp-typia add pattern <name> [--dry-run]
   wp-typia add binding-source <name> [--dry-run]
   wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create,update,delete>] [--dry-run]
+  wp-typia add ability <name> [--dry-run]
+  wp-typia add ai-feature <name> [--namespace <vendor/v1>] [--dry-run]
   wp-typia add hooked-block <block-slug> --anchor <anchor-block-name> --position <${HOOKED_BLOCK_POSITION_IDS.join("|")}> [--dry-run]
   wp-typia add editor-plugin <name> [--slot <${EDITOR_PLUGIN_SLOT_IDS.join("|")}>] [--dry-run]
 
@@ -171256,6 +171286,8 @@ Notes:
   \`add pattern\` scaffolds a namespaced PHP pattern shell under \`src/patterns/\`.
   \`add binding-source\` scaffolds shared PHP and editor registration under \`src/bindings/\`.
   \`add rest-resource\` scaffolds plugin-level TypeScript REST contracts under \`src/rest/\` and PHP route glue under \`inc/rest/\`.
+  \`add ability\` scaffolds typed workflow abilities under \`src/abilities/\` and server registration under \`inc/abilities/\`.
+  \`add ai-feature\` scaffolds server-owned AI feature endpoints under \`src/ai-features/\` and PHP route glue under \`inc/ai-features/\`.
   \`add hooked-block\` patches an existing workspace block's \`block.json\` \`blockHooks\` metadata.
   \`add editor-plugin\` scaffolds a document-level editor extension under \`src/editor-plugins/\`.`;
 }
@@ -171270,6 +171302,8 @@ var VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 var PATTERN_CONFIG_ENTRY_MARKER = "\t// wp-typia add pattern entries";
 var BINDING_SOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add binding-source entries";
 var REST_RESOURCE_CONFIG_ENTRY_MARKER = "\t// wp-typia add rest-resource entries";
+var ABILITY_CONFIG_ENTRY_MARKER = "\t// wp-typia add ability entries";
+var AI_FEATURE_CONFIG_ENTRY_MARKER = "\t// wp-typia add ai-feature entries";
 var EDITOR_PLUGIN_CONFIG_ENTRY_MARKER = "\t// wp-typia add editor-plugin entries";
 var VARIATIONS_INTERFACE_SECTION = `
 
@@ -171336,6 +171370,62 @@ export const REST_RESOURCES: WorkspaceRestResourceConfig[] = [
 	// wp-typia add rest-resource entries
 ];
 `;
+var WORKSPACE_COMPATIBILITY_CONFIG_FIELD = `	compatibility?: {
+		hardMinimums: {
+			php?: string;
+			wordpress?: string;
+		};
+		mode: 'baseline' | 'optional' | 'required';
+		optionalFeatures: string[];
+		requiredFeatures: string[];
+		runtimeGates: string[];
+	};
+`;
+var ABILITIES_INTERFACE_SECTION = `
+
+export interface WorkspaceAbilityConfig {
+	clientFile: string;
+${WORKSPACE_COMPATIBILITY_CONFIG_FIELD}	configFile: string;
+	dataFile: string;
+	inputSchemaFile: string;
+	inputTypeName: string;
+	outputSchemaFile: string;
+	outputTypeName: string;
+	phpFile: string;
+	slug: string;
+	typesFile: string;
+}
+`;
+var ABILITIES_CONST_SECTION = `
+
+export const ABILITIES: WorkspaceAbilityConfig[] = [
+	// wp-typia add ability entries
+];
+`;
+var AI_FEATURES_INTERFACE_SECTION = `
+
+export interface WorkspaceAiFeatureConfig {
+	aiSchemaFile: string;
+	apiFile: string;
+	clientFile: string;
+${WORKSPACE_COMPATIBILITY_CONFIG_FIELD}	dataFile: string;
+	namespace: string;
+	openApiFile: string;
+	phpFile: string;
+	restManifest?: ReturnType<
+		typeof import( '@wp-typia/block-runtime/metadata-core' ).defineEndpointManifest
+	>;
+	slug: string;
+	typesFile: string;
+	validatorsFile: string;
+}
+`;
+var AI_FEATURES_CONST_SECTION = `
+
+export const AI_FEATURES: WorkspaceAiFeatureConfig[] = [
+	// wp-typia add ai-feature entries
+];
+`;
 var EDITOR_PLUGINS_INTERFACE_SECTION = `
 
 export interface WorkspaceEditorPluginConfig {
@@ -171502,6 +171592,44 @@ function parseRestResourceEntries(arrayLiteral) {
     };
   });
 }
+function parseAiFeatureEntries(arrayLiteral) {
+  return arrayLiteral.elements.map((element, elementIndex) => {
+    if (!import_typescript.default.isObjectLiteralExpression(element)) {
+      throw new Error(`AI_FEATURES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+    }
+    return {
+      aiSchemaFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "aiSchemaFile"),
+      apiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "apiFile"),
+      clientFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "clientFile"),
+      dataFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "dataFile"),
+      namespace: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "namespace"),
+      openApiFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "openApiFile"),
+      phpFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "phpFile"),
+      slug: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "slug"),
+      typesFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "typesFile"),
+      validatorsFile: getRequiredStringProperty("AI_FEATURES", elementIndex, element, "validatorsFile")
+    };
+  });
+}
+function parseAbilityEntries(arrayLiteral) {
+  return arrayLiteral.elements.map((element, elementIndex) => {
+    if (!import_typescript.default.isObjectLiteralExpression(element)) {
+      throw new Error(`ABILITIES[${elementIndex}] must be an object literal in scripts/block-config.ts.`);
+    }
+    return {
+      clientFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "clientFile"),
+      configFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "configFile"),
+      dataFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "dataFile"),
+      inputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputSchemaFile"),
+      inputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "inputTypeName"),
+      outputSchemaFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputSchemaFile"),
+      outputTypeName: getRequiredStringProperty("ABILITIES", elementIndex, element, "outputTypeName"),
+      phpFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "phpFile"),
+      slug: getRequiredStringProperty("ABILITIES", elementIndex, element, "slug"),
+      typesFile: getRequiredStringProperty("ABILITIES", elementIndex, element, "typesFile")
+    };
+  });
+}
 function parseEditorPluginEntries(arrayLiteral) {
   return arrayLiteral.elements.map((element, elementIndex) => {
     if (!import_typescript.default.isObjectLiteralExpression(element)) {
@@ -171524,6 +171652,8 @@ function parseWorkspaceInventorySource(source) {
   const patternArray = findExportedArrayLiteral(sourceFile, "PATTERNS");
   const bindingSourceArray = findExportedArrayLiteral(sourceFile, "BINDING_SOURCES");
   const restResourceArray = findExportedArrayLiteral(sourceFile, "REST_RESOURCES");
+  const abilityArray = findExportedArrayLiteral(sourceFile, "ABILITIES");
+  const aiFeatureArray = findExportedArrayLiteral(sourceFile, "AI_FEATURES");
   const editorPluginArray = findExportedArrayLiteral(sourceFile, "EDITOR_PLUGINS");
   if (variationArray.found && !variationArray.array) {
     throw new Error("scripts/block-config.ts must export VARIATIONS as an array literal.");
@@ -171537,12 +171667,22 @@ function parseWorkspaceInventorySource(source) {
   if (restResourceArray.found && !restResourceArray.array) {
     throw new Error("scripts/block-config.ts must export REST_RESOURCES as an array literal.");
   }
+  if (abilityArray.found && !abilityArray.array) {
+    throw new Error("scripts/block-config.ts must export ABILITIES as an array literal.");
+  }
+  if (aiFeatureArray.found && !aiFeatureArray.array) {
+    throw new Error("scripts/block-config.ts must export AI_FEATURES as an array literal.");
+  }
   if (editorPluginArray.found && !editorPluginArray.array) {
     throw new Error("scripts/block-config.ts must export EDITOR_PLUGINS as an array literal.");
   }
   return {
+    abilities: abilityArray.array ? parseAbilityEntries(abilityArray.array) : [],
+    aiFeatures: aiFeatureArray.array ? parseAiFeatureEntries(aiFeatureArray.array) : [],
     bindingSources: bindingSourceArray.array ? parseBindingSourceEntries(bindingSourceArray.array) : [],
     blocks: parseBlockEntries(blockArray.array),
+    hasAbilitiesSection: abilityArray.found,
+    hasAiFeaturesSection: aiFeatureArray.found,
     hasBindingSourcesSection: bindingSourceArray.found,
     hasEditorPluginsSection: editorPluginArray.found,
     hasPatternsSection: patternArray.found,
@@ -171604,6 +171744,18 @@ function ensureWorkspaceInventorySections(source) {
   if (!/export\s+const\s+REST_RESOURCES\b/u.test(nextSource)) {
     nextSource += REST_RESOURCES_CONST_SECTION;
   }
+  if (!/export\s+interface\s+WorkspaceAbilityConfig\b/u.test(nextSource)) {
+    nextSource += ABILITIES_INTERFACE_SECTION;
+  }
+  if (!/export\s+const\s+ABILITIES\b/u.test(nextSource)) {
+    nextSource += ABILITIES_CONST_SECTION;
+  }
+  if (!/export\s+interface\s+WorkspaceAiFeatureConfig\b/u.test(nextSource)) {
+    nextSource += AI_FEATURES_INTERFACE_SECTION;
+  }
+  if (!/export\s+const\s+AI_FEATURES\b/u.test(nextSource)) {
+    nextSource += AI_FEATURES_CONST_SECTION;
+  }
   if (!/export\s+interface\s+WorkspaceEditorPluginConfig\b/u.test(nextSource)) {
     nextSource += EDITOR_PLUGINS_INTERFACE_SECTION;
   }
@@ -171624,9 +171776,40 @@ function appendEntriesAtMarker(source, marker, entries) {
 `)}
 ${marker}`);
 }
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function ensureInterfaceField(source, interfaceName, fieldName, fieldSource) {
+  const interfacePattern = new RegExp(`(export\\s+interface\\s+${escapeRegex(interfaceName)}\\s*\\{\\r?\\n)([\\s\\S]*?)(\\r?\\n\\})`, "u");
+  return source.replace(interfacePattern, (match, start, body, end) => {
+    if (new RegExp(`^[ 	]*${escapeRegex(fieldName)}\\??:`, "mu").test(body)) {
+      return match;
+    }
+    const lineEnding = start.endsWith(`\r
+`) ? `\r
+` : `
+`;
+    const formattedFieldSource = `${fieldSource.replace(/\r?\n$/u, "").split(`
+`).join(lineEnding)}${lineEnding}`;
+    const memberPattern = /^[ \t]*([A-Za-z_$][\w$]*)\??:/gmu;
+    for (const member of body.matchAll(memberPattern)) {
+      const memberIndex = member.index;
+      const memberName = member[1];
+      if (memberIndex === undefined || !memberName) {
+        continue;
+      }
+      if (memberName.localeCompare(fieldName) > 0) {
+        return `${start}${body.slice(0, memberIndex)}${formattedFieldSource}${body.slice(memberIndex)}${end}`;
+      }
+    }
+    return `${start}${body}${body.length > 0 && !body.endsWith(lineEnding) ? lineEnding : ""}${formattedFieldSource}${end}`;
+  });
+}
 function updateWorkspaceInventorySource(source, {
   blockEntries = [],
   bindingSourceEntries = [],
+  abilityEntries = [],
+  aiFeatureEntries = [],
   editorPluginEntries = [],
   patternEntries = [],
   restResourceEntries = [],
@@ -171642,6 +171825,10 @@ function updateWorkspaceInventorySource(source, {
   nextSource = appendEntriesAtMarker(nextSource, PATTERN_CONFIG_ENTRY_MARKER, patternEntries);
   nextSource = appendEntriesAtMarker(nextSource, BINDING_SOURCE_CONFIG_ENTRY_MARKER, bindingSourceEntries);
   nextSource = appendEntriesAtMarker(nextSource, REST_RESOURCE_CONFIG_ENTRY_MARKER, restResourceEntries);
+  nextSource = appendEntriesAtMarker(nextSource, ABILITY_CONFIG_ENTRY_MARKER, abilityEntries);
+  nextSource = appendEntriesAtMarker(nextSource, AI_FEATURE_CONFIG_ENTRY_MARKER, aiFeatureEntries);
+  nextSource = ensureInterfaceField(nextSource, "WorkspaceAbilityConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
+  nextSource = ensureInterfaceField(nextSource, "WorkspaceAiFeatureConfig", "compatibility", WORKSPACE_COMPATIBILITY_CONFIG_FIELD);
   nextSource = appendEntriesAtMarker(nextSource, EDITOR_PLUGIN_CONFIG_ENTRY_MARKER, editorPluginEntries);
   return nextSource;
 }
@@ -171654,6 +171841,6 @@ async function appendWorkspaceInventoryEntries(projectDir, options) {
   }
 }
 
-export { HOOKED_BLOCK_POSITION_SET, HOOKED_BLOCK_ANCHOR_PATTERN, toKebabCase, toSnakeCase, toPascalCase, toSegmentPascalCase, toTitleCase, validateBlockSlug, validateNamespace, normalizeBlockSlug, resolveNonEmptyNormalizedBlockSlug, buildBlockCssClassName, buildFrontendCssClassName, resolveScaffoldIdentifiers, ADD_KIND_IDS, REST_RESOURCE_METHOD_IDS, EDITOR_PLUGIN_SLOT_IDS, ADD_BLOCK_TEMPLATE_IDS, REST_RESOURCE_NAMESPACE_PATTERN, assertValidGeneratedSlug, resolveRestResourceNamespace, assertValidRestResourceMethods, assertValidHookedBlockPosition, getWorkspaceBootstrapPath, buildWorkspacePhpPrefix, isAddBlockTemplateId, quoteTsString, patchFile, readOptionalFile, snapshotWorkspaceFiles, rollbackWorkspaceMutation, resolveWorkspaceBlock, assertValidHookAnchor, assertValidEditorPluginSlot, readWorkspaceBlockJson, getMutableBlockHooks, assertVariationDoesNotExist, assertPatternDoesNotExist, assertBindingSourceDoesNotExist, assertRestResourceDoesNotExist, assertEditorPluginDoesNotExist, formatAddHelpText, readWorkspaceInventory, getWorkspaceBlockSelectOptions, appendWorkspaceInventoryEntries };
+export { HOOKED_BLOCK_POSITION_SET, HOOKED_BLOCK_ANCHOR_PATTERN, toKebabCase, toSnakeCase, toPascalCase, toSegmentPascalCase, toTitleCase, validateBlockSlug, validateNamespace, normalizeBlockSlug, resolveNonEmptyNormalizedBlockSlug, buildBlockCssClassName, buildFrontendCssClassName, resolveScaffoldIdentifiers, ADD_KIND_IDS, REST_RESOURCE_METHOD_IDS, EDITOR_PLUGIN_SLOT_IDS, ADD_BLOCK_TEMPLATE_IDS, REST_RESOURCE_NAMESPACE_PATTERN, assertValidGeneratedSlug, resolveRestResourceNamespace, assertValidRestResourceMethods, assertValidHookedBlockPosition, getWorkspaceBootstrapPath, buildWorkspacePhpPrefix, isAddBlockTemplateId, quoteTsString, patchFile, readOptionalFile, snapshotWorkspaceFiles, rollbackWorkspaceMutation, resolveWorkspaceBlock, assertValidHookAnchor, assertValidEditorPluginSlot, readWorkspaceBlockJson, getMutableBlockHooks, assertVariationDoesNotExist, assertPatternDoesNotExist, assertBindingSourceDoesNotExist, assertRestResourceDoesNotExist, assertAbilityDoesNotExist, assertAiFeatureDoesNotExist, assertEditorPluginDoesNotExist, formatAddHelpText, readWorkspaceInventory, getWorkspaceBlockSelectOptions, appendWorkspaceInventoryEntries };
 
-//# debugId=E5512AA4DE4BAC6564756E2164756E21
+//# debugId=42AF31D5CC3A7C2364756E2164756E21

package/dist-bunli/{cli-32rf304y.js → cli-8rnhjvb8.js}

@@ -4,7 +4,7 @@ import {
 } from "./cli-tesygdnr.js";
 import {
   seedProjectMigrations
-} from "./cli-qpt5dt0x.js";
+} from "./cli-2rev5hqm.js";
 import {
   ensureMigrationDirectories,
   isPlainObject,
@@ -59,7 +59,7 @@ import {
   toTitleCase,
   validateBlockSlug,
   validateNamespace
-} from "./cli-rg481yks.js";
+} from "./cli-3w3qxq9w.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -11427,6 +11427,268 @@ async function resolveTemplateSource(templateId, cwd, variables, variant) {
   }
 }
 
+// ../wp-typia-project-tools/src/runtime/ai-feature-capability.ts
+var AI_FEATURE_DEFINITIONS = {
+  wordpressAiClient: {
+    description: "WordPress 7.0 AI Client surface used by AI-capable feature endpoints.",
+    id: "wordpress-ai-client",
+    label: "WordPress AI Client",
+    minimumVersions: {
+      wordpress: "7.0"
+    },
+    runtimeGates: [
+      {
+        kind: "wordpress-core-feature",
+        value: "WordPress AI Client"
+      }
+    ]
+  },
+  wordpressCoreAbilities: {
+    description: "Client-side ability discovery surface for editor and admin flows.",
+    id: "wordpress-core-abilities",
+    label: "@wordpress/core-abilities",
+    minimumVersions: {
+      wordpress: "7.0"
+    },
+    runtimeGates: [
+      {
+        kind: "script-package",
+        value: "@wordpress/core-abilities"
+      }
+    ]
+  },
+  wordpressMcpPublicMetadata: {
+    description: "Optional MCP exposure metadata consumed by a separate adapter path rather than core alone.",
+    id: "wordpress-mcp-public-metadata",
+    label: "MCP public metadata",
+    runtimeGates: [
+      {
+        kind: "adapter",
+        value: "MCP adapter"
+      }
+    ]
+  },
+  wordpressServerAbilities: {
+    description: "Server-side ability registration and execution surface for WordPress-native abilities.",
+    id: "wordpress-server-abilities",
+    label: "WordPress Abilities API",
+    minimumVersions: {
+      wordpress: "6.9"
+    },
+    runtimeGates: [
+      {
+        kind: "php-function",
+        value: "wp_register_ability"
+      },
+      {
+        kind: "php-function",
+        value: "wp_register_ability_category"
+      }
+    ]
+  }
+};
+var DEFAULT_AI_FEATURE_REGISTRY = Object.values(AI_FEATURE_DEFINITIONS).reduce((accumulator, definition) => {
+  accumulator[definition.id] = definition;
+  return accumulator;
+}, {});
+function parseVersionFloorParts(value) {
+  return value.split(".").map((part, index) => {
+    if (!/^\d+$/.test(part)) {
+      throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
+    }
+    return Number.parseInt(part, 10);
+  });
+}
+function compareVersionFloors(left, right) {
+  const leftParts = parseVersionFloorParts(left);
+  const rightParts = parseVersionFloorParts(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0;index < length; index += 1) {
+    const leftValue = leftParts[index] ?? 0;
+    const rightValue = rightParts[index] ?? 0;
+    if (leftValue > rightValue) {
+      return 1;
+    }
+    if (leftValue < rightValue) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function pickHigherVersionFloor(current, candidate) {
+  if (!candidate) {
+    return current;
+  }
+  if (!current) {
+    return candidate;
+  }
+  return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
+}
+function normalizeSelections(selections) {
+  const normalized = new Map;
+  for (const selection of selections) {
+    const current = normalized.get(selection.featureId);
+    if (!current || selection.mode === "required") {
+      normalized.set(selection.featureId, selection);
+    }
+  }
+  return [...normalized.values()];
+}
+function resolveAiFeatureCapabilityPlan(selections, registry = DEFAULT_AI_FEATURE_REGISTRY) {
+  const requiredFeatures = [];
+  const optionalFeatures = [];
+  let wordpress;
+  let php;
+  for (const selection of normalizeSelections(selections)) {
+    const definition = registry[selection.featureId];
+    if (!definition) {
+      throw new Error(`Unknown AI feature capability "${selection.featureId}".`);
+    }
+    const resolvedDefinition = {
+      ...definition,
+      mode: selection.mode
+    };
+    if (selection.mode === "required") {
+      requiredFeatures.push(resolvedDefinition);
+      wordpress = pickHigherVersionFloor(wordpress, definition.minimumVersions?.wordpress);
+      php = pickHigherVersionFloor(php, definition.minimumVersions?.php);
+      continue;
+    }
+    optionalFeatures.push(resolvedDefinition);
+  }
+  return {
+    hardMinimums: {
+      ...php ? { php } : {},
+      ...wordpress ? { wordpress } : {}
+    },
+    optionalFeatures,
+    requiredFeatures
+  };
+}
+
+// ../wp-typia-project-tools/src/runtime/scaffold-compatibility.ts
+var DEFAULT_SCAFFOLD_COMPATIBILITY = {
+  requiresAtLeast: "6.7",
+  requiresPhp: "8.0",
+  testedUpTo: "6.9"
+};
+var OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY = [
+  {
+    featureId: AI_FEATURE_DEFINITIONS.wordpressAiClient.id,
+    mode: "optional"
+  }
+];
+var REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY = [
+  {
+    featureId: AI_FEATURE_DEFINITIONS.wordpressServerAbilities.id,
+    mode: "required"
+  },
+  {
+    featureId: AI_FEATURE_DEFINITIONS.wordpressCoreAbilities.id,
+    mode: "required"
+  }
+];
+function parseVersionFloorParts2(value) {
+  return value.split(".").map((part, index) => {
+    if (!/^\d+$/u.test(part)) {
+      throw new Error(`parseVersionFloorParts received an invalid version floor "${value}" at segment ${index + 1}.`);
+    }
+    return Number.parseInt(part, 10);
+  });
+}
+function compareVersionFloors2(left, right) {
+  const leftParts = parseVersionFloorParts2(left);
+  const rightParts = parseVersionFloorParts2(right);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0;index < length; index += 1) {
+    const leftValue = leftParts[index] ?? 0;
+    const rightValue = rightParts[index] ?? 0;
+    if (leftValue > rightValue) {
+      return 1;
+    }
+    if (leftValue < rightValue) {
+      return -1;
+    }
+  }
+  return 0;
+}
+function pickHigherVersionFloor2(current, candidate) {
+  if (!candidate) {
+    return current;
+  }
+  return compareVersionFloors2(current, candidate) >= 0 ? current : candidate;
+}
+function pickHigherHeaderVersionFloor(policyValue, currentValue) {
+  const normalizedCurrentValue = currentValue.trim();
+  if (!normalizedCurrentValue) {
+    return policyValue;
+  }
+  try {
+    return pickHigherVersionFloor2(policyValue, normalizedCurrentValue);
+  } catch {
+    return policyValue;
+  }
+}
+function formatRuntimeGate(feature) {
+  return (feature.runtimeGates ?? []).map((gate) => `${feature.label}: ${gate.kind} ${gate.value}`);
+}
+function getPolicyMode(capabilityPlan) {
+  if (capabilityPlan.requiredFeatures.length > 0) {
+    return "required";
+  }
+  if (capabilityPlan.optionalFeatures.length > 0) {
+    return "optional";
+  }
+  return "baseline";
+}
+function resolveScaffoldCompatibilityPolicy(selections, {
+  baseline = DEFAULT_SCAFFOLD_COMPATIBILITY
+} = {}) {
+  const capabilityPlan = resolveAiFeatureCapabilityPlan(selections);
+  const requiresAtLeast = pickHigherVersionFloor2(baseline.requiresAtLeast, capabilityPlan.hardMinimums.wordpress);
+  const requiresPhp = pickHigherVersionFloor2(baseline.requiresPhp, capabilityPlan.hardMinimums.php);
+  const testedUpTo = pickHigherVersionFloor2(baseline.testedUpTo, requiresAtLeast);
+  return {
+    capabilityPlan,
+    pluginHeader: {
+      requiresAtLeast,
+      requiresPhp,
+      testedUpTo
+    }
+  };
+}
+function createScaffoldCompatibilityConfig(policy) {
+  const { capabilityPlan } = policy;
+  return {
+    hardMinimums: capabilityPlan.hardMinimums,
+    mode: getPolicyMode(capabilityPlan),
+    optionalFeatures: capabilityPlan.optionalFeatures.map((feature) => feature.label),
+    requiredFeatures: capabilityPlan.requiredFeatures.map((feature) => feature.label),
+    runtimeGates: [
+      ...capabilityPlan.requiredFeatures.flatMap(formatRuntimeGate),
+      ...capabilityPlan.optionalFeatures.flatMap(formatRuntimeGate)
+    ]
+  };
+}
+function renderScaffoldCompatibilityConfig(policy, indent = "\t\t") {
+  const config = createScaffoldCompatibilityConfig(policy);
+  return JSON.stringify(config, null, "\t").split(`
+`).map((line, index) => index === 0 ? line : `${indent}${line}`).join(`
+`);
+}
+function replacePluginHeaderVersionFloor(source, pattern, policyValue) {
+  return source.replace(pattern, (_match, prefix, currentValue, lineEnding) => {
+    const versionPrefix = prefix.endsWith(":") ? `${prefix} ` : prefix;
+    return `${versionPrefix}${pickHigherHeaderVersionFloor(policyValue, currentValue)}${lineEnding}`;
+  });
+}
+function updatePluginHeaderCompatibility(source, policy) {
+  const { pluginHeader } = policy;
+  const nextSource = replacePluginHeaderVersionFloor(source, /(\* Requires at least:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.requiresAtLeast);
+  const nextSourceWithTestedUpTo = replacePluginHeaderVersionFloor(nextSource, /(\* Tested up to:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.testedUpTo);
+  return replacePluginHeaderVersionFloor(nextSourceWithTestedUpTo, /(\* Requires PHP:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.requiresPhp);
+}
+
 // ../wp-typia-project-tools/src/runtime/block-generator-service-spec.ts
 function getBuiltInPersistenceSpec({
   templateId,
@@ -11556,6 +11818,7 @@ function buildTemplateVariablesFromBlockSpec(spec) {
   const dataStorageMode = persistenceEnabled ? spec.persistence.dataStorageMode : "custom-table";
   const persistencePolicy = persistenceEnabled ? spec.persistence.persistencePolicy : "authenticated";
   const queryVariationNamespace = `${namespace}/${slug}`;
+  const compatibility = resolveScaffoldCompatibilityPolicy([]);
   const flatVariables = {
     alternateRenderTargetsCsv: formatAlternateRenderTargets(alternateRenderTargets),
     alternateRenderTargetsJson: JSON.stringify(alternateRenderTargets),
@@ -11583,6 +11846,9 @@ function buildTemplateVariablesFromBlockSpec(spec) {
     hasAlternateMjmlRenderTarget: hasAlternateMjmlRenderTarget ? "true" : "false",
     hasAlternatePlainTextRenderTarget: hasAlternatePlainTextRenderTarget ? "true" : "false",
     hasAlternateRenderTargets: alternateRenderTargets.length > 0 ? "true" : "false",
+    requiresAtLeast: compatibility.pluginHeader.requiresAtLeast,
+    requiresPhp: compatibility.pluginHeader.requiresPhp,
+    testedUpTo: compatibility.pluginHeader.testedUpTo,
     projectToolsPackageVersion,
     cssClassName,
     dashCase: slug,
@@ -11626,6 +11892,7 @@ function buildTemplateVariablesFromBlockSpec(spec) {
     author: spec.project.author,
     blockMetadataVersion: BUILTIN_BLOCK_METADATA_VERSION,
     category: spec.metadata.category,
+    compatibility: compatibility.pluginHeader,
     cssClassName,
     description: spec.metadata.description,
     descriptionJson: flatVariables.descriptionJson,
@@ -15924,6 +16191,7 @@ function getTemplateVariables(templateId, answers) {
   const compoundPersistenceEnabled = templateId === "persistence" ? true : templateId === "compound" ? Boolean(answers.dataStorageMode || answers.persistencePolicy) : false;
   const dataStorageMode = templateId === "persistence" || compoundPersistenceEnabled ? answers.dataStorageMode ?? "custom-table" : "custom-table";
   const persistencePolicy = templateId === "persistence" || compoundPersistenceEnabled ? answers.persistencePolicy ?? "authenticated" : "authenticated";
+  const compatibility = resolveScaffoldCompatibilityPolicy([]);
   const flatVariables = {
     alternateRenderTargetsCsv: "",
     alternateRenderTargetsJson: "[]",
@@ -15952,6 +16220,8 @@ function getTemplateVariables(templateId, answers) {
     hasAlternatePlainTextRenderTarget: "false",
     hasAlternateRenderTargets: "false",
     projectToolsPackageVersion,
+    requiresAtLeast: compatibility.pluginHeader.requiresAtLeast,
+    requiresPhp: compatibility.pluginHeader.requiresPhp,
     cssClassName,
     dataStorageMode,
     dashCase: slug,
@@ -15975,6 +16245,7 @@ function getTemplateVariables(templateId, answers) {
     phpPrefix,
     phpPrefixUpper,
     restPackageVersion,
+    testedUpTo: compatibility.pluginHeader.testedUpTo,
     publicWriteRequestIdDeclaration: persistencePolicy === "public" ? "publicWriteRequestId: string & tags.MinLength< 1 > & tags.MaxLength< 128 >;" : "publicWriteRequestId?: string & tags.MinLength< 1 > & tags.MaxLength< 128 >;",
     restWriteAuthIntent: persistencePolicy === "public" ? "public-write-protected" : "authenticated",
     restWriteAuthMechanism: persistencePolicy === "public" ? "public-signed-token" : "rest-nonce",
@@ -16015,6 +16286,7 @@ function getTemplateVariables(templateId, answers) {
       author: answers.author.trim(),
       blockMetadataVersion: BUILTIN_BLOCK_METADATA_VERSION,
       category: metadataDefaults?.category ?? template?.defaultCategory ?? "widgets",
+      compatibility: compatibility.pluginHeader,
       cssClassName,
       description,
       descriptionJson: JSON.stringify(description),
@@ -16285,6 +16557,6 @@ async function resolveOptionalInteractiveExternalLayerId({
   }
 }
 
-export { syncPersistenceRestArtifacts, copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, getPrimaryDevelopmentScript, getOptionalOnboardingSteps, getOptionalOnboardingNote, getOptionalOnboardingShortNote, formatNonEmptyTargetDirectoryError, parseTemplateLocator, resolveExternalTemplateLayers, resolveTemplateSeed, normalizeOptionalCliString, resolveLocalCliPathOption, assertExternalLayerCompositionOptions, assertBuiltInTemplateVariantAllowed, parseAlternateRenderTargets, parseCompoundInnerBlocksPreset, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
+export { syncPersistenceRestArtifacts, copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, getPrimaryDevelopmentScript, getOptionalOnboardingSteps, getOptionalOnboardingNote, getOptionalOnboardingShortNote, formatNonEmptyTargetDirectoryError, parseTemplateLocator, resolveExternalTemplateLayers, resolveTemplateSeed, normalizeOptionalCliString, resolveLocalCliPathOption, assertExternalLayerCompositionOptions, assertBuiltInTemplateVariantAllowed, parseAlternateRenderTargets, parseCompoundInnerBlocksPreset, OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY, REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, renderScaffoldCompatibilityConfig, updatePluginHeaderCompatibility, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
 
-//# debugId=C62257CB4F3F0AF464756E2164756E21
+//# debugId=287134A8F6F7F6FD64756E2164756E21