wp-typia 0.22.2 → 0.22.4

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

@@ -21,7 +21,7 @@ import {
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-kww2sraq.js";
+} from "./cli-6ymn63t4.js";
 import {
   DEFAULT_WORDPRESS_ABILITIES_VERSION,
   DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
@@ -34,17 +34,20 @@ import {
 } from "./cli-1sm60g1z.js";
 import {
   snapshotProjectVersion
-} from "./cli-6hcbjvym.js";
+} from "./cli-2mt6bvcj.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
   writeInitialMigrationScaffold,
   writeMigrationConfig
-} from "./cli-gcbre1zs.js";
+} from "./cli-hb9vpsev.js";
 import"./cli-bq2v559b.js";
 import {
-  formatInstallCommand
-} from "./cli-sj5mtyzj.js";
+  findExecutablePatternMatch,
+  hasExecutablePattern,
+  hasUncommentedPattern,
+  maskTypeScriptCommentsAndLiterals
+} from "./cli-rwjkqjhs.js";
 import"./cli-10pe4mf8.js";
 import {
   SHARED_WORKSPACE_TEMPLATE_ROOT
@@ -58,6 +61,8 @@ import {
   assertAdminViewDoesNotExist,
   assertAiFeatureDoesNotExist,
   assertBindingSourceDoesNotExist,
+  assertBlockStyleDoesNotExist,
+  assertBlockTransformDoesNotExist,
   assertEditorPluginDoesNotExist,
   assertPatternDoesNotExist,
   assertRestResourceDoesNotExist,
@@ -95,7 +100,7 @@ import {
   toPascalCase,
   toSnakeCase,
   toTitleCase
-} from "./cli-smzkbfna.js";
+} from "./cli-qr2ek735.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -105,7 +110,10 @@ import {
 } from "./cli-p95wr1q8.js";
 import {
   resolveWorkspaceProject
-} from "./cli-pd5pqgre.js";
+} from "./cli-btbpt84c.js";
+import {
+  formatInstallCommand
+} from "./cli-6bhfzq5e.js";
 import {
   __reExport,
   __toESM
@@ -1863,6 +1871,67 @@ add_action( 'admin_enqueue_scripts', '${enqueueFunctionName}' );
 `;
 }
 
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-mutation.ts
+var DEFAULT_PHP_SNIPPET_INSERTION_ANCHORS = [
+  /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
+  /\?>\s*$/u
+];
+
+class WorkspaceMutationRollbackError extends Error {
+  mutationError;
+  rollbackError;
+  constructor(mutationError, rollbackError) {
+    super("Workspace mutation failed and rollback also failed.");
+    this.name = "WorkspaceMutationRollbackError";
+    this.mutationError = mutationError;
+    this.rollbackError = rollbackError;
+  }
+}
+async function executeWorkspaceMutationPlan({
+  filePaths,
+  run,
+  snapshotDirs = [],
+  targetPaths = []
+}) {
+  const mutationSnapshot = {
+    fileSources: await snapshotWorkspaceFiles(filePaths),
+    snapshotDirs: [...snapshotDirs],
+    targetPaths: [...targetPaths]
+  };
+  try {
+    return await run();
+  } catch (error) {
+    try {
+      await rollbackWorkspaceMutation(mutationSnapshot);
+    } catch (rollbackError) {
+      throw new WorkspaceMutationRollbackError(error, rollbackError);
+    }
+    throw error;
+  }
+}
+function insertPhpSnippetBeforeWorkspaceAnchors(source, snippet) {
+  for (const anchor of DEFAULT_PHP_SNIPPET_INSERTION_ANCHORS) {
+    const candidate = source.replace(anchor, (match) => `${snippet}
+${match}`);
+    if (candidate !== source) {
+      return candidate;
+    }
+  }
+  return `${source.trimEnd()}
+${snippet}
+`;
+}
+function appendPhpSnippetBeforeClosingTag(source, snippet) {
+  const closingTagPattern = /\?>\s*$/u;
+  if (closingTagPattern.test(source)) {
+    return source.replace(closingTagPattern, `${snippet}
+?>`);
+  }
+  return `${source.trimEnd()}
+${snippet}
+`;
+}
+
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
 function detectJsonIndent(source) {
   const indentMatch = /\n([ \t]+)"/u.exec(source);
@@ -1926,36 +1995,8 @@ function ${loadFunctionName}() {
 	}
 }
 `;
-    const insertionAnchors = [
-      /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-      /\?>\s*$/u
-    ];
-    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(nextSource, loadFunctionName)) {
-      insertPhpSnippet(loadFunction);
+      nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, loadFunction);
     } else {
       const functionRange = findPhpFunctionRange(nextSource, loadFunctionName);
       const functionSource = functionRange ? nextSource.slice(functionRange.start, functionRange.end) : "";
@@ -1968,7 +2009,7 @@ ${snippet}
       }
     }
     if (!loadHookPattern.test(nextSource)) {
-      appendPhpSnippet(loadHook);
+      nextSource = appendPhpSnippetBeforeClosingTag(nextSource, loadHook);
     }
     return nextSource;
   });
@@ -2091,42 +2132,38 @@ async function scaffoldAdminViewWorkspace(options) {
   const adminViewsIndexPath = resolveAdminViewRegistryPath(workspace.projectDir);
   const adminViewDir = path5.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
   const adminViewPhpPath = path5.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
-  const mutationSnapshot = {
-    fileSources: await snapshotWorkspaceFiles([
+  await executeWorkspaceMutationPlan({
+    filePaths: [
       adminViewsIndexPath,
       blockConfigPath,
       bootstrapPath,
       buildScriptPath,
       packageJsonPath,
       webpackConfigPath
-    ]),
-    snapshotDirs: [],
-    targetPaths: [adminViewDir, adminViewPhpPath]
-  };
-  try {
-    await fsp3.mkdir(adminViewDir, { recursive: true });
-    await fsp3.mkdir(path5.dirname(adminViewPhpPath), { recursive: true });
-    await ensureAdminViewPackageDependencies(workspace, parsedSource);
-    await ensureAdminViewBootstrapAnchors(workspace);
-    await ensureAdminViewBuildScriptAnchors(workspace);
-    await ensureAdminViewWebpackAnchors(workspace);
-    await fsp3.writeFile(path5.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
-    await fsp3.writeFile(path5.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
-    await fsp3.writeFile(path5.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
-    await fsp3.writeFile(path5.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
-    await fsp3.writeFile(path5.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
-    await fsp3.writeFile(path5.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
-    await fsp3.writeFile(adminViewPhpPath, buildAdminViewPhpSource(adminViewSlug, workspace), "utf8");
-    await writeAdminViewRegistry(workspace.projectDir, adminViewSlug);
-    await appendWorkspaceInventoryEntries(workspace.projectDir, {
-      adminViewEntries: [
-        buildAdminViewConfigEntry(adminViewSlug, parsedSource)
-      ]
-    });
-  } catch (error) {
-    await rollbackWorkspaceMutation(mutationSnapshot);
-    throw error;
-  }
+    ],
+    targetPaths: [adminViewDir, adminViewPhpPath],
+    run: async () => {
+      await fsp3.mkdir(adminViewDir, { recursive: true });
+      await fsp3.mkdir(path5.dirname(adminViewPhpPath), { recursive: true });
+      await ensureAdminViewPackageDependencies(workspace, parsedSource);
+      await ensureAdminViewBootstrapAnchors(workspace);
+      await ensureAdminViewBuildScriptAnchors(workspace);
+      await ensureAdminViewWebpackAnchors(workspace);
+      await fsp3.writeFile(path5.join(adminViewDir, "types.ts"), buildAdminViewTypesSource(adminViewSlug, restResource, coreDataSource), "utf8");
+      await fsp3.writeFile(path5.join(adminViewDir, "config.ts"), buildAdminViewConfigSource(adminViewSlug, workspace.workspace.textDomain, parsedSource, restResource), "utf8");
+      await fsp3.writeFile(path5.join(adminViewDir, "data.ts"), coreDataSource ? buildCoreDataAdminViewDataSource(adminViewSlug, coreDataSource) : restResource ? buildRestAdminViewDataSource(adminViewSlug, restResource) : buildDefaultAdminViewDataSource(adminViewSlug), "utf8");
+      await fsp3.writeFile(path5.join(adminViewDir, "Screen.tsx"), coreDataSource ? buildCoreDataAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain) : buildAdminViewScreenSource(adminViewSlug, workspace.workspace.textDomain), "utf8");
+      await fsp3.writeFile(path5.join(adminViewDir, "index.tsx"), buildAdminViewEntrySource(adminViewSlug), "utf8");
+      await fsp3.writeFile(path5.join(adminViewDir, "style.scss"), buildAdminViewStyleSource(), "utf8");
+      await fsp3.writeFile(adminViewPhpPath, buildAdminViewPhpSource(adminViewSlug, workspace), "utf8");
+      await writeAdminViewRegistry(workspace.projectDir, adminViewSlug);
+      await appendWorkspaceInventoryEntries(workspace.projectDir, {
+        adminViewEntries: [
+          buildAdminViewConfigEntry(adminViewSlug, parsedSource)
+        ]
+      });
+    }
+  });
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view.ts
@@ -2377,8 +2414,10 @@ registerBlockBindingsSource( {
 `;
 }
 function resolveBindingTarget(options, namespace) {
-  const hasBlock = options.blockName !== undefined && options.blockName.trim().length > 0;
-  const hasAttribute = options.attributeName !== undefined && options.attributeName.trim().length > 0;
+  const blockName = normalizeOptionalCliString(options.blockName);
+  const attributeName = normalizeOptionalCliString(options.attributeName);
+  const hasBlock = blockName !== undefined;
+  const hasAttribute = attributeName !== undefined;
   if (!hasBlock && !hasAttribute) {
     return;
   }
@@ -2386,8 +2425,8 @@ function resolveBindingTarget(options, namespace) {
     throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
   }
   return {
-    attributeName: assertValidBindingAttributeName(options.attributeName ?? ""),
-    blockSlug: resolveBindingTargetBlockSlug(options.blockName ?? "", namespace)
+    attributeName: assertValidBindingAttributeName(attributeName ?? ""),
+    blockSlug: resolveBindingTargetBlockSlug(blockName ?? "", namespace)
   };
 }
 function formatBindingAttributeTypeMember(attributeName) {
@@ -4367,12 +4406,14 @@ async function runAddRestResourceCommand({
     throw error;
   }
 }
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
 var import_semver = __toESM(require_semver(), 1);
 import fs5 from "fs";
 import { promises as fsp6 } from "fs";
 import path10 from "path";
 import { syncTypeSchemas as syncTypeSchemas2 } from "@wp-typia/block-runtime/metadata-core";
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-types.ts
 var ABILITY_SERVER_GLOB = "/inc/abilities/*.php";
 var ABILITY_EDITOR_SCRIPT = "build/abilities/index.js";
 var ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php";
@@ -4380,17 +4421,8 @@ 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_MODULE_ID = "@wordpress/abilities";
 var WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
-function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
-  if (!existingVersion) {
-    return requiredVersion;
-  }
-  const existingMinimum = import_semver.default.minVersion(existingVersion);
-  const requiredMinimum = import_semver.default.minVersion(requiredVersion);
-  if (!existingMinimum || !requiredMinimum) {
-    return requiredVersion;
-  }
-  return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
-}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-templates.ts
 function toAbilityCategorySlug(workspaceNamespace) {
   const normalizedNamespace = workspaceNamespace.replace(/[^a-z0-9-]+/gu, "-").replace(/-{2,}/gu, "-").replace(/^-|-$/gu, "");
   return `${normalizedNamespace || "workspace"}-workflows`;
@@ -4855,6 +4887,19 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `).concat(`
 `);
 }
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
+function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
+  if (!existingVersion) {
+    return requiredVersion;
+  }
+  const existingMinimum = import_semver.default.minVersion(existingVersion);
+  const requiredMinimum = import_semver.default.minVersion(requiredVersion);
+  if (!existingMinimum || !requiredMinimum) {
+    return requiredVersion;
+  }
+  return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
+}
 function resolveAbilityRegistryPath(projectDir) {
   const abilitiesDir = path10.join(projectDir, "src", "abilities");
   return [path10.join(abilitiesDir, "index.ts"), path10.join(abilitiesDir, "index.js")].find((candidatePath) => fs5.existsSync(candidatePath)) ?? path10.join(abilitiesDir, "index.ts");
@@ -4950,50 +4995,22 @@ function ${enqueueFunctionName}() {
 	);
 }
 `;
-    const insertionAnchors = [
-      /add_action\(\s*["']init["']\s*,\s*["'][^"']+_load_textdomain["']\s*\);\s*\n/u,
-      /\?>\s*$/u
-    ];
-    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(nextSource, loadFunctionName)) {
-      insertPhpSnippet(loadFunction);
+      nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, loadFunction);
     }
     if (!hasPhpFunctionDefinition(nextSource, enqueueFunctionName)) {
-      insertPhpSnippet(enqueueFunction);
+      nextSource = insertPhpSnippetBeforeWorkspaceAnchors(nextSource, enqueueFunction);
     } else if (!findPhpFunctionRange(nextSource, enqueueFunctionName)?.source.includes("wp_enqueue_script_module")) {
       nextSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction, { trimReplacementStart: true }) ?? nextSource;
     }
     if (!nextSource.includes(loadHook)) {
-      appendPhpSnippet(loadHook);
+      nextSource = appendPhpSnippetBeforeClosingTag(nextSource, loadHook);
     }
     if (!nextSource.includes(adminEnqueueHook)) {
-      appendPhpSnippet(adminEnqueueHook);
+      nextSource = appendPhpSnippetBeforeClosingTag(nextSource, adminEnqueueHook);
     }
     if (!nextSource.includes(editorEnqueueHook)) {
-      appendPhpSnippet(editorEnqueueHook);
+      nextSource = appendPhpSnippetBeforeClosingTag(nextSource, editorEnqueueHook);
     }
     return nextSource;
   });
@@ -5066,21 +5083,29 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     }
     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")) {
+    if (!match || !/['"]src\/bindings\/index\.(?:ts|js)['"]/u.test(match[2]) || !/['"]src\/editor-plugins\/index\.(?:tsx|ts|js)['"]/u.test(match[2])) {
       throw new Error([
         `ensureAbilityBuildScriptAnchors could not patch ${path10.basename(buildScriptPath)}.`,
         "Missing the expected shared editor entries array in scripts/build-workspace.mjs.",
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    nextSource = nextSource.replace(sharedEntriesPattern, `$1
-		'src/bindings/index.ts',
-		'src/bindings/index.js',
-		'src/editor-plugins/index.ts',
-		'src/editor-plugins/index.js',
-		'src/abilities/index.ts',
-		'src/abilities/index.js',
-	$3`);
+    nextSource = nextSource.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      const missingAbilityEntries = [
+        "'src/abilities/index.ts'",
+        "'src/abilities/index.js'"
+      ].filter((entry) => !sharedEntries.includes(entry));
+      if (missingAbilityEntries.length === 0) {
+        return fullMatch;
+      }
+      const itemIndent = sharedEntries.match(/\n([ \t]*)['"]/u)?.[1] ?? "\t\t";
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const nextEntries = `${trimmedEntries}${separator}` + missingAbilityEntries.map((entry) => `
+${itemIndent}${entry},`).join("") + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
     return nextSource;
   });
 }
@@ -5109,8 +5134,7 @@ async function ensureAbilityWebpackAnchors(workspace) {
 			entries.push( [ entryName, entryPath ] );
 			break;
 		}
-	}
-$2`);
+	}$2`);
     }
     const sharedEntriesPattern = /for\s*\(\s*const\s+\[\s*entryName\s*,\s*candidates\s*\]\s+of\s+\[([\s\S]*?)\]\s*\)\s*\{/u;
     const match = source.match(sharedEntriesPattern);
@@ -5121,31 +5145,33 @@ $2`);
         "Restore the generated template or wire abilities/index manually before retrying."
       ].join(" "));
     }
-    return source.replace(sharedEntriesPattern, `for ( const [ entryName, candidates ] of [
-		[
-			'bindings/index',
-			[ 'src/bindings/index.ts', 'src/bindings/index.js' ],
-		],
-		[
-			'editor-plugins/index',
-			[ 'src/editor-plugins/index.ts', 'src/editor-plugins/index.js' ],
-		],
-		[
-			'abilities/index',
-			[ 'src/abilities/index.ts', 'src/abilities/index.js' ],
-		],
-	] ) {`);
+    return source.replace(sharedEntriesPattern, (fullMatch, sharedEntries) => {
+      if (/['"]abilities\/index['"]/u.test(sharedEntries)) {
+        return fullMatch;
+      }
+      const tupleIndent = sharedEntries.match(/\n([ \t]*)\[/u)?.[1] ?? "\t\t";
+      const nestedIndent = `${tupleIndent}	`;
+      const trimmedEntries = sharedEntries.replace(/\s*$/u, "");
+      const trailingWhitespace = sharedEntries.slice(trimmedEntries.length);
+      const separator = trimmedEntries.trimEnd().endsWith(",") ? "" : ",";
+      const abilityTuple = [
+        `${tupleIndent}[`,
+        `${nestedIndent}'abilities/index',`,
+        `${nestedIndent}[ 'src/abilities/index.ts', 'src/abilities/index.js' ],`,
+        `${tupleIndent}],`
+      ].join(`
+`);
+      const nextEntries = `${trimmedEntries}${separator}
+${abilityTuple}` + trailingWhitespace;
+      return fullMatch.replace(sharedEntries, nextEntries);
+    });
   });
 }
-async function runAddAbilityCommand({
-  abilityName,
-  cwd = process.cwd()
+async function scaffoldAbilityWorkspace({
+  abilitySlug,
+  compatibilityPolicy,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
   const blockConfigPath = path10.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const buildScriptPath = path10.join(workspace.projectDir, "scripts", "build-workspace.mjs");
@@ -5160,8 +5186,8 @@ async function runAddAbilityCommand({
   const dataFilePath = path10.join(abilityDir, "data.ts");
   const clientFilePath = path10.join(abilityDir, "client.ts");
   const phpFilePath = path10.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
-  const mutationSnapshot = {
-    fileSources: await snapshotWorkspaceFiles([
+  await executeWorkspaceMutationPlan({
+    filePaths: [
       blockConfigPath,
       bootstrapPath,
       buildScriptPath,
@@ -5170,52 +5196,67 @@ async function runAddAbilityCommand({
       syncProjectScriptPath,
       webpackConfigPath,
       abilitiesIndexPath
-    ]),
-    snapshotDirs: [],
-    targetPaths: [abilityDir, phpFilePath, syncAbilitiesScriptPath]
+    ],
+    targetPaths: [abilityDir, phpFilePath, syncAbilitiesScriptPath],
+    run: async () => {
+      await fsp6.mkdir(abilityDir, { recursive: true });
+      await fsp6.mkdir(path10.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 fsp6.writeFile(syncAbilitiesScriptPath, buildAbilitySyncScriptSource(), "utf8");
+      await fsp6.writeFile(configFilePath, buildAbilityConfigSource(abilitySlug, workspace.workspace.namespace), "utf8");
+      await fsp6.writeFile(typesFilePath, buildAbilityTypesSource(abilitySlug), "utf8");
+      await fsp6.writeFile(dataFilePath, buildAbilityDataSource(abilitySlug), "utf8");
+      await fsp6.writeFile(clientFilePath, buildAbilityClientSource(abilitySlug), "utf8");
+      await fsp6.writeFile(phpFilePath, buildAbilityPhpSource(abilitySlug, workspace), "utf8");
+      const pascalCase = toPascalCase(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)
+        ]
+      });
+    }
+  });
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
+async function runAddAbilityCommand({
+  abilityName,
+  cwd = process.cwd()
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
+  await scaffoldAbilityWorkspace({
+    abilitySlug,
+    compatibilityPolicy,
+    workspace
+  });
+  return {
+    abilitySlug,
+    projectDir: workspace.projectDir
   };
-  try {
-    await fsp6.mkdir(abilityDir, { recursive: true });
-    await fsp6.mkdir(path10.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 fsp6.writeFile(syncAbilitiesScriptPath, buildAbilitySyncScriptSource(), "utf8");
-    await fsp6.writeFile(configFilePath, buildAbilityConfigSource(abilitySlug, workspace.workspace.namespace), "utf8");
-    await fsp6.writeFile(typesFilePath, buildAbilityTypesSource(abilitySlug), "utf8");
-    await fsp6.writeFile(dataFilePath, buildAbilityDataSource(abilitySlug), "utf8");
-    await fsp6.writeFile(clientFilePath, buildAbilityClientSource(abilitySlug), "utf8");
-    await fsp6.writeFile(phpFilePath, buildAbilityPhpSource(abilitySlug, workspace), "utf8");
-    const pascalCase = toPascalCase(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
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-scaffold.ts
 import { promises as fsp8 } from "fs";
 import path13 from "path";
 
@@ -6072,7 +6113,7 @@ async function ensureAiFeatureSyncRestAnchors(workspace) {
   });
 }
 
-// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-templates.ts
 function buildAiFeaturePhpSource(aiFeatureSlug, namespace, phpPrefix, textDomain) {
   const aiFeatureTitle = toTitleCase(aiFeatureSlug);
   const aiFeaturePhpId = aiFeatureSlug.replace(/-/g, "_");
@@ -6113,6 +6154,8 @@ if ( ! defined( 'ABSPATH' ) ) {
  * - ${quotePhpString(adminNoticeMessageFilterHook)} filters the wp-admin notice shown when AI support is unavailable.
  * - ${quotePhpString(unavailableMessageFilterHook)} filters REST-facing unavailable messages by reason code.
  * - ${quotePhpString(telemetryFilterHook)} filters the response telemetry array before schema validation. Return a schema-compatible array.
+ *
+ * Compatibility note: this server-only endpoint avoids WordPress script-module enqueue APIs so older sites can load the generated feature file safely.
  */
 
 if ( ! function_exists( '${loadSchemaFunctionName}' ) ) {
@@ -6673,17 +6716,14 @@ add_action( 'admin_notices', '${adminNoticeFunctionName}' );
 add_action( 'rest_api_init', '${registerRoutesFunctionName}' );
 `;
 }
-async function runAddAiFeatureCommand({
-  aiFeatureName,
-  cwd = process.cwd(),
-  namespace
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-scaffold.ts
+async function scaffoldAiFeatureWorkspace({
+  aiFeatureSlug,
+  compatibilityPolicy,
+  namespace,
+  workspace
 }) {
-  const workspace = resolveWorkspaceProject(cwd);
-  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
-  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
-  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
-  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
   const blockConfigPath = path13.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const packageJsonPath = path13.join(workspace.projectDir, "package.json");
@@ -6696,69 +6736,88 @@ async function runAddAiFeatureCommand({
   const apiFilePath = path13.join(aiFeatureDir, "api.ts");
   const dataFilePath = path13.join(aiFeatureDir, "data.ts");
   const phpFilePath = path13.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
-  const mutationSnapshot = {
-    fileSources: await snapshotWorkspaceFiles([
+  return executeWorkspaceMutationPlan({
+    filePaths: [
       blockConfigPath,
       bootstrapPath,
       packageJsonPath,
       syncAiScriptPath,
       syncProjectScriptPath,
       syncRestScriptPath
-    ]),
-    snapshotDirs: [],
-    targetPaths: [aiFeatureDir, phpFilePath, syncAiScriptPath]
+    ],
+    targetPaths: [aiFeatureDir, phpFilePath, syncAiScriptPath],
+    run: async () => {
+      await fsp8.mkdir(aiFeatureDir, { recursive: true });
+      await fsp8.mkdir(path13.dirname(phpFilePath), { recursive: true });
+      await ensureAiFeatureBootstrapAnchors(workspace);
+      await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
+      const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
+      await ensureAiFeatureSyncProjectAnchors(workspace);
+      await ensureAiFeatureSyncRestAnchors(workspace);
+      await fsp8.writeFile(syncAiScriptPath, buildAiFeatureSyncScriptSource(), "utf8");
+      await fsp8.writeFile(typesFilePath, buildAiFeatureTypesSource(aiFeatureSlug), "utf8");
+      await fsp8.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
+      await fsp8.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
+      await fsp8.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
+      await fsp8.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, namespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
+      const pascalCase = toPascalCase(aiFeatureSlug);
+      await syncAiFeatureRestArtifacts({
+        clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
+        outputDir: path13.join("src", "ai-features", aiFeatureSlug),
+        projectDir: workspace.projectDir,
+        typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
+        validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
+        variables: {
+          namespace,
+          pascalCase,
+          slugKebabCase: aiFeatureSlug,
+          title: toTitleCase(aiFeatureSlug)
+        }
+      });
+      await syncAiFeatureSchemaArtifact({
+        aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
+        outputDir: path13.join("src", "ai-features", aiFeatureSlug),
+        projectDir: workspace.projectDir
+      });
+      await appendWorkspaceInventoryEntries(workspace.projectDir, {
+        aiFeatureEntries: [
+          buildAiFeatureConfigEntry(aiFeatureSlug, namespace)
+        ],
+        transformSource: ensureBlockConfigCanAddRestManifests
+      });
+      return {
+        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`."
+        ] : []
+      };
+    }
+  });
+}
+
+// ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
+async function runAddAiFeatureCommand({
+  aiFeatureName,
+  cwd = process.cwd(),
+  namespace
+}) {
+  const workspace = resolveWorkspaceProject(cwd);
+  const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
+  const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
+  const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
+  const inventory = readWorkspaceInventory(workspace.projectDir);
+  assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
+  const scaffoldResult = await scaffoldAiFeatureWorkspace({
+    aiFeatureSlug,
+    compatibilityPolicy,
+    namespace: resolvedNamespace,
+    workspace
+  });
+  return {
+    aiFeatureSlug,
+    namespace: resolvedNamespace,
+    projectDir: workspace.projectDir,
+    warnings: scaffoldResult.warnings
   };
-  try {
-    await fsp8.mkdir(aiFeatureDir, { recursive: true });
-    await fsp8.mkdir(path13.dirname(phpFilePath), { recursive: true });
-    await ensureAiFeatureBootstrapAnchors(workspace);
-    await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
-    const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
-    await ensureAiFeatureSyncProjectAnchors(workspace);
-    await ensureAiFeatureSyncRestAnchors(workspace);
-    await fsp8.writeFile(syncAiScriptPath, buildAiFeatureSyncScriptSource(), "utf8");
-    await fsp8.writeFile(typesFilePath, buildAiFeatureTypesSource(aiFeatureSlug), "utf8");
-    await fsp8.writeFile(validatorsFilePath, buildAiFeatureValidatorsSource(aiFeatureSlug), "utf8");
-    await fsp8.writeFile(apiFilePath, buildAiFeatureApiSource(aiFeatureSlug), "utf8");
-    await fsp8.writeFile(dataFilePath, buildAiFeatureDataSource(aiFeatureSlug), "utf8");
-    await fsp8.writeFile(phpFilePath, buildAiFeaturePhpSource(aiFeatureSlug, resolvedNamespace, workspace.workspace.phpPrefix, workspace.workspace.textDomain), "utf8");
-    const pascalCase = toPascalCase(aiFeatureSlug);
-    await syncAiFeatureRestArtifacts({
-      clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
-      outputDir: path13.join("src", "ai-features", aiFeatureSlug),
-      projectDir: workspace.projectDir,
-      typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
-      validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
-      variables: {
-        namespace: resolvedNamespace,
-        pascalCase,
-        slugKebabCase: aiFeatureSlug,
-        title: toTitleCase(aiFeatureSlug)
-      }
-    });
-    await syncAiFeatureSchemaArtifact({
-      aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
-      outputDir: path13.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
@@ -6776,80 +6835,6 @@ var BLOCK_TRANSFORMS_CALL_LINE = "applyWorkspaceBlockTransforms(registration.set
 var BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
 var SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN = /registerScaffoldBlockType\s*\(\s*registration\s*\.\s*name\s*,\s*registration\s*\.\s*settings\s*\)\s*;?/u;
 var FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
-function maskSourceSegment(segment) {
-  return segment.replace(/[^\n\r]/gu, " ");
-}
-function maskTypeScriptComments(source) {
-  return source.replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment).replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
-}
-function maskTypeScriptCommentsAndLiterals(source) {
-  let maskedSource = "";
-  let index = 0;
-  while (index < source.length) {
-    const current = source[index];
-    const next = source[index + 1];
-    if (current === "/" && next === "/") {
-      const start = index;
-      index += 2;
-      while (index < source.length && source[index] !== `
-` && source[index] !== "\r") {
-        index += 1;
-      }
-      maskedSource += maskSourceSegment(source.slice(start, index));
-      continue;
-    }
-    if (current === "/" && next === "*") {
-      const start = index;
-      index += 2;
-      while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) {
-        index += 1;
-      }
-      index = Math.min(index + 2, source.length);
-      maskedSource += maskSourceSegment(source.slice(start, index));
-      continue;
-    }
-    if (current === "'" || current === '"' || current === "`") {
-      const start = index;
-      const quote = current;
-      index += 1;
-      while (index < source.length) {
-        const char = source[index];
-        if (char === "\\") {
-          index += 2;
-          continue;
-        }
-        index += 1;
-        if (char === quote) {
-          break;
-        }
-      }
-      maskedSource += maskSourceSegment(source.slice(start, index));
-      continue;
-    }
-    maskedSource += current;
-    index += 1;
-  }
-  return maskedSource;
-}
-function hasExecutablePattern(source, pattern) {
-  return pattern.test(maskTypeScriptCommentsAndLiterals(source));
-}
-function hasUncommentedPattern(source, pattern) {
-  return pattern.test(maskTypeScriptComments(source));
-}
-function findExecutablePatternMatch(source, patterns) {
-  const maskedSource = maskTypeScriptCommentsAndLiterals(source);
-  for (const pattern of patterns) {
-    const match = pattern.exec(maskedSource);
-    if (match && match.index !== undefined) {
-      return {
-        end: match.index + match[0].length,
-        start: match.index
-      };
-    }
-  }
-  return;
-}
 function isIdentifierBoundary(source, index) {
   if (index < 0 || index >= source.length) {
     return true;
@@ -7242,24 +7227,6 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
   const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
   await fsp9.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
-function assertBlockStyleDoesNotExist(projectDir, blockSlug, styleSlug, inventory) {
-  const stylePath = path14.join(projectDir, "src", "blocks", blockSlug, "styles", `${styleSlug}.ts`);
-  if (fs6.existsSync(stylePath)) {
-    throw new Error(`A block style already exists at ${path14.relative(projectDir, stylePath)}. Choose a different name.`);
-  }
-  if (inventory.blockStyles.some((entry) => entry.block === blockSlug && entry.slug === styleSlug)) {
-    throw new Error(`A block style inventory entry already exists for ${blockSlug}/${styleSlug}. Choose a different name.`);
-  }
-}
-function assertBlockTransformDoesNotExist(projectDir, blockSlug, transformSlug, inventory) {
-  const transformPath = path14.join(projectDir, "src", "blocks", blockSlug, "transforms", `${transformSlug}.ts`);
-  if (fs6.existsSync(transformPath)) {
-    throw new Error(`A block transform already exists at ${path14.relative(projectDir, transformPath)}. Choose a different name.`);
-  }
-  if (inventory.blockTransforms.some((entry) => entry.block === blockSlug && entry.slug === transformSlug)) {
-    throw new Error(`A block transform inventory entry already exists for ${blockSlug}/${transformSlug}. Choose a different name.`);
-  }
-}
 function assertFullBlockName(blockName, flagName) {
   const trimmed = blockName.trim();
   if (!trimmed) {
@@ -7500,6 +7467,7 @@ export {
   runAddAiFeatureCommand,
   runAddAdminViewCommand,
   runAddAbilityCommand,
+  isAddBlockTemplateId,
   getWorkspaceBlockSelectOptions,
   formatAddHelpText,
   EDITOR_PLUGIN_SLOT_IDS,
@@ -7507,4 +7475,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=FE993C1947A36DF464756E2164756E21
+//# debugId=851894DA0B69BA4964756E2164756E21