wp-typia 0.20.3 → 0.20.5

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

@@ -35481,7 +35481,10 @@ function inferCliDiagnosticCode(options) {
   if (/requires <|requires --|requires a value/u.test(haystack)) {
     return CLI_DIAGNOSTIC_CODES.MISSING_ARGUMENT;
   }
-  if (/Unknown .*subcommand|Unknown add kind|Unknown template|removed in favor|does not support|The Bun-free fallback runtime does not support|The positional alias only accepts/u.test(haystack)) {
+  if (/Unknown (?:add-block )?template\s+(?:"|\\")/u.test(haystack)) {
+    return CLI_DIAGNOSTIC_CODES.UNKNOWN_TEMPLATE;
+  }
+  if (/Unknown .*subcommand|Unknown add kind|removed in favor|does not support|The Bun-free fallback runtime does not support|The positional alias only accepts/u.test(haystack)) {
     return haystack.includes("does not support") || haystack.includes("The Bun-free fallback runtime does not support") ? CLI_DIAGNOSTIC_CODES.UNSUPPORTED_COMMAND : CLI_DIAGNOSTIC_CODES.INVALID_COMMAND;
   }
   if (/Invalid |must start with|cannot hook|cannot nest|cannot use|cannot be|already defines|already exists|Expected one of/u.test(haystack)) {
@@ -35577,6 +35580,7 @@ var init_cli_diagnostics = __esm(() => {
     OUTSIDE_PROJECT_ROOT: "outside-project-root",
     TEMPLATE_SOURCE_TIMEOUT: "template-source-timeout",
     TEMPLATE_SOURCE_TOO_LARGE: "template-source-too-large",
+    UNKNOWN_TEMPLATE: "unknown-template",
     UNSUPPORTED_COMMAND: "unsupported-command"
   };
   DEFAULT_CLI_FAILURE_SUMMARIES = {
@@ -223023,6 +223027,13 @@ import { promises as fsp13 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import path43 from "path";
 import { spawnSync as spawnSync3 } from "child_process";
+function getUnknownNpmTemplateMessage(templateId) {
+  return [
+    `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS.join(", ")}.`,
+    "Run `wp-typia templates list` to inspect available templates.",
+    "If you meant an npm template package, verify the package name and configured npm registry."
+  ].join(" ");
+}
 function selectRegistryVersion(metadata2, locator) {
   const distTags = isPlainObject3(metadata2["dist-tags"]) ? metadata2["dist-tags"] : {};
   const versions2 = isPlainObject3(metadata2.versions) ? metadata2.versions : {};
@@ -223061,6 +223072,9 @@ async function fetchNpmTemplateSource(locator) {
     label: metadataLabel
   });
   if (!metadataResponse.ok) {
+    if (metadataResponse.status === 404) {
+      throw new Error(getUnknownNpmTemplateMessage(locator.raw));
+    }
     throw new Error(`Failed to fetch npm template metadata for ${locator.raw}: ${metadataResponse.status}`);
   }
   const metadata2 = await readJsonResponseWithLimit(metadataResponse, {
@@ -223253,7 +223267,7 @@ async function resolveTemplateSeed(locator, cwd) {
   }
   return fetchNpmTemplateSource(locator.locator);
 }
-var import_semver;
+var import_semver, USER_FACING_TEMPLATE_IDS;
 var init_template_source_seeds = __esm(() => {
   init_index_min();
   init_external_template_guards();
@@ -223261,6 +223275,10 @@ var init_template_source_seeds = __esm(() => {
   init_object_utils();
   init_temp_roots();
   import_semver = __toESM(require_semver2(), 1);
+  USER_FACING_TEMPLATE_IDS = [
+    ...TEMPLATE_IDS,
+    OFFICIAL_WORKSPACE_TEMPLATE_ALIAS
+  ];
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-validation.ts
@@ -228275,6 +228293,7 @@ var init_block_generator_service = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/scaffold-answer-resolution.ts
 import { execSync as execSync4 } from "child_process";
+import path45 from "path";
 function detectAuthor() {
   try {
     return execSync4("git config user.name", {
@@ -228325,8 +228344,14 @@ function normalizeQueryPostType(value2) {
 function normalizeTemplateSelection(templateId) {
   return templateId === WORKSPACE_TEMPLATE_ALIAS ? OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE : templateId;
 }
+function looksLikeWindowsAbsoluteTemplatePath(templateId) {
+  return /^[a-z]:[\\/]/iu.test(templateId) || /^\\\\[^\\]+\\[^\\]+/u.test(templateId);
+}
+function looksLikeExplicitNonNpmExternalTemplateLocator(templateId) {
+  return path45.isAbsolute(templateId) || looksLikeWindowsAbsoluteTemplatePath(templateId) || templateId.startsWith("./") || templateId.startsWith("../") || templateId.startsWith("@") || templateId.startsWith("github:") || templateId.includes("/");
+}
 function looksLikeExplicitExternalTemplateLocator(templateId) {
-  return templateId.startsWith("./") || templateId.startsWith("../") || templateId.startsWith("/") || templateId.startsWith("@") || templateId.startsWith("github:") || templateId.includes("/");
+  return looksLikeExplicitNonNpmExternalTemplateLocator(templateId) || parseNpmTemplateLocator(templateId) !== null;
 }
 function getEditDistance(left, right) {
   const previous = Array.from({ length: right.length + 1 }, (_3, index) => index);
@@ -228345,7 +228370,7 @@ function getEditDistance(left, right) {
 }
 function findMistypedBuiltInTemplateSuggestion(templateId) {
   const normalizedTemplateId = templateId.trim().toLowerCase();
-  if (normalizedTemplateId.length === 0 || looksLikeExplicitExternalTemplateLocator(normalizedTemplateId)) {
+  if (normalizedTemplateId.length === 0 || looksLikeExplicitNonNpmExternalTemplateLocator(normalizedTemplateId)) {
     return null;
   }
   let bestCandidate = null;
@@ -228368,6 +228393,13 @@ function getMistypedBuiltInTemplateMessage(templateId) {
   const suggestionDescription = suggestion === WORKSPACE_TEMPLATE_ALIAS ? "official workspace scaffold" : "built-in scaffold";
   return `Unknown template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\` for the ${suggestionDescription}, or pass a local path, \`github:owner/repo/path[#ref]\`, or an npm package spec for an external template.`;
 }
+function getUnknownTemplateMessage(templateId) {
+  return [
+    `Unknown template "${templateId}". Expected one of: ${USER_FACING_TEMPLATE_IDS2.join(", ")}.`,
+    "Run `wp-typia templates list` to inspect available templates.",
+    "Pass an explicit external template locator such as `./path`, `github:owner/repo/path[#ref]`, or `@scope/template` for custom templates."
+  ].join(" ");
+}
 async function resolveTemplateId({
   templateId,
   yes = false,
@@ -228389,6 +228421,9 @@ async function resolveTemplateId({
     if (mistypedBuiltInTemplateMessage) {
       throw new Error(mistypedBuiltInTemplateMessage);
     }
+    if (!looksLikeExplicitExternalTemplateLocator(normalizedTemplateId)) {
+      throw new Error(getUnknownTemplateMessage(templateId));
+    }
     return normalizedTemplateId;
   }
   if (yes) {
@@ -228429,7 +228464,7 @@ async function collectScaffoldAnswers({
   textDomain
 }) {
   const defaults = getDefaultAnswers(projectName, templateId);
-  if (yes) {
+  if (yes || !isBuiltInTemplateId(templateId) && !promptText) {
     const identifiers2 = resolveScaffoldIdentifiers({
       namespace: namespace ?? defaults.namespace,
       phpPrefix,
@@ -228468,17 +228503,22 @@ async function collectScaffoldAnswers({
     title: await promptText("Block title", toTitleCase(identifiers.slug))
   };
 }
-var WORKSPACE_TEMPLATE_ALIAS = "workspace", TEMPLATE_SELECTION_HINT, TEMPLATE_SUGGESTION_IDS, QUERY_POST_TYPE_RULE = 'Use lowercase, 1-20 chars, and only a-z, 0-9, "_" or "-".';
+var WORKSPACE_TEMPLATE_ALIAS = "workspace", TEMPLATE_SELECTION_HINT, TEMPLATE_SUGGESTION_IDS, QUERY_POST_TYPE_RULE = 'Use lowercase, 1-20 chars, and only a-z, 0-9, "_" or "-".', USER_FACING_TEMPLATE_IDS2;
 var init_scaffold_answer_resolution = __esm(() => {
   init_package_managers();
   init_scaffold_identifiers();
   init_template_registry();
   init_template_defaults();
+  init_template_source_locators();
   TEMPLATE_SELECTION_HINT = `--template <${[
     ...TEMPLATE_IDS,
     WORKSPACE_TEMPLATE_ALIAS
   ].join("|")}|./path|github:owner/repo/path[#ref]|npm-package>`;
   TEMPLATE_SUGGESTION_IDS = [...TEMPLATE_IDS, WORKSPACE_TEMPLATE_ALIAS];
+  USER_FACING_TEMPLATE_IDS2 = [
+    ...TEMPLATE_IDS,
+    WORKSPACE_TEMPLATE_ALIAS
+  ];
 });
 
 // ../wp-typia-project-tools/src/runtime/scaffold-template-variables.ts
@@ -228665,7 +228705,7 @@ var init_scaffold_template_variables = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
 import fs38 from "fs";
 import { promises as fsp14 } from "fs";
-import path45 from "path";
+import path46 from "path";
 function isDataStorageMode(value2) {
   return DATA_STORAGE_MODES.includes(value2);
 }
@@ -228811,7 +228851,7 @@ async function scaffoldProject({
     phase: "finalize-project",
     title: "Finalizing scaffold output"
   });
-  const readmePath = path45.join(projectDir, "README.md");
+  const readmePath = path46.join(projectDir, "README.md");
   if (!fs38.existsSync(readmePath)) {
     await fsp14.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
       withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
@@ -228819,7 +228859,7 @@ async function scaffoldProject({
       withWpEnv: isBuiltInTemplate ? withWpEnv : false
     }), "utf8");
   }
-  const gitignorePath = path45.join(projectDir, ".gitignore");
+  const gitignorePath = path46.join(projectDir, ".gitignore");
   const existingGitignore = fs38.existsSync(gitignorePath) ? await fsp14.readFile(gitignorePath, "utf8") : "";
   await fsp14.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
   await normalizePackageJson(projectDir, resolvedPackageManager);
@@ -228885,9 +228925,9 @@ var init_scaffold = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-block-config.ts
-import path46 from "path";
+import path47 from "path";
 function buildServerTemplateRoot(persistencePolicy) {
-  return path46.join(SHARED_WORKSPACE_TEMPLATE_ROOT, persistencePolicy === "public" ? "persistence-public" : "persistence-auth");
+  return path47.join(SHARED_WORKSPACE_TEMPLATE_ROOT, persistencePolicy === "public" ? "persistence-public" : "persistence-auth");
 }
 function buildSingleBlockConfigEntry(variables) {
   return [
@@ -229037,7 +229077,7 @@ var init_cli_add_block_config = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-block-legacy-validator.ts
 import fs39 from "fs";
 import { promises as fsp15 } from "fs";
-import path47 from "path";
+import path48 from "path";
 function ensureBlockConfigCanAddRestManifests(source) {
   const importLine = "import { defineEndpointManifest } from '@wp-typia/block-runtime/metadata-core';";
   if (REST_MANIFEST_IMPORT_PATTERN.test(source)) {
@@ -229139,22 +229179,22 @@ function renderLegacyManifestDefaultsWrapperSource() {
 `);
 }
 async function ensureLegacyCompoundValidatorManifestDefaultsWrapper(validatorPath) {
-  const validatorDir = path47.dirname(validatorPath);
-  const wrapperPath = path47.join(validatorDir, "manifest-defaults-document.ts");
-  const manifestPath = path47.join(validatorDir, "typia.manifest.json");
+  const validatorDir = path48.dirname(validatorPath);
+  const wrapperPath = path48.join(validatorDir, "manifest-defaults-document.ts");
+  const manifestPath = path48.join(validatorDir, "typia.manifest.json");
   if (fs39.existsSync(wrapperPath) || !fs39.existsSync(manifestPath)) {
     return;
   }
   await fsp15.writeFile(wrapperPath, renderLegacyManifestDefaultsWrapperSource(), "utf8");
 }
 async function collectLegacyCompoundValidatorPaths(projectDir) {
-  const blocksDir = path47.join(projectDir, "src", "blocks");
+  const blocksDir = path48.join(projectDir, "src", "blocks");
   if (!fs39.existsSync(blocksDir)) {
     return [];
   }
   const blockEntries = await fsp15.readdir(blocksDir, { withFileTypes: true });
   const validatorPaths = await Promise.all(blockEntries.filter((entry) => entry.isDirectory()).map(async (entry) => {
-    const validatorPath = path47.join(blocksDir, entry.name, "validators.ts");
+    const validatorPath = path48.join(blocksDir, entry.name, "validators.ts");
     const validatorSource = await readOptionalFile(validatorPath);
     return isLegacyCompoundValidatorSource(validatorSource) ? validatorPath : null;
   }));
@@ -229162,14 +229202,14 @@ async function collectLegacyCompoundValidatorPaths(projectDir) {
 }
 async function ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths) {
   for (const fileName of COMPOUND_SHARED_SUPPORT_FILES) {
-    const sourcePath = path47.join(tempProjectDir, "src", fileName);
+    const sourcePath = path48.join(tempProjectDir, "src", fileName);
     if (!fs39.existsSync(sourcePath)) {
       continue;
     }
-    const targetPath = path47.join(projectDir, "src", fileName);
+    const targetPath = path48.join(projectDir, "src", fileName);
     const currentSource = await readOptionalFile(targetPath);
     if (fileName === "validator-toolkit.ts" ? shouldRefreshCompoundValidatorToolkit(currentSource) : currentSource === null) {
-      await fsp15.mkdir(path47.dirname(targetPath), { recursive: true });
+      await fsp15.mkdir(path48.dirname(targetPath), { recursive: true });
       await fsp15.copyFile(sourcePath, targetPath);
     }
   }
@@ -229254,7 +229294,7 @@ var init_external_layer_selection = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-block.ts
 import fs40 from "fs";
 import { promises as fsp16 } from "fs";
-import path48 from "path";
+import path49 from "path";
 import {
   syncBlockMetadata
 } from "@wp-typia/block-runtime/metadata-core";
@@ -229276,16 +229316,16 @@ ${source}`;
   });
 }
 async function copyTempDirectory(sourceDir, targetDir) {
-  await fsp16.mkdir(path48.dirname(targetDir), { recursive: true });
+  await fsp16.mkdir(path49.dirname(targetDir), { recursive: true });
   await fsp16.cp(sourceDir, targetDir, { recursive: true });
 }
 async function addCollectionImportsForTemplate(projectDir, templateId, variables) {
   if (templateId === "compound") {
-    await ensureCollectionImport(path48.join(projectDir, "src", "blocks", variables.slugKebabCase, "index.tsx"));
-    await ensureCollectionImport(path48.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`, "index.tsx"));
+    await ensureCollectionImport(path49.join(projectDir, "src", "blocks", variables.slugKebabCase, "index.tsx"));
+    await ensureCollectionImport(path49.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`, "index.tsx"));
     return;
   }
-  await ensureCollectionImport(path48.join(projectDir, "src", "blocks", variables.slugKebabCase, "index.tsx"));
+  await ensureCollectionImport(path49.join(projectDir, "src", "blocks", variables.slugKebabCase, "index.tsx"));
 }
 async function appendBlockConfigEntries(projectDir, entries, needsRestManifestImport) {
   await appendWorkspaceInventoryEntries(projectDir, {
@@ -229294,12 +229334,12 @@ async function appendBlockConfigEntries(projectDir, entries, needsRestManifestIm
   });
 }
 async function renderWorkspacePersistenceServerModule(projectDir, variables) {
-  const targetDir = path48.join(projectDir, "src", "blocks", variables.slugKebabCase);
+  const targetDir = path49.join(projectDir, "src", "blocks", variables.slugKebabCase);
   const templateDir = buildServerTemplateRoot(variables.persistencePolicy);
   await copyInterpolatedDirectory(templateDir, targetDir, variables);
 }
 function hasInstalledWorkspaceDependencies(projectDir) {
-  return WORKSPACE_INSTALL_MARKERS.some((marker) => fs40.existsSync(path48.join(projectDir, marker)));
+  return WORKSPACE_INSTALL_MARKERS.some((marker) => fs40.existsSync(path49.join(projectDir, marker)));
 }
 function assertWorkspaceDependenciesInstalled(workspace) {
   if (hasInstalledWorkspaceDependencies(workspace.projectDir)) {
@@ -229310,14 +229350,14 @@ function assertWorkspaceDependenciesInstalled(workspace) {
 async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir, variables, legacyValidatorPaths = []) {
   if (templateId === "compound") {
     await ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths);
-    await copyTempDirectory(path48.join(tempProjectDir, "src", "blocks", variables.slugKebabCase), path48.join(projectDir, "src", "blocks", variables.slugKebabCase));
-    await copyTempDirectory(path48.join(tempProjectDir, "src", "blocks", `${variables.slugKebabCase}-item`), path48.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`));
+    await copyTempDirectory(path49.join(tempProjectDir, "src", "blocks", variables.slugKebabCase), path49.join(projectDir, "src", "blocks", variables.slugKebabCase));
+    await copyTempDirectory(path49.join(tempProjectDir, "src", "blocks", `${variables.slugKebabCase}-item`), path49.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`));
     if (variables.compoundPersistenceEnabled === "true") {
       await renderWorkspacePersistenceServerModule(projectDir, variables);
     }
     return;
   }
-  await copyTempDirectory(path48.join(tempProjectDir, "src"), path48.join(projectDir, "src", "blocks", variables.slugKebabCase));
+  await copyTempDirectory(path49.join(tempProjectDir, "src"), path49.join(projectDir, "src", "blocks", variables.slugKebabCase));
   if (templateId === "persistence") {
     await renderWorkspacePersistenceServerModule(projectDir, variables);
   }
@@ -229368,21 +229408,21 @@ async function assertAddBlockSupportsExternalLayerOutputs(options) {
 function collectWorkspaceBlockPaths(projectDir, templateId, variables) {
   if (templateId === "compound") {
     return [
-      path48.join(projectDir, "src", "blocks", variables.slugKebabCase),
-      path48.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`)
+      path49.join(projectDir, "src", "blocks", variables.slugKebabCase),
+      path49.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`)
     ];
   }
-  return [path48.join(projectDir, "src", "blocks", variables.slugKebabCase)];
+  return [path49.join(projectDir, "src", "blocks", variables.slugKebabCase)];
 }
 function assertBlockTargetsDoNotExist(projectDir, templateId, variables) {
   for (const targetPath of collectWorkspaceBlockPaths(projectDir, templateId, variables)) {
     if (fs40.existsSync(targetPath)) {
-      throw new Error(`A block already exists at ${path48.relative(projectDir, targetPath)}. Choose a different name.`);
+      throw new Error(`A block already exists at ${path49.relative(projectDir, targetPath)}. Choose a different name.`);
     }
   }
 }
 async function updateWorkspaceMigrationConfigIfPresent(projectDir, newBlocks) {
-  const configPath = path48.join(projectDir, "src", "migrations", "config.ts");
+  const configPath = path49.join(projectDir, "src", "migrations", "config.ts");
   if (!fs40.existsSync(configPath)) {
     return;
   }
@@ -229403,10 +229443,10 @@ async function updateWorkspaceMigrationConfigIfPresent(projectDir, newBlocks) {
 }
 async function syncWorkspaceBlockMetadata(projectDir, slug, sourceTypeName, typesFile) {
   await syncBlockMetadata({
-    blockJsonFile: path48.join("src", "blocks", slug, "block.json"),
-    jsonSchemaFile: path48.join("src", "blocks", slug, "typia.schema.json"),
-    manifestFile: path48.join("src", "blocks", slug, "typia.manifest.json"),
-    openApiFile: path48.join("src", "blocks", slug, "typia.openapi.json"),
+    blockJsonFile: path49.join("src", "blocks", slug, "block.json"),
+    jsonSchemaFile: path49.join("src", "blocks", slug, "typia.schema.json"),
+    manifestFile: path49.join("src", "blocks", slug, "typia.manifest.json"),
+    openApiFile: path49.join("src", "blocks", slug, "typia.openapi.json"),
     projectRoot: projectDir,
     sourceTypeName,
     typesFile
@@ -229414,16 +229454,16 @@ async function syncWorkspaceBlockMetadata(projectDir, slug, sourceTypeName, type
 }
 async function syncWorkspacePersistenceArtifacts(projectDir, variables) {
   await syncPersistenceRestArtifacts({
-    apiTypesFile: path48.join("src", "blocks", variables.slugKebabCase, "api-types.ts"),
-    outputDir: path48.join("src", "blocks", variables.slugKebabCase),
+    apiTypesFile: path49.join("src", "blocks", variables.slugKebabCase, "api-types.ts"),
+    outputDir: path49.join("src", "blocks", variables.slugKebabCase),
     projectDir,
     variables
   });
 }
 async function syncWorkspaceAddedBlockArtifacts(projectDir, templateId, variables) {
-  await syncWorkspaceBlockMetadata(projectDir, variables.slugKebabCase, `${variables.pascalCase}Attributes`, path48.join("src", "blocks", variables.slugKebabCase, "types.ts"));
+  await syncWorkspaceBlockMetadata(projectDir, variables.slugKebabCase, `${variables.pascalCase}Attributes`, path49.join("src", "blocks", variables.slugKebabCase, "types.ts"));
   if (templateId === "compound") {
-    await syncWorkspaceBlockMetadata(projectDir, `${variables.slugKebabCase}-item`, `${variables.pascalCase}ItemAttributes`, path48.join("src", "blocks", `${variables.slugKebabCase}-item`, "types.ts"));
+    await syncWorkspaceBlockMetadata(projectDir, `${variables.slugKebabCase}-item`, `${variables.pascalCase}ItemAttributes`, path49.join("src", "blocks", `${variables.slugKebabCase}-item`, "types.ts"));
   }
   if (templateId === "persistence" || templateId === "compound" && variables.compoundPersistenceEnabled === "true") {
     await syncWorkspacePersistenceArtifacts(projectDir, variables);
@@ -229484,7 +229524,7 @@ async function runAddBlockCommand({
     throw new Error("`wp-typia add block --template query-loop` is not supported. Query Loop is a create-time `core/query` variation scaffold, so use `wp-typia create <project-dir> --template query-loop` instead.");
   }
   if (!isAddBlockTemplateId(templateId)) {
-    throw new Error(`Unknown add-block template "${templateId}". Expected one of: ${ADD_BLOCK_TEMPLATE_IDS.join(", ")}`);
+    throw new Error(`Unknown add-block template "${templateId}". Expected one of: ${ADD_BLOCK_TEMPLATE_IDS.join(", ")}. Run \`wp-typia templates list\` to inspect available templates.`);
   }
   const resolvedTemplateId = templateId;
   assertPersistenceFlagsAllowed(resolvedTemplateId, {
@@ -229525,13 +229565,13 @@ async function runAddBlockCommand({
       path: tempRoot,
       cleanup: cleanupTempRoot
     } = await createManagedTempRoot("wp-typia-add-block-"));
-    const tempProjectDir = path48.join(tempRoot, normalizedSlug);
-    const blockConfigPath = path48.join(workspace.projectDir, "scripts", "block-config.ts");
-    const migrationConfigPath = path48.join(workspace.projectDir, "src", "migrations", "config.ts");
+    const tempProjectDir = path49.join(tempRoot, normalizedSlug);
+    const blockConfigPath = path49.join(workspace.projectDir, "scripts", "block-config.ts");
+    const migrationConfigPath = path49.join(workspace.projectDir, "src", "migrations", "config.ts");
     const blockPhpPrefix = buildWorkspacePhpPrefix(workspace.workspace.phpPrefix, normalizedSlug);
     const migrationConfigSource = await readOptionalFile(migrationConfigPath);
     const migrationConfig = migrationConfigSource === null ? null : parseMigrationConfig(migrationConfigSource);
-    const compoundSupportPaths = resolvedTemplateId === "compound" ? COMPOUND_SHARED_SUPPORT_FILES.map((fileName) => path48.join(workspace.projectDir, "src", fileName)) : [];
+    const compoundSupportPaths = resolvedTemplateId === "compound" ? COMPOUND_SHARED_SUPPORT_FILES.map((fileName) => path49.join(workspace.projectDir, "src", fileName)) : [];
     const legacyCompoundValidatorPaths = resolvedTemplateId === "compound" ? await collectLegacyCompoundValidatorPaths(workspace.projectDir) : [];
     const result = await (async () => {
       const scaffoldResult = await scaffoldProject({
@@ -229574,7 +229614,7 @@ async function runAddBlockCommand({
         ...compoundSupportPaths,
         ...legacyCompoundValidatorPaths
       ]),
-      snapshotDirs: migrationConfig === null ? [] : buildMigrationBlocks2(resolvedTemplateId, result.variables).map((block) => path48.join(workspace.projectDir, ...migrationConfig.snapshotDir.split("/"), migrationConfig.currentMigrationVersion, block.key)),
+      snapshotDirs: migrationConfig === null ? [] : buildMigrationBlocks2(resolvedTemplateId, result.variables).map((block) => path49.join(workspace.projectDir, ...migrationConfig.snapshotDir.split("/"), migrationConfig.currentMigrationVersion, block.key)),
       targetPaths: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables)
     };
     try {
@@ -229584,7 +229624,7 @@ async function runAddBlockCommand({
       await syncWorkspaceAddedBlockArtifacts(workspace.projectDir, resolvedTemplateId, result.variables);
       await updateWorkspaceMigrationConfigIfPresent(workspace.projectDir, buildMigrationBlocks2(resolvedTemplateId, result.variables));
       return {
-        blockSlugs: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables).map((targetPath) => path48.basename(targetPath)),
+        blockSlugs: collectWorkspaceBlockPaths(workspace.projectDir, resolvedTemplateId, result.variables).map((targetPath) => path49.basename(targetPath)),
         projectDir: workspace.projectDir,
         templateId: resolvedTemplateId,
         warnings: result.warnings
@@ -229628,7 +229668,7 @@ var init_cli_add_block = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
 import fs41 from "fs";
 import { promises as fsp17 } from "fs";
-import path49 from "path";
+import path50 from "path";
 function escapeRegex3(value2) {
   return value2.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
@@ -230010,7 +230050,7 @@ ${patternFunctions}
       }
     }
     if (!nextSource.includes(patternCategoryFunctionName) || !nextSource.includes(patternRegistrationFunctionName)) {
-      throw new Error(`Unable to inject pattern bootstrap functions into ${path49.basename(bootstrapPath)}.`);
+      throw new Error(`Unable to inject pattern bootstrap functions into ${path50.basename(bootstrapPath)}.`);
     }
     if (!nextSource.includes(patternCategoryHook)) {
       nextSource = `${nextSource.trimEnd()}
@@ -230200,7 +230240,7 @@ ${snippet}
       if (missingReferences.length > 0) {
         const replacedSource = replacePhpFunctionDefinition(nextSource, enqueueFunctionName, enqueueFunction);
         if (!replacedSource) {
-          throw new Error(`Unable to repair ${path49.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
+          throw new Error(`Unable to repair ${path50.basename(bootstrapPath)} for ${enqueueFunctionName}.`);
         }
         nextSource = replacedSource;
       }
@@ -230212,7 +230252,7 @@ ${snippet}
   });
 }
 async function ensureEditorPluginBuildScriptAnchors(workspace) {
-  const buildScriptPath = path49.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path50.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     if (/['"]src\/editor-plugins\/index\.(?:ts|js)['"]/u.test(source)) {
       return source;
@@ -230225,13 +230265,13 @@ async function ensureEditorPluginBuildScriptAnchors(workspace) {
 		'src/editor-plugins/index.js',
 	]`);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path49.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path50.relative(workspace.projectDir, buildScriptPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 async function ensureEditorPluginWebpackAnchors(workspace) {
-  const webpackConfigPath = path49.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path50.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]editor-plugins\/index['"]/u.test(source)) {
       return source;
@@ -230259,17 +230299,17 @@ async function ensureEditorPluginWebpackAnchors(workspace) {
 	}`;
     const nextSource = source.replace(legacySharedEntriesBlockPattern, nextSharedEntriesBlock);
     if (nextSource === source) {
-      throw new Error(`Unable to update ${path49.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
+      throw new Error(`Unable to update ${path50.relative(workspace.projectDir, webpackConfigPath)} for editor plugin shared entries.`);
     }
     return nextSource;
   });
 }
 function resolveBindingSourceRegistryPath(projectDir) {
-  const bindingsDir = path49.join(projectDir, "src", "bindings");
-  return [path49.join(bindingsDir, "index.ts"), path49.join(bindingsDir, "index.js")].find((candidatePath) => fs41.existsSync(candidatePath)) ?? path49.join(bindingsDir, "index.ts");
+  const bindingsDir = path50.join(projectDir, "src", "bindings");
+  return [path50.join(bindingsDir, "index.ts"), path50.join(bindingsDir, "index.js")].find((candidatePath) => fs41.existsSync(candidatePath)) ?? path50.join(bindingsDir, "index.ts");
 }
 async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
-  const bindingsDir = path49.join(projectDir, "src", "bindings");
+  const bindingsDir = path50.join(projectDir, "src", "bindings");
   const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
   await fsp17.mkdir(bindingsDir, { recursive: true });
   const existingBindingSourceSlugs = fs41.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -230277,11 +230317,11 @@ async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
   await fsp17.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
 }
 function resolveEditorPluginRegistryPath(projectDir) {
-  const editorPluginsDir = path49.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path50.join(projectDir, "src", "editor-plugins");
   return [
-    path49.join(editorPluginsDir, "index.ts"),
-    path49.join(editorPluginsDir, "index.js")
-  ].find((candidatePath) => fs41.existsSync(candidatePath)) ?? path49.join(editorPluginsDir, "index.ts");
+    path50.join(editorPluginsDir, "index.ts"),
+    path50.join(editorPluginsDir, "index.js")
+  ].find((candidatePath) => fs41.existsSync(candidatePath)) ?? path50.join(editorPluginsDir, "index.ts");
 }
 function readEditorPluginRegistrySlugs(registryPath) {
   if (!fs41.existsSync(registryPath)) {
@@ -230291,7 +230331,7 @@ function readEditorPluginRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
-  const editorPluginsDir = path49.join(projectDir, "src", "editor-plugins");
+  const editorPluginsDir = path50.join(projectDir, "src", "editor-plugins");
   const registryPath = resolveEditorPluginRegistryPath(projectDir);
   await fsp17.mkdir(editorPluginsDir, { recursive: true });
   const existingEditorPluginSlugs = readWorkspaceInventory(projectDir).editorPlugins.map((entry) => entry.slug);
@@ -230309,17 +230349,17 @@ async function runAddEditorPluginCommand({
   const resolvedSlot = assertValidEditorPluginSlot(slot);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertEditorPluginDoesNotExist(workspace.projectDir, editorPluginSlug, inventory);
-  const blockConfigPath = path49.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path50.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path49.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path50.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   const editorPluginsIndexPath = resolveEditorPluginRegistryPath(workspace.projectDir);
-  const webpackConfigPath = path49.join(workspace.projectDir, "webpack.config.js");
-  const editorPluginDir = path49.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
-  const entryFilePath = path49.join(editorPluginDir, "index.tsx");
-  const sidebarFilePath = path49.join(editorPluginDir, "Sidebar.tsx");
-  const dataFilePath = path49.join(editorPluginDir, "data.ts");
-  const typesFilePath = path49.join(editorPluginDir, "types.ts");
-  const styleFilePath = path49.join(editorPluginDir, "style.scss");
+  const webpackConfigPath = path50.join(workspace.projectDir, "webpack.config.js");
+  const editorPluginDir = path50.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
+  const entryFilePath = path50.join(editorPluginDir, "index.tsx");
+  const sidebarFilePath = path50.join(editorPluginDir, "Sidebar.tsx");
+  const dataFilePath = path50.join(editorPluginDir, "data.ts");
+  const typesFilePath = path50.join(editorPluginDir, "types.ts");
+  const styleFilePath = path50.join(editorPluginDir, "style.scss");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -230365,16 +230405,16 @@ async function runAddPatternCommand({
   const patternSlug = assertValidGeneratedSlug("Pattern name", normalizeBlockSlug(patternName), "wp-typia add pattern <name>");
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertPatternDoesNotExist(workspace.projectDir, patternSlug, inventory);
-  const blockConfigPath = path49.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path50.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const patternFilePath = path49.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
+  const patternFilePath = path50.join(workspace.projectDir, "src", "patterns", `${patternSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath]),
     snapshotDirs: [],
     targetPaths: [patternFilePath]
   };
   try {
-    await fsp17.mkdir(path49.dirname(patternFilePath), { recursive: true });
+    await fsp17.mkdir(path50.dirname(patternFilePath), { recursive: true });
     await ensurePatternBootstrapAnchors(workspace);
     await fsp17.writeFile(patternFilePath, buildPatternSource(patternSlug, workspace.workspace.namespace, workspace.workspace.textDomain), "utf8");
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -230397,12 +230437,12 @@ async function runAddBindingSourceCommand({
   const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name>");
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
-  const blockConfigPath = path49.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path50.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
-  const bindingSourceDir = path49.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
-  const serverFilePath = path49.join(bindingSourceDir, "server.php");
-  const editorFilePath = path49.join(bindingSourceDir, "editor.ts");
+  const bindingSourceDir = path50.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
+  const serverFilePath = path50.join(bindingSourceDir, "server.php");
+  const editorFilePath = path50.join(bindingSourceDir, "editor.ts");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([blockConfigPath, bootstrapPath, bindingsIndexPath]),
     snapshotDirs: [],
@@ -230434,7 +230474,7 @@ var init_cli_add_workspace_assets = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest-anchors.ts
-import path50 from "path";
+import path51 from "path";
 function escapeRegex4(value2) {
   return value2.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
@@ -230485,7 +230525,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(REST_RESOURCE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path50.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
+        `Unable to patch ${path51.basename(bootstrapPath)} in ensureRestResourceBootstrapAnchors.`,
         `The existing ${registerFunctionName}() definition does not include ${REST_RESOURCE_SERVER_GLOB}.`,
         "Restore the generated bootstrap shape or wire the REST resource loader manually before retrying."
       ].join(" "));
@@ -230499,7 +230539,7 @@ ${snippet}
 function assertSyncRestAnchor(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureRestResourceSyncScriptAnchors could not patch ${path50.basename(syncRestScriptPath)}.`,
+      `ensureRestResourceSyncScriptAnchors could not patch ${path51.basename(syncRestScriptPath)}.`,
       `Missing expected ${anchorDescription} anchor in scripts/sync-rest-contracts.ts.`,
       "Restore the generated template or add the REST_RESOURCES wiring manually before retrying."
     ].join(" "));
@@ -230514,7 +230554,7 @@ function replaceRequiredSyncRestSource(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureRestResourceSyncScriptAnchors(workspace) {
-  const syncRestScriptPath = path50.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path51.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = "import { BLOCKS, type WorkspaceBlockConfig } from './block-config';";
@@ -230636,7 +230676,7 @@ var init_cli_add_workspace_rest_anchors = __esm(() => {
 });
 
 // ../wp-typia-project-tools/src/runtime/rest-resource-artifacts.ts
-import path51 from "path";
+import path52 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest2,
   syncEndpointClient as syncEndpointClient2,
@@ -230772,8 +230812,8 @@ async function syncRestResourceArtifacts({
   const manifest = buildRestResourceEndpointManifest(variables, methods);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas2({
-      jsonSchemaFile: path51.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path51.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path52.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path52.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -230781,7 +230821,7 @@ async function syncRestResourceArtifacts({
   }
   await syncRestOpenApi2({
     manifest,
-    openApiFile: path51.join(outputDir, "api.openapi.json"),
+    openApiFile: path52.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   });
@@ -231186,7 +231226,7 @@ var init_cli_add_workspace_rest_source_emitters = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-rest.ts
 import { promises as fsp18 } from "fs";
-import path52 from "path";
+import path53 from "path";
 function quotePhpString2(value2) {
   return `'${value2.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
 }
@@ -231619,16 +231659,15 @@ async function runAddRestResourceCommand({
   const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
-  const blockConfigPath = path52.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const syncRestScriptPath = path52.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const restResourceDir = path52.join(workspace.projectDir, "src", "rest", restResourceSlug);
-  const typesFilePath = path52.join(restResourceDir, "api-types.ts");
-  const validatorsFilePath = path52.join(restResourceDir, "api-validators.ts");
-  const apiFilePath = path52.join(restResourceDir, "api.ts");
-  const dataFilePath = path52.join(restResourceDir, "data.ts");
-  const clientFilePath = path52.join(restResourceDir, "api-client.ts");
-  const phpFilePath = path52.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
+  const syncRestScriptPath = path53.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const restResourceDir = path53.join(workspace.projectDir, "src", "rest", restResourceSlug);
+  const typesFilePath = path53.join(restResourceDir, "api-types.ts");
+  const validatorsFilePath = path53.join(restResourceDir, "api-validators.ts");
+  const apiFilePath = path53.join(restResourceDir, "api.ts");
+  const dataFilePath = path53.join(restResourceDir, "data.ts");
+  const phpFilePath = path53.join(workspace.projectDir, "inc", "rest", `${restResourceSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -231640,7 +231679,7 @@ async function runAddRestResourceCommand({
   };
   try {
     await fsp18.mkdir(restResourceDir, { recursive: true });
-    await fsp18.mkdir(path52.dirname(phpFilePath), { recursive: true });
+    await fsp18.mkdir(path53.dirname(phpFilePath), { recursive: true });
     await ensureRestResourceBootstrapAnchors(workspace);
     await ensureRestResourceSyncScriptAnchors(workspace);
     await fsp18.writeFile(typesFilePath, buildRestResourceTypesSource(restResourceSlug, resolvedMethods), "utf8");
@@ -231692,7 +231731,7 @@ var init_cli_add_workspace_rest = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability.ts
 import fs42 from "fs";
 import { promises as fsp19 } from "fs";
-import path53 from "path";
+import path54 from "path";
 import { syncTypeSchemas as syncTypeSchemas3 } from "@wp-typia/block-runtime/metadata-core";
 function escapeRegex5(value2) {
   return value2.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
@@ -231700,6 +231739,50 @@ function escapeRegex5(value2) {
 function quotePhpString3(value2) {
   return `'${value2.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
 }
+function findPhpFunctionRange2(source, functionName) {
+  const functionPattern = new RegExp(`function\\s+${escapeRegex5(functionName)}\\s*\\([^)]*\\)\\s*\\{`, "u");
+  const match3 = functionPattern.exec(source);
+  if (!match3) {
+    return null;
+  }
+  const openingBraceIndex = match3.index + match3[0].length - 1;
+  let depth = 0;
+  for (let index = openingBraceIndex;index < source.length; index += 1) {
+    const character = source[index];
+    if (character === "{") {
+      depth += 1;
+    } else if (character === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        const end = index + 1;
+        return {
+          end,
+          source: source.slice(match3.index, end),
+          start: match3.index
+        };
+      }
+    }
+  }
+  return null;
+}
+function replacePhpFunctionDefinition2(source, functionName, replacement) {
+  const functionRange = findPhpFunctionRange2(source, functionName);
+  if (!functionRange) {
+    return source;
+  }
+  return `${source.slice(0, functionRange.start)}${replacement.trimStart()}${source.slice(functionRange.end)}`;
+}
+function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
+  if (!existingVersion) {
+    return requiredVersion;
+  }
+  const existingMinimum = import_semver2.default.minVersion(existingVersion);
+  const requiredMinimum = import_semver2.default.minVersion(requiredVersion);
+  if (!existingMinimum || !requiredMinimum) {
+    return requiredVersion;
+  }
+  return import_semver2.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
+}
 function toPascalCaseFromAbilitySlug(abilitySlug) {
   return normalizeBlockSlug(abilitySlug).split("-").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
 }
@@ -231769,7 +231852,14 @@ export interface ${pascalCase}AbilityOutput {
 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';
+  return `import {
+	executeAbility,
+	getAbilities,
+	getAbility as getRegisteredAbility,
+} from '@wordpress/abilities';
+import '@wordpress/core-abilities';
+
+import abilityConfig from './ability.config.json';
 
 import type { ${pascalCase}AbilityInput, ${pascalCase}AbilityOutput } from './types';
 
@@ -231781,55 +231871,56 @@ interface WordPressAbilityDefinition {
 	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;
+const ABILITY_DISCOVERY_POLL_INTERVAL_MS = 50;
+const ABILITY_DISCOVERY_TIMEOUT_MS = 5000;
 
 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 );
-	}
+function sleep( milliseconds: number ): Promise< void > {
+	return new Promise( ( resolve ) => {
+		setTimeout( resolve, milliseconds );
+	} );
+}
 
-	return client;
+async function waitFor${pascalCase}AbilityRegistration(): Promise< void > {
+	const deadline = Date.now() + ABILITY_DISCOVERY_TIMEOUT_MS;
+	while ( ! getRegisteredAbility( ${abilityConstBase}_ABILITY_ID ) ) {
+		if ( Date.now() >= deadline ) {
+			return;
+		}
+
+		await sleep( ABILITY_DISCOVERY_POLL_INTERVAL_MS );
+	}
 }
 
-export function list${pascalCase}CategoryAbilities(): WordPressAbilityDefinition[] {
-	return resolveAbilitiesClient().getAbilities( {
+export async function list${pascalCase}CategoryAbilities(): Promise< WordPressAbilityDefinition[] > {
+	await waitFor${pascalCase}AbilityRegistration();
+
+	return getAbilities( {
 		category: ${abilityConstBase}_ABILITY_CATEGORY.slug,
-	} );
+	} ) as WordPressAbilityDefinition[];
 }
 
-export function get${pascalCase}Ability():
+export async function get${pascalCase}Ability(): Promise<
 	| WordPressAbilityDefinition
-	| undefined {
-	return resolveAbilitiesClient().getAbility( ${abilityConstBase}_ABILITY_ID );
+	| undefined
+> {
+	await waitFor${pascalCase}AbilityRegistration();
+
+	return getRegisteredAbility( ${abilityConstBase}_ABILITY_ID ) as
+		| WordPressAbilityDefinition
+		| undefined;
 }
 
-export function require${pascalCase}Ability(): WordPressAbilityDefinition {
-	const ability = get${pascalCase}Ability();
+export async function require${pascalCase}Ability(): Promise< WordPressAbilityDefinition > {
+	const ability = await get${pascalCase}Ability();
 	if ( ability ) {
 		return ability;
 	}
@@ -231845,7 +231936,9 @@ export function require${pascalCase}Ability(): WordPressAbilityDefinition {
 export async function run${pascalCase}Ability(
 	input: ${pascalCase}AbilityInput
 ): Promise< ${pascalCase}AbilityOutput > {
-	return ( await resolveAbilitiesClient().executeAbility(
+	await waitFor${pascalCase}AbilityRegistration();
+
+	return ( await executeAbility(
 		${abilityConstBase}_ABILITY_ID,
 		input
 	) ) as ${pascalCase}AbilityOutput;
@@ -231857,8 +231950,8 @@ function buildAbilityClientSource(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.
+ * The helper methods load the WordPress core abilities integration and wait for
+ * this server-registered ability before reading or executing it.
  */
 export * from './data';
 `;
@@ -232158,8 +232251,8 @@ function buildAbilityRegistrySource(abilitySlugs) {
 `);
 }
 function resolveAbilityRegistryPath(projectDir) {
-  const abilitiesDir = path53.join(projectDir, "src", "abilities");
-  return [path53.join(abilitiesDir, "index.ts"), path53.join(abilitiesDir, "index.js")].find((candidatePath) => fs42.existsSync(candidatePath)) ?? path53.join(abilitiesDir, "index.ts");
+  const abilitiesDir = path54.join(projectDir, "src", "abilities");
+  return [path54.join(abilitiesDir, "index.ts"), path54.join(abilitiesDir, "index.js")].find((candidatePath) => fs42.existsSync(candidatePath)) ?? path54.join(abilitiesDir, "index.ts");
 }
 function readAbilityRegistrySlugs(registryPath) {
   if (!fs42.existsSync(registryPath)) {
@@ -232169,7 +232262,7 @@ function readAbilityRegistrySlugs(registryPath) {
   return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match3) => match3[1]);
 }
 async function writeAbilityRegistry(projectDir, abilitySlug) {
-  const abilitiesDir = path53.join(projectDir, "src", "abilities");
+  const abilitiesDir = path54.join(projectDir, "src", "abilities");
   const registryPath = resolveAbilityRegistryPath(projectDir);
   await fsp19.mkdir(abilitiesDir, { recursive: true });
   const existingAbilitySlugs = readWorkspaceInventory(projectDir).abilities.map((entry) => entry.slug);
@@ -232224,22 +232317,31 @@ function ${enqueueFunctionName}() {
 		? $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 )
-		) {
+	foreach ( array( '${WP_CORE_ABILITIES_SCRIPT_MODULE_ID}', '${WP_ABILITIES_SCRIPT_MODULE_ID}' ) as $ability_dependency ) {
+		$has_dependency = false;
+		foreach ( $dependencies as $dependency ) {
+			$dependency_id = is_array( $dependency ) && isset( $dependency['id'] )
+				? $dependency['id']
+				: $dependency;
+			if ( $dependency_id === $ability_dependency ) {
+				$has_dependency = true;
+				break;
+			}
+		}
+		if ( ! $has_dependency ) {
 			$dependencies[] = $ability_dependency;
 		}
 	}
 
-	wp_enqueue_script(
+	if ( ! function_exists( 'wp_enqueue_script_module' ) ) {
+		return;
+	}
+
+	wp_enqueue_script_module(
 		'${workspaceBaseName}-abilities',
 		plugins_url( '${ABILITY_EDITOR_SCRIPT}', __FILE__ ),
 		$dependencies,
-		isset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path ),
-		true
+		isset( $asset['version'] ) ? $asset['version'] : filemtime( $script_path )
 	);
 }
 `;
@@ -232277,6 +232379,8 @@ ${snippet}
     }
     if (!hasPhpFunctionDefinition(enqueueFunctionName)) {
       insertPhpSnippet(enqueueFunction);
+    } else if (!findPhpFunctionRange2(nextSource, enqueueFunctionName)?.source.includes("wp_enqueue_script_module")) {
+      nextSource = replacePhpFunctionDefinition2(nextSource, enqueueFunctionName, enqueueFunction);
     }
     if (!nextSource.includes(loadHook)) {
       appendPhpSnippet(loadHook);
@@ -232291,21 +232395,27 @@ ${snippet}
   });
 }
 async function ensureAbilityPackageScripts(workspace) {
-  const packageJsonPath = path53.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path54.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp19.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 ?? {})) {
+  const nextDependencies = {
+    ...packageJson.dependencies ?? {},
+    [WP_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_ABILITIES_SCRIPT_MODULE_ID], WP_ABILITIES_PACKAGE_VERSION),
+    [WP_CORE_ABILITIES_SCRIPT_MODULE_ID]: resolveManagedDependencyVersion(packageJson.dependencies?.[WP_CORE_ABILITIES_SCRIPT_MODULE_ID], WP_CORE_ABILITIES_PACKAGE_VERSION)
+  };
+  if (JSON.stringify(nextScripts) === JSON.stringify(packageJson.scripts ?? {}) && JSON.stringify(nextDependencies) === JSON.stringify(packageJson.dependencies ?? {})) {
     return;
   }
   packageJson.scripts = nextScripts;
+  packageJson.dependencies = nextDependencies;
   await fsp19.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function ensureAbilitySyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path53.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path54.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' );";
@@ -232320,7 +232430,7 @@ async function ensureAbilitySyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAbilitiesConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path53.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path54.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(" "));
@@ -232331,7 +232441,7 @@ ${syncAbilitiesConst}`);
     if (!nextSource.includes("runSyncScript( syncAbilitiesScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAbilitySyncProjectAnchors could not patch ${path53.basename(syncProjectScriptPath)}.`,
+          `ensureAbilitySyncProjectAnchors could not patch ${path54.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(" "));
@@ -232344,7 +232454,7 @@ ${syncAbilitiesBlock}`);
   });
 }
 async function ensureAbilityBuildScriptAnchors(workspace) {
-  const buildScriptPath = path53.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const buildScriptPath = path54.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   await patchFile(buildScriptPath, (source) => {
     let nextSource = source;
     if (/['"]src\/abilities\/index\.(?:ts|js)['"]/u.test(nextSource)) {
@@ -232354,7 +232464,7 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
     const match3 = nextSource.match(sharedEntriesPattern);
     if (!match3 || !match3[2].includes("src/bindings/index.ts") || !match3[2].includes("src/editor-plugins/index.ts")) {
       throw new Error([
-        `ensureAbilityBuildScriptAnchors could not patch ${path53.basename(buildScriptPath)}.`,
+        `ensureAbilityBuildScriptAnchors could not patch ${path54.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(" "));
@@ -232371,16 +232481,38 @@ async function ensureAbilityBuildScriptAnchors(workspace) {
   });
 }
 async function ensureAbilityWebpackAnchors(workspace) {
-  const webpackConfigPath = path53.join(workspace.projectDir, "webpack.config.js");
+  const webpackConfigPath = path54.join(workspace.projectDir, "webpack.config.js");
   await patchFile(webpackConfigPath, (source) => {
     if (/['"]abilities\/index['"]/u.test(source)) {
       return source;
     }
+    const optionalModuleReturnPattern = /(function\s+getOptionalModuleEntries\s*\(\)\s*\{[\s\S]*?)(\n\treturn Object\.fromEntries\(\s*entries\s*\);\n\})/u;
+    if (optionalModuleReturnPattern.test(source)) {
+      return source.replace(optionalModuleReturnPattern, `$1
+
+	for ( const [ entryName, candidates ] of [
+		[
+			'abilities/index',
+			[ 'src/abilities/index.ts', 'src/abilities/index.js' ],
+		],
+	] ) {
+		for ( const relativePath of candidates ) {
+			const entryPath = path.resolve( process.cwd(), relativePath );
+			if ( ! fs.existsSync( entryPath ) ) {
+				continue;
+			}
+
+			entries.push( [ entryName, entryPath ] );
+			break;
+		}
+	}
+$2`);
+    }
     const sharedEntriesPattern = /for\s*\(\s*const\s+\[\s*entryName\s*,\s*candidates\s*\]\s+of\s+\[([\s\S]*?)\]\s*\)\s*\{/u;
     const match3 = source.match(sharedEntriesPattern);
     if (!match3 || !match3[1].includes("bindings/index") || !match3[1].includes("editor-plugins/index")) {
       throw new Error([
-        `ensureAbilityWebpackAnchors could not patch ${path53.basename(webpackConfigPath)}.`,
+        `ensureAbilityWebpackAnchors could not patch ${path54.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(" "));
@@ -232410,20 +232542,20 @@ async function runAddAbilityCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
-  const blockConfigPath = path53.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path54.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const buildScriptPath = path53.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const packageJsonPath = path53.join(workspace.projectDir, "package.json");
-  const syncAbilitiesScriptPath = path53.join(workspace.projectDir, "scripts", "sync-abilities.ts");
-  const syncProjectScriptPath = path53.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const webpackConfigPath = path53.join(workspace.projectDir, "webpack.config.js");
+  const buildScriptPath = path54.join(workspace.projectDir, "scripts", "build-workspace.mjs");
+  const packageJsonPath = path54.join(workspace.projectDir, "package.json");
+  const syncAbilitiesScriptPath = path54.join(workspace.projectDir, "scripts", "sync-abilities.ts");
+  const syncProjectScriptPath = path54.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const webpackConfigPath = path54.join(workspace.projectDir, "webpack.config.js");
   const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
-  const abilityDir = path53.join(workspace.projectDir, "src", "abilities", abilitySlug);
-  const configFilePath = path53.join(abilityDir, "ability.config.json");
-  const typesFilePath = path53.join(abilityDir, "types.ts");
-  const dataFilePath = path53.join(abilityDir, "data.ts");
-  const clientFilePath = path53.join(abilityDir, "client.ts");
-  const phpFilePath = path53.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
+  const abilityDir = path54.join(workspace.projectDir, "src", "abilities", abilitySlug);
+  const configFilePath = path54.join(abilityDir, "ability.config.json");
+  const typesFilePath = path54.join(abilityDir, "types.ts");
+  const dataFilePath = path54.join(abilityDir, "data.ts");
+  const clientFilePath = path54.join(abilityDir, "client.ts");
+  const phpFilePath = path54.join(workspace.projectDir, "inc", "abilities", `${abilitySlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -232440,7 +232572,7 @@ async function runAddAbilityCommand({
   };
   try {
     await fsp19.mkdir(abilityDir, { recursive: true });
-    await fsp19.mkdir(path53.dirname(phpFilePath), { recursive: true });
+    await fsp19.mkdir(path54.dirname(phpFilePath), { recursive: true });
     await ensureAbilityBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     await ensureAbilityPackageScripts(workspace);
@@ -232479,12 +232611,13 @@ async function runAddAbilityCommand({
     throw error48;
   }
 }
-var ABILITY_SERVER_GLOB = "/inc/abilities/*.php", ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end", ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start", WP_ABILITIES_SCRIPT_HANDLE = "wp-abilities", WP_CORE_ABILITIES_SCRIPT_HANDLE = "wp-core-abilities";
+var import_semver2, ABILITY_SERVER_GLOB = "/inc/abilities/*.php", ABILITY_EDITOR_SCRIPT = "build/abilities/index.js", ABILITY_EDITOR_ASSET = "build/abilities/index.asset.php", ABILITY_REGISTRY_END_MARKER = "// wp-typia add ability entries end", ABILITY_REGISTRY_START_MARKER = "// wp-typia add ability entries start", WP_ABILITIES_PACKAGE_VERSION = "^0.10.0", WP_CORE_ABILITIES_PACKAGE_VERSION = "^0.9.0", WP_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/abilities", WP_CORE_ABILITIES_SCRIPT_MODULE_ID = "@wordpress/core-abilities";
 var init_cli_add_workspace_ability = __esm(() => {
   init_workspace_inventory();
   init_workspace_project();
   init_cli_add_shared();
   init_scaffold_compatibility();
+  import_semver2 = __toESM(require_semver2(), 1);
 });
 
 // ../wp-typia-project-tools/src/runtime/schema-core.ts
@@ -232516,7 +232649,7 @@ var init_ai_artifacts = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/ai-feature-artifacts.ts
 import { mkdir as mkdir3, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import path54 from "path";
+import path55 from "path";
 import {
   defineEndpointManifest as defineEndpointManifest3,
   syncEndpointClient as syncEndpointClient3,
@@ -232529,7 +232662,7 @@ function normalizeGeneratedArtifactContent(content) {
 }
 async function reconcileGeneratedArtifact(options) {
   if (!options.check) {
-    await mkdir3(path54.dirname(options.filePath), {
+    await mkdir3(path55.dirname(options.filePath), {
       recursive: true
     });
     await writeFile5(options.filePath, options.content, "utf8");
@@ -232601,8 +232734,8 @@ async function syncAiFeatureRestArtifacts({
   const manifest = buildAiFeatureEndpointManifest(variables);
   for (const [baseName, contract] of Object.entries(manifest.contracts)) {
     await syncTypeSchemas4({
-      jsonSchemaFile: path54.join(outputDir, "api-schemas", `${baseName}.schema.json`),
-      openApiFile: path54.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
+      jsonSchemaFile: path55.join(outputDir, "api-schemas", `${baseName}.schema.json`),
+      openApiFile: path55.join(outputDir, "api-schemas", `${baseName}.openapi.json`),
       projectRoot: projectDir,
       sourceTypeName: contract.sourceTypeName,
       typesFile
@@ -232610,7 +232743,7 @@ async function syncAiFeatureRestArtifacts({
   }
   await syncRestOpenApi3({
     manifest,
-    openApiFile: path54.join(outputDir, "api.openapi.json"),
+    openApiFile: path55.join(outputDir, "api.openapi.json"),
     projectRoot: projectDir,
     typesFile
   }, executionOptions);
@@ -232628,19 +232761,19 @@ async function syncAiFeatureSchemaArtifact({
   outputDir,
   projectDir
 }) {
-  const sourceSchemaPath = path54.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
+  const sourceSchemaPath = path55.join(projectDir, outputDir, "api-schemas", "feature-result.schema.json");
   const responseSchema = assertJsonObject(JSON.parse(await readFile5(sourceSchemaPath, "utf8")), sourceSchemaPath);
   const aiSchema = projectWordPressAiSchema(responseSchema);
   await reconcileGeneratedArtifact({
     check: check2,
     content: `${JSON.stringify(aiSchema, null, 2)}
 `,
-    filePath: path54.join(projectDir, aiSchemaFile),
+    filePath: path55.join(projectDir, aiSchemaFile),
     label: "AI feature schema"
   });
   return {
     aiSchema,
-    aiSchemaPath: path54.join(projectDir, aiSchemaFile),
+    aiSchemaPath: path55.join(projectDir, aiSchemaFile),
     check: check2,
     sourceSchemaPath
   };
@@ -232975,7 +233108,7 @@ var init_cli_add_workspace_ai_source_emitters = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai-anchors.ts
 import { promises as fsp20 } from "fs";
-import path55 from "path";
+import path56 from "path";
 function escapeRegex6(value2) {
   return value2.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
@@ -233026,7 +233159,7 @@ ${snippet}
       insertPhpSnippet(registerFunction);
     } else if (!nextSource.includes(AI_FEATURE_SERVER_GLOB)) {
       throw new Error([
-        `Unable to patch ${path55.basename(bootstrapPath)} in ensureAiFeatureBootstrapAnchors.`,
+        `Unable to patch ${path56.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(" "));
@@ -233038,7 +233171,7 @@ ${snippet}
   });
 }
 async function ensureAiFeaturePackageScripts(workspace) {
-  const packageJsonPath = path55.join(workspace.projectDir, "package.json");
+  const packageJsonPath = path56.join(workspace.projectDir, "package.json");
   const packageJson = JSON.parse(await fsp20.readFile(packageJsonPath, "utf8"));
   const nextScripts = {
     ...packageJson.scripts ?? {},
@@ -233066,7 +233199,7 @@ async function ensureAiFeaturePackageScripts(workspace) {
   };
 }
 async function ensureAiFeatureSyncProjectAnchors(workspace) {
-  const syncProjectScriptPath = path55.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncProjectScriptPath = path56.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' );";
@@ -233081,7 +233214,7 @@ async function ensureAiFeatureSyncProjectAnchors(workspace) {
     if (!nextSource.includes(syncAiConst)) {
       if (!nextSource.includes(syncRestConst)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path55.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path56.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(" "));
@@ -233092,7 +233225,7 @@ ${syncAiConst}`);
     if (!nextSource.includes("runSyncScript( syncAiScriptPath, options );")) {
       if (!syncRestBlockPattern.test(nextSource)) {
         throw new Error([
-          `ensureAiFeatureSyncProjectAnchors could not patch ${path55.basename(syncProjectScriptPath)}.`,
+          `ensureAiFeatureSyncProjectAnchors could not patch ${path56.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(" "));
@@ -233107,7 +233240,7 @@ ${syncAiBlock}`);
 function assertSyncRestAnchor2(nextSource, target, anchorDescription, hasAnchor, syncRestScriptPath) {
   if (!nextSource.includes(target) && !hasAnchor) {
     throw new Error([
-      `ensureAiFeatureSyncRestAnchors could not patch ${path55.basename(syncRestScriptPath)}.`,
+      `ensureAiFeatureSyncRestAnchors could not patch ${path56.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(" "));
@@ -233122,7 +233255,7 @@ function replaceRequiredSyncRestSource2(nextSource, target, anchor, replacement,
   return nextSource.replace(anchor, replacement);
 }
 async function ensureAiFeatureSyncRestAnchors(workspace) {
-  const syncRestScriptPath = path55.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const syncRestScriptPath = path56.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
   await patchFile(syncRestScriptPath, (source) => {
     let nextSource = source;
     const importAnchor = [
@@ -233257,7 +233390,7 @@ var init_cli_add_workspace_ai_anchors = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ai.ts
 import { promises as fsp21 } from "fs";
-import path56 from "path";
+import path57 from "path";
 function quotePhpString4(value2) {
   return `'${value2.replace(/\\/gu, "\\\\").replace(/'/gu, "\\'")}'`;
 }
@@ -233649,18 +233782,18 @@ async function runAddAiFeatureCommand({
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
   const inventory = readWorkspaceInventory(workspace.projectDir);
   assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
-  const blockConfigPath = path56.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockConfigPath = path57.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const packageJsonPath = path56.join(workspace.projectDir, "package.json");
-  const syncAiScriptPath = path56.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
-  const syncProjectScriptPath = path56.join(workspace.projectDir, "scripts", "sync-project.ts");
-  const syncRestScriptPath = path56.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
-  const aiFeatureDir = path56.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
-  const typesFilePath = path56.join(aiFeatureDir, "api-types.ts");
-  const validatorsFilePath = path56.join(aiFeatureDir, "api-validators.ts");
-  const apiFilePath = path56.join(aiFeatureDir, "api.ts");
-  const dataFilePath = path56.join(aiFeatureDir, "data.ts");
-  const phpFilePath = path56.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
+  const packageJsonPath = path57.join(workspace.projectDir, "package.json");
+  const syncAiScriptPath = path57.join(workspace.projectDir, "scripts", "sync-ai-features.ts");
+  const syncProjectScriptPath = path57.join(workspace.projectDir, "scripts", "sync-project.ts");
+  const syncRestScriptPath = path57.join(workspace.projectDir, "scripts", "sync-rest-contracts.ts");
+  const aiFeatureDir = path57.join(workspace.projectDir, "src", "ai-features", aiFeatureSlug);
+  const typesFilePath = path57.join(aiFeatureDir, "api-types.ts");
+  const validatorsFilePath = path57.join(aiFeatureDir, "api-validators.ts");
+  const apiFilePath = path57.join(aiFeatureDir, "api.ts");
+  const dataFilePath = path57.join(aiFeatureDir, "data.ts");
+  const phpFilePath = path57.join(workspace.projectDir, "inc", "ai-features", `${aiFeatureSlug}.php`);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -233675,7 +233808,7 @@ async function runAddAiFeatureCommand({
   };
   try {
     await fsp21.mkdir(aiFeatureDir, { recursive: true });
-    await fsp21.mkdir(path56.dirname(phpFilePath), { recursive: true });
+    await fsp21.mkdir(path57.dirname(phpFilePath), { recursive: true });
     await ensureAiFeatureBootstrapAnchors(workspace);
     await patchFile(bootstrapPath, (source) => updatePluginHeaderCompatibility(source, compatibilityPolicy));
     const packageScriptChanges = await ensureAiFeaturePackageScripts(workspace);
@@ -233690,7 +233823,7 @@ async function runAddAiFeatureCommand({
     const pascalCase = toPascalCaseFromAiFeatureSlug(aiFeatureSlug);
     await syncAiFeatureRestArtifacts({
       clientFile: `src/ai-features/${aiFeatureSlug}/api-client.ts`,
-      outputDir: path56.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path57.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir,
       typesFile: `src/ai-features/${aiFeatureSlug}/api-types.ts`,
       validatorsFile: `src/ai-features/${aiFeatureSlug}/api-validators.ts`,
@@ -233703,7 +233836,7 @@ async function runAddAiFeatureCommand({
     });
     await syncAiFeatureSchemaArtifact({
       aiSchemaFile: `src/ai-features/${aiFeatureSlug}/ai-schemas/feature-result.ai.schema.json`,
-      outputDir: path56.join("src", "ai-features", aiFeatureSlug),
+      outputDir: path57.join("src", "ai-features", aiFeatureSlug),
       projectDir: workspace.projectDir
     });
     await appendWorkspaceInventoryEntries(workspace.projectDir, {
@@ -233739,7 +233872,7 @@ var init_cli_add_workspace_ai = __esm(() => {
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
 import fs43 from "fs";
 import { promises as fsp22 } from "fs";
-import path57 from "path";
+import path58 from "path";
 function buildVariationConfigEntry(blockSlug, variationSlug) {
   return [
     "\t{",
@@ -233840,14 +233973,14 @@ ${VARIATIONS_CALL_LINE}
       }
     }
     if (!nextSource.includes(VARIATIONS_CALL_LINE)) {
-      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path57.basename(blockIndexPath)}.`);
+      throw new Error(`Unable to inject ${VARIATIONS_CALL_LINE} into ${path58.basename(blockIndexPath)}.`);
     }
     return nextSource;
   });
 }
 async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
-  const variationsDir = path57.join(projectDir, "src", "blocks", blockSlug, "variations");
-  const variationsIndexPath = path57.join(variationsDir, "index.ts");
+  const variationsDir = path58.join(projectDir, "src", "blocks", blockSlug, "variations");
+  const variationsIndexPath = path58.join(variationsDir, "index.ts");
   await fsp22.mkdir(variationsDir, { recursive: true });
   const existingVariationSlugs = fs43.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();
@@ -233864,11 +233997,11 @@ async function runAddVariationCommand({
   const inventory = readWorkspaceInventory(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
-  const blockConfigPath = path57.join(workspace.projectDir, "scripts", "block-config.ts");
-  const blockIndexPath = path57.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
-  const variationsDir = path57.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
-  const variationFilePath = path57.join(variationsDir, `${variationSlug}.ts`);
-  const variationsIndexPath = path57.join(variationsDir, "index.ts");
+  const blockConfigPath = path58.join(workspace.projectDir, "scripts", "block-config.ts");
+  const blockIndexPath = path58.join(workspace.projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const variationsDir = path58.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
+  const variationFilePath = path58.join(variationsDir, `${variationSlug}.ts`);
+  const variationsIndexPath = path58.join(variationsDir, "index.ts");
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -233913,7 +234046,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 = path57.relative(workspace.projectDir, blockJsonPath);
+  const blockJsonRelativePath = path58.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}".`);
@@ -233979,7 +234112,7 @@ import { execFileSync as execFileSync3 } from "child_process";
 import { access, constants as fsConstants, rm as rm2, writeFile as writeFile6 } from "fs/promises";
 import fs44 from "fs";
 import os4 from "os";
-import path58 from "path";
+import path59 from "path";
 function readCommandVersion(command, args = ["--version"]) {
   try {
     return execFileSync3(command, args, {
@@ -234003,7 +234136,7 @@ async function checkWritableDirectory(directory) {
   }
 }
 async function checkTempDirectory() {
-  const tempFile = path58.join(os4.tmpdir(), `wp-typia-${Date.now()}.tmp`);
+  const tempFile = path59.join(os4.tmpdir(), `wp-typia-${Date.now()}.tmp`);
   try {
     await writeFile6(tempFile, "ok", "utf8");
     await rm2(tempFile, { force: true });
@@ -234020,7 +234153,7 @@ function getTemplateDoctorChecks() {
   for (const template of listTemplates()) {
     if (!isBuiltInTemplateId(template.id)) {
       const templateDirExists = fs44.existsSync(template.templateDir);
-      const hasAssets2 = templateDirExists && fs44.existsSync(path58.join(template.templateDir, "package.json.mustache"));
+      const hasAssets2 = templateDirExists && fs44.existsSync(path59.join(template.templateDir, "package.json.mustache"));
       checks3.push({
         status: !templateDirExists || hasAssets2 ? "pass" : "fail",
         label: `Template ${template.id}`,
@@ -234045,7 +234178,7 @@ function getTemplateDoctorChecks() {
     ])) : getBuiltInTemplateLayerDirs(builtInTemplateId);
     const missingRequiredLayer = layerDirs.some((layerDir) => !fs44.existsSync(layerDir) && !isOmittableBuiltInTemplateLayerDir(builtInTemplateId, layerDir));
     const existingLayerDirs = layerDirs.filter((layerDir) => fs44.existsSync(layerDir));
-    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs44.existsSync(path58.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs44.existsSync(path58.join(layerDir, "src")));
+    const hasAssets = !missingRequiredLayer && existingLayerDirs.some((layerDir) => fs44.existsSync(path59.join(layerDir, "package.json.mustache"))) && existingLayerDirs.some((layerDir) => fs44.existsSync(path59.join(layerDir, "src")));
     checks3.push({
       status: hasAssets ? "pass" : "fail",
       label: `Template ${template.id}`,
@@ -234076,7 +234209,7 @@ var init_cli_doctor_environment = __esm(() => {
 
 // ../wp-typia-project-tools/src/runtime/cli-doctor-workspace.ts
 import fs45 from "fs";
-import path59 from "path";
+import path60 from "path";
 import { parseScaffoldBlockMetadata as parseScaffoldBlockMetadata2 } from "@wp-typia/block-runtime/blocks";
 function createDoctorCheck2(label, status, detail) {
   return { detail, label, status };
@@ -234092,7 +234225,7 @@ function getWorkspaceBootstrapRelativePath(packageName) {
   return `${packageBaseName}.php`;
 }
 function checkExistingFiles(projectDir, label, filePaths) {
-  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs45.existsSync(path59.join(projectDir, filePath)));
+  const missing = filePaths.filter((filePath) => typeof filePath === "string").filter((filePath) => !fs45.existsSync(path60.join(projectDir, filePath)));
   return createDoctorCheck2(label, missing.length === 0 ? "pass" : "fail", missing.length === 0 ? "All referenced files exist" : `Missing: ${missing.join(", ")}`);
 }
 function checkWorkspacePackageMetadata(workspace, packageJson) {
@@ -234118,24 +234251,24 @@ function checkWorkspacePackageMetadata(workspace, packageJson) {
   if (wpTypia?.phpPrefix !== workspace.workspace.phpPrefix) {
     issues.push(`wpTypia.phpPrefix must equal "${workspace.workspace.phpPrefix}"`);
   }
-  if (!fs45.existsSync(path59.join(workspace.projectDir, bootstrapRelativePath))) {
+  if (!fs45.existsSync(path60.join(workspace.projectDir, bootstrapRelativePath))) {
     issues.push(`Missing bootstrap file ${bootstrapRelativePath}`);
   }
   return createDoctorCheck2("Workspace package metadata", issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `package.json metadata aligns with ${workspace.packageName} and ${bootstrapRelativePath}` : issues.join("; "));
 }
 function getWorkspaceBlockRequiredFiles(block) {
-  const blockDir = path59.join("src", "blocks", block.slug);
+  const blockDir = path60.join("src", "blocks", block.slug);
   return Array.from(new Set([
     block.typesFile,
     block.apiTypesFile,
     block.openApiFile,
-    path59.join(blockDir, "index.tsx"),
-    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path59.join(blockDir, fileName))
+    path60.join(blockDir, "index.tsx"),
+    ...WORKSPACE_GENERATED_BLOCK_ARTIFACTS.map((fileName) => path60.join(blockDir, fileName))
   ].filter((filePath) => typeof filePath === "string")));
 }
 function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
-  const blockJsonRelativePath = path59.join("src", "blocks", block.slug, "block.json");
-  const blockJsonPath = path59.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path60.join("src", "blocks", block.slug, "block.json");
+  const blockJsonPath = path60.join(projectDir, blockJsonRelativePath);
   if (!fs45.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block metadata ${block.slug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
@@ -234156,8 +234289,8 @@ function checkWorkspaceBlockMetadata(projectDir, workspace, block) {
   return createDoctorCheck2(`Block metadata ${block.slug}`, issues.length === 0 ? "pass" : "fail", issues.length === 0 ? `block.json matches ${expectedName} and ${workspace.workspace.textDomain}` : issues.join("; "));
 }
 function checkWorkspaceBlockHooks(projectDir, blockSlug) {
-  const blockJsonRelativePath = path59.join("src", "blocks", blockSlug, "block.json");
-  const blockJsonPath = path59.join(projectDir, blockJsonRelativePath);
+  const blockJsonRelativePath = path60.join("src", "blocks", blockSlug, "block.json");
+  const blockJsonPath = path60.join(projectDir, blockJsonRelativePath);
   if (!fs45.existsSync(blockJsonPath)) {
     return createDoctorCheck2(`Block hooks ${blockSlug}`, "fail", `Missing ${blockJsonRelativePath}`);
   }
@@ -234179,8 +234312,8 @@ function checkWorkspaceBlockHooks(projectDir, blockSlug) {
   return createDoctorCheck2(`Block hooks ${blockSlug}`, invalidEntries.length === 0 ? "pass" : "fail", invalidEntries.length === 0 ? `blockHooks metadata is valid${Object.keys(blockHooks).length > 0 ? ` (${Object.keys(blockHooks).join(", ")})` : ""}` : `Invalid blockHooks entries: ${invalidEntries.map(([anchor, position]) => `${anchor || "<empty>"} => ${String(position)}`).join(", ")}`);
 }
 function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
-  const entryRelativePath = path59.join("src", "blocks", blockSlug, "index.tsx");
-  const entryPath = path59.join(projectDir, entryRelativePath);
+  const entryRelativePath = path60.join("src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path60.join(projectDir, entryRelativePath);
   if (!fs45.existsSync(entryPath)) {
     return createDoctorCheck2(`Block collection ${blockSlug}`, "fail", `Missing ${entryRelativePath}`);
   }
@@ -234190,9 +234323,9 @@ function checkWorkspaceBlockCollectionImport(projectDir, blockSlug) {
 }
 function checkWorkspacePatternBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path59.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path60.join(projectDir, `${packageBaseName}.php`);
   if (!fs45.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path59.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Pattern bootstrap", "fail", `Missing ${path60.basename(bootstrapPath)}`);
   }
   const source = fs45.readFileSync(bootstrapPath, "utf8");
   const hasCategoryAnchor = source.includes("register_block_pattern_category");
@@ -234201,9 +234334,9 @@ function checkWorkspacePatternBootstrap(projectDir, packageName) {
 }
 function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path59.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path60.join(projectDir, `${packageBaseName}.php`);
   if (!fs45.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path59.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Binding bootstrap", "fail", `Missing ${path60.basename(bootstrapPath)}`);
   }
   const source = fs45.readFileSync(bootstrapPath, "utf8");
   const hasServerGlob = source.includes(WORKSPACE_BINDING_SERVER_GLOB);
@@ -234213,11 +234346,11 @@ function checkWorkspaceBindingBootstrap(projectDir, packageName) {
   return createDoctorCheck2("Binding bootstrap", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasServerGlob && hasEditorEnqueueHook && hasEditorScript && hasEditorAsset ? "Binding source PHP and editor bootstrap hooks are present" : "Missing binding source PHP require glob or editor enqueue hook");
 }
 function checkWorkspaceBindingSourcesIndex(projectDir, bindingSources) {
-  const indexRelativePath = [path59.join("src", "bindings", "index.ts"), path59.join("src", "bindings", "index.js")].find((relativePath) => fs45.existsSync(path59.join(projectDir, relativePath)));
+  const indexRelativePath = [path60.join("src", "bindings", "index.ts"), path60.join("src", "bindings", "index.js")].find((relativePath) => fs45.existsSync(path60.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Binding sources index", "fail", "Missing src/bindings/index.ts or src/bindings/index.js");
   }
-  const indexPath = path59.join(projectDir, indexRelativePath);
+  const indexPath = path60.join(projectDir, indexRelativePath);
   const source = fs45.readFileSync(indexPath, "utf8");
   const missingImports = bindingSources.filter((bindingSource) => !source.includes(`./${bindingSource.slug}/editor`));
   return createDoctorCheck2("Binding sources index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Binding source editor registrations are aggregated" : `Missing editor imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
@@ -234247,7 +234380,7 @@ function getWorkspaceRestResourceRequiredFiles(restResource) {
   }
   return Array.from(new Set([
     restResource.apiFile,
-    ...Array.from(schemaNames, (schemaName) => path59.join(path59.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
+    ...Array.from(schemaNames, (schemaName) => path60.join(path60.dirname(restResource.typesFile), "api-schemas", `${schemaName}.schema.json`)),
     restResource.clientFile,
     restResource.dataFile,
     restResource.openApiFile,
@@ -234263,9 +234396,9 @@ function checkWorkspaceRestResourceConfig(restResource) {
 }
 function checkWorkspaceRestResourceBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path59.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path60.join(projectDir, `${packageBaseName}.php`);
   if (!fs45.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path59.basename(bootstrapPath)}`);
+    return createDoctorCheck2("REST resource bootstrap", "fail", `Missing ${path60.basename(bootstrapPath)}`);
   }
   const source = fs45.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_rest_resources`;
@@ -234286,7 +234419,7 @@ function getWorkspaceAbilityRequiredFiles(ability) {
   ]));
 }
 function checkWorkspaceAbilityConfig(projectDir, ability) {
-  const configPath = path59.join(projectDir, ability.configFile);
+  const configPath = path60.join(projectDir, ability.configFile);
   if (!fs45.existsSync(configPath)) {
     return createDoctorCheck2(`Ability config ${ability.slug}`, "fail", `Missing ${ability.configFile}`);
   }
@@ -234303,9 +234436,9 @@ function checkWorkspaceAbilityConfig(projectDir, ability) {
 }
 function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path59.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path60.join(projectDir, `${packageBaseName}.php`);
   if (!fs45.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path59.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Ability bootstrap", "fail", `Missing ${path60.basename(bootstrapPath)}`);
   }
   const source = fs45.readFileSync(bootstrapPath, "utf8");
   const loadFunctionName = `${phpPrefix}_load_workflow_abilities`;
@@ -234319,17 +234452,18 @@ function checkWorkspaceAbilityBootstrap(projectDir, packageName, phpPrefix) {
   const hasServerGlob = source.includes(WORKSPACE_ABILITY_GLOB);
   const hasEditorScript = source.includes(WORKSPACE_ABILITY_EDITOR_SCRIPT);
   const hasEditorAsset = source.includes(WORKSPACE_ABILITY_EDITOR_ASSET);
-  return createDoctorCheck2("Ability bootstrap", hasLoaderHook && hasAdminEnqueueHook && hasEditorEnqueueHook && hasServerGlob && hasEditorScript && hasEditorAsset ? "pass" : "fail", hasLoaderHook && hasAdminEnqueueHook && hasEditorEnqueueHook && hasServerGlob && hasEditorScript && hasEditorAsset ? "Ability loader and admin/editor client bootstrap hooks are present" : "Missing ability loader hook or build/abilities script asset references");
+  const hasScriptModuleEnqueue = source.includes("wp_enqueue_script_module");
+  return createDoctorCheck2("Ability bootstrap", hasLoaderHook && hasAdminEnqueueHook && hasEditorEnqueueHook && hasServerGlob && hasEditorScript && hasEditorAsset && hasScriptModuleEnqueue ? "pass" : "fail", hasLoaderHook && hasAdminEnqueueHook && hasEditorEnqueueHook && hasServerGlob && hasEditorScript && hasEditorAsset && hasScriptModuleEnqueue ? "Ability loader and admin/editor script-module bootstrap hooks are present" : "Missing ability loader hook, script-module enqueue, or build/abilities asset references");
 }
 function checkWorkspaceAbilityIndex(projectDir, abilities) {
   const indexRelativePath = [
-    path59.join("src", "abilities", "index.ts"),
-    path59.join("src", "abilities", "index.js")
-  ].find((relativePath) => fs45.existsSync(path59.join(projectDir, relativePath)));
+    path60.join("src", "abilities", "index.ts"),
+    path60.join("src", "abilities", "index.js")
+  ].find((relativePath) => fs45.existsSync(path60.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Abilities index", "fail", "Missing src/abilities/index.ts or src/abilities/index.js");
   }
-  const indexPath = path59.join(projectDir, indexRelativePath);
+  const indexPath = path60.join(projectDir, indexRelativePath);
   const source = fs45.readFileSync(indexPath, "utf8");
   const missingExports = abilities.filter((ability) => {
     const exportPattern = new RegExp(`^\\s*export\\s+(?:\\*\\s+from|\\{[^}]+\\}\\s+from)\\s+['"\`]\\./${escapeRegex7(ability.slug)}\\/client['"\`]`, "mu");
@@ -234341,9 +234475,9 @@ function getWorkspaceAiFeatureRequiredFiles(aiFeature) {
   return Array.from(new Set([
     aiFeature.aiSchemaFile,
     aiFeature.apiFile,
-    path59.join(path59.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
-    path59.join(path59.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
-    path59.join(path59.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
+    path60.join(path60.dirname(aiFeature.typesFile), "api-schemas", "feature-request.schema.json"),
+    path60.join(path60.dirname(aiFeature.typesFile), "api-schemas", "feature-response.schema.json"),
+    path60.join(path60.dirname(aiFeature.typesFile), "api-schemas", "feature-result.schema.json"),
     aiFeature.clientFile,
     aiFeature.dataFile,
     aiFeature.openApiFile,
@@ -234358,9 +234492,9 @@ function checkWorkspaceAiFeatureConfig(aiFeature) {
 }
 function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path59.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path60.join(projectDir, `${packageBaseName}.php`);
   if (!fs45.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path59.basename(bootstrapPath)}`);
+    return createDoctorCheck2("AI feature bootstrap", "fail", `Missing ${path60.basename(bootstrapPath)}`);
   }
   const source = fs45.readFileSync(bootstrapPath, "utf8");
   const registerFunctionName = `${phpPrefix}_register_ai_features`;
@@ -234370,13 +234504,13 @@ function checkWorkspaceAiFeatureBootstrap(projectDir, packageName, phpPrefix) {
   return createDoctorCheck2("AI feature bootstrap", hasServerGlob && hasRegisterHook ? "pass" : "fail", hasServerGlob && hasRegisterHook ? "AI feature PHP loader hook is present" : "Missing AI feature PHP require glob or init hook");
 }
 function getWorkspaceEditorPluginRequiredFiles(editorPlugin) {
-  const editorPluginDir = path59.join("src", "editor-plugins", editorPlugin.slug);
+  const editorPluginDir = path60.join("src", "editor-plugins", editorPlugin.slug);
   return Array.from(new Set([
     editorPlugin.file,
-    path59.join(editorPluginDir, "Sidebar.tsx"),
-    path59.join(editorPluginDir, "data.ts"),
-    path59.join(editorPluginDir, "types.ts"),
-    path59.join(editorPluginDir, "style.scss")
+    path60.join(editorPluginDir, "Sidebar.tsx"),
+    path60.join(editorPluginDir, "data.ts"),
+    path60.join(editorPluginDir, "types.ts"),
+    path60.join(editorPluginDir, "style.scss")
   ]));
 }
 function checkWorkspaceEditorPluginConfig(editorPlugin) {
@@ -234386,9 +234520,9 @@ function checkWorkspaceEditorPluginConfig(editorPlugin) {
 }
 function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix) {
   const packageBaseName = packageName.split("/").pop() ?? packageName;
-  const bootstrapPath = path59.join(projectDir, `${packageBaseName}.php`);
+  const bootstrapPath = path60.join(projectDir, `${packageBaseName}.php`);
   if (!fs45.existsSync(bootstrapPath)) {
-    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path59.basename(bootstrapPath)}`);
+    return createDoctorCheck2("Editor plugin bootstrap", "fail", `Missing ${path60.basename(bootstrapPath)}`);
   }
   const source = fs45.readFileSync(bootstrapPath, "utf8");
   const enqueueFunctionName = `${phpPrefix}_enqueue_editor_plugins_editor`;
@@ -234401,13 +234535,13 @@ function checkWorkspaceEditorPluginBootstrap(projectDir, packageName, phpPrefix)
 }
 function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   const indexRelativePath = [
-    path59.join("src", "editor-plugins", "index.ts"),
-    path59.join("src", "editor-plugins", "index.js")
-  ].find((relativePath) => fs45.existsSync(path59.join(projectDir, relativePath)));
+    path60.join("src", "editor-plugins", "index.ts"),
+    path60.join("src", "editor-plugins", "index.js")
+  ].find((relativePath) => fs45.existsSync(path60.join(projectDir, relativePath)));
   if (!indexRelativePath) {
     return createDoctorCheck2("Editor plugins index", "fail", "Missing src/editor-plugins/index.ts or src/editor-plugins/index.js");
   }
-  const indexPath = path59.join(projectDir, indexRelativePath);
+  const indexPath = path60.join(projectDir, indexRelativePath);
   const source = fs45.readFileSync(indexPath, "utf8");
   const missingImports = editorPlugins.filter((editorPlugin) => {
     const importPattern = new RegExp(`['"\`]\\./${escapeRegex7(editorPlugin.slug)}(?:/[^'"\`]*)?['"\`]`, "u");
@@ -234416,9 +234550,9 @@ function checkWorkspaceEditorPluginIndex(projectDir, editorPlugins) {
   return createDoctorCheck2("Editor plugins index", missingImports.length === 0 ? "pass" : "fail", missingImports.length === 0 ? "Editor plugin registrations are aggregated" : `Missing editor plugin imports for: ${missingImports.map((entry) => entry.slug).join(", ")}`);
 }
 function checkVariationEntrypoint(projectDir, blockSlug) {
-  const entryPath = path59.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
+  const entryPath = path60.join(projectDir, "src", "blocks", blockSlug, "index.tsx");
   if (!fs45.existsSync(entryPath)) {
-    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path59.relative(projectDir, entryPath)}`);
+    return createDoctorCheck2(`Variation entrypoint ${blockSlug}`, "fail", `Missing ${path60.relative(projectDir, entryPath)}`);
   }
   const source = fs45.readFileSync(entryPath, "utf8");
   const hasImport = source.includes("./variations");
@@ -234427,8 +234561,8 @@ function checkVariationEntrypoint(projectDir, blockSlug) {
 }
 function checkMigrationWorkspaceHint(workspace, packageJson) {
   const hasMigrationScript = typeof packageJson.scripts?.["migration:doctor"] === "string";
-  const migrationConfigRelativePath = path59.join("src", "migrations", "config.ts");
-  const hasMigrationConfig = fs45.existsSync(path59.join(workspace.projectDir, migrationConfigRelativePath));
+  const migrationConfigRelativePath = path60.join("src", "migrations", "config.ts");
+  const hasMigrationConfig = fs45.existsSync(path60.join(workspace.projectDir, migrationConfigRelativePath));
   if (!hasMigrationScript && !hasMigrationConfig) {
     return null;
   }
@@ -234486,7 +234620,7 @@ function getWorkspaceDoctorChecks(cwd) {
     for (const blockSlug of variationTargetBlocks) {
       checks3.push(checkVariationEntrypoint(workspace.projectDir, blockSlug));
     }
-    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs45.existsSync(path59.join(workspace.projectDir, "src", "patterns"));
+    const shouldCheckPatternBootstrap = inventory.patterns.length > 0 || fs45.existsSync(path60.join(workspace.projectDir, "src", "patterns"));
     if (shouldCheckPatternBootstrap) {
       checks3.push(checkWorkspacePatternBootstrap(workspace.projectDir, workspace.packageName));
     }
@@ -234602,12 +234736,12 @@ __export(exports_cli_init, {
   getInitPlan: () => getInitPlan
 });
 import fs46 from "fs";
-import path60 from "path";
+import path61 from "path";
 function normalizeRelativePath2(value2) {
   return value2.replace(/\\/gu, "/");
 }
 function readProjectPackageJson(projectDir) {
-  const packageJsonPath = path60.join(projectDir, "package.json");
+  const packageJsonPath = path61.join(projectDir, "package.json");
   if (!fs46.existsSync(packageJsonPath)) {
     return null;
   }
@@ -234617,13 +234751,13 @@ function inferInitPackageManager(projectDir, packageJson) {
   if (packageJson?.packageManager) {
     return parseWorkspacePackageManagerId(packageJson.packageManager);
   }
-  if (fs46.existsSync(path60.join(projectDir, "bun.lock")) || fs46.existsSync(path60.join(projectDir, "bun.lockb"))) {
+  if (fs46.existsSync(path61.join(projectDir, "bun.lock")) || fs46.existsSync(path61.join(projectDir, "bun.lockb"))) {
     return "bun";
   }
-  if (fs46.existsSync(path60.join(projectDir, "pnpm-lock.yaml"))) {
+  if (fs46.existsSync(path61.join(projectDir, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs46.existsSync(path60.join(projectDir, "yarn.lock")) || fs46.existsSync(path60.join(projectDir, ".yarnrc.yml"))) {
+  if (fs46.existsSync(path61.join(projectDir, "yarn.lock")) || fs46.existsSync(path61.join(projectDir, ".yarnrc.yml"))) {
     return "yarn";
   }
   return "npm";
@@ -234698,13 +234832,13 @@ function buildPackageManagerFieldChange(packageJson, packageManager) {
   };
 }
 function buildGeneratedArtifactPaths(blockJsonFile, manifestFile) {
-  const manifestDir = path60.dirname(manifestFile);
+  const manifestDir = path61.dirname(manifestFile);
   const artifactPaths = [
     blockJsonFile,
     manifestFile,
-    path60.join(manifestDir, "typia.schema.json"),
-    path60.join(manifestDir, "typia-validator.php"),
-    path60.join(manifestDir, "typia.openapi.json")
+    path61.join(manifestDir, "typia.schema.json"),
+    path61.join(manifestDir, "typia-validator.php"),
+    path61.join(manifestDir, "typia.openapi.json")
   ];
   return Array.from(new Set(artifactPaths.map((filePath) => normalizeRelativePath2(filePath))));
 }
@@ -234816,7 +234950,7 @@ function buildRequiredDevDependencyMapEntries() {
   return Object.entries(buildRequiredDevDependencyMap()).map(([name2, version2]) => `${name2}@${version2.replace(/^workspace:/u, "")}`);
 }
 function getInitPlan(projectDir) {
-  const resolvedProjectDir = path60.resolve(projectDir);
+  const resolvedProjectDir = path61.resolve(projectDir);
   const packageJson = readProjectPackageJson(resolvedProjectDir);
   const packageManager = inferInitPackageManager(resolvedProjectDir, packageJson);
   const workspace = tryResolveWorkspaceProject(resolvedProjectDir);
@@ -234848,7 +234982,7 @@ function getInitPlan(projectDir) {
       summary: "This directory is already an official wp-typia workspace. No retrofit bootstrap is needed."
     };
   }
-  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path60.basename(resolvedProjectDir);
+  const projectName = typeof packageJson?.name === "string" && packageJson.name.length > 0 ? packageJson.name : path61.basename(resolvedProjectDir);
   const layout = buildLayoutDetails(resolvedProjectDir);
   const dependencyChanges = buildDependencyChanges(packageJson);
   const scriptChanges = buildScriptChanges(packageJson, packageManager);
@@ -234931,18 +235065,18 @@ __export(exports_cli_scaffold, {
 });
 import fs47 from "fs";
 import { promises as fsp23 } from "fs";
-import path61 from "path";
+import path62 from "path";
 async function listRelativeProjectFiles(rootDir) {
   const relativeFiles = [];
   async function visit2(currentDir) {
     const entries = await fsp23.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = path61.join(currentDir, entry.name);
+      const absolutePath = path62.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         await visit2(absolutePath);
         continue;
       }
-      relativeFiles.push(path61.relative(rootDir, absolutePath).replace(path61.sep === "\\" ? /\\/gu : /\//gu, "/"));
+      relativeFiles.push(path62.relative(rootDir, absolutePath).replace(path62.sep === "\\" ? /\\/gu : /\//gu, "/"));
     }
   }
   await visit2(rootDir);
@@ -234980,7 +235114,7 @@ async function buildScaffoldDryRunPlan({
 }) {
   await assertDryRunTargetDirectoryReady(projectDir, allowExistingDir);
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-scaffold-plan-");
-  const previewProjectDir = path61.join(tempRoot, "preview-project");
+  const previewProjectDir = path62.join(tempRoot, "preview-project");
   try {
     const result = await scaffoldProject({
       allowExistingDir: false,
@@ -235020,14 +235154,14 @@ function validateCreateProjectInput(projectInput) {
   if (normalizedProjectInput.length === 0) {
     throw new Error("Project directory is required. Usage: wp-typia create <project-dir> (or wp-typia <project-dir> when <project-dir> is the only positional argument).");
   }
-  const normalizedProjectPath = path61.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path61.normalize(normalizedProjectInput);
+  const normalizedProjectPath = path62.normalize(normalizedProjectInput).replace(/[\\/]+$/u, "") || path62.normalize(normalizedProjectInput);
   if (normalizedProjectPath === "." || normalizedProjectPath === "..") {
     throw new Error("`wp-typia create` requires a new project directory. Use an explicit child directory instead of `.` or `..`.");
   }
 }
 function collectProjectDirectoryWarnings(projectDir) {
   const warnings = [];
-  const projectName = path61.basename(projectDir);
+  const projectName = path62.basename(projectDir);
   if (/\s/u.test(projectName)) {
     warnings.push(`Project directory "${projectName}" contains spaces. The generated next-step commands will be quoted, but a simple kebab-case directory name is usually easier to use with shells and downstream tooling.`);
   }
@@ -235182,7 +235316,7 @@ function getNextSteps({
   noInstall,
   templateId
 }) {
-  const cdTarget = path61.isAbsolute(projectInput) ? projectDir : projectInput;
+  const cdTarget = path62.isAbsolute(projectInput) ? projectDir : projectInput;
   const steps = [`cd ${quoteShellValue(cdTarget)}`];
   if (noInstall) {
     steps.push(formatInstallCommand(packageManager));
@@ -235330,8 +235464,8 @@ async function runScaffoldFlow({
       select: selectWithMigrationUi,
       yes
     });
-    const projectDir = path61.resolve(cwd, projectInput);
-    const projectName = path61.basename(projectDir);
+    const projectDir = path62.resolve(cwd, projectInput);
+    const projectName = path62.basename(projectDir);
     const answers = await collectScaffoldAnswers({
       dataStorageMode: resolvedDataStorage,
       namespace,
@@ -235394,7 +235528,7 @@ async function runScaffoldFlow({
     let availableScripts;
     if (!dryRun) {
       try {
-        const parsedPackageJson = JSON.parse(fs47.readFileSync(path61.join(projectDir, "package.json"), "utf8"));
+        const parsedPackageJson = JSON.parse(fs47.readFileSync(path62.join(projectDir, "package.json"), "utf8"));
         const scripts = parsedPackageJson.scripts && typeof parsedPackageJson.scripts === "object" && !Array.isArray(parsedPackageJson.scripts) ? parsedPackageJson.scripts : {};
         availableScripts = Object.entries(scripts).filter(([, value2]) => typeof value2 === "string").map(([scriptName]) => scriptName);
       } catch {
@@ -288755,7 +288889,7 @@ import path10 from "path";
 // package.json
 var package_default2 = {
   name: "wp-typia",
-  version: "0.20.3",
+  version: "0.20.5",
   description: "Canonical CLI package for wp-typia scaffolding and project workflows",
   packageManager: "bun@1.3.11",
   type: "module",
@@ -288823,7 +288957,7 @@ var package_default2 = {
     "@bunli/tui": "0.6.0",
     "@bunli/utils": "0.6.0",
     "@wp-typia/api-client": "^0.4.5",
-    "@wp-typia/project-tools": "0.20.0",
+    "@wp-typia/project-tools": "0.20.2",
     "better-result": "^2.7.0",
     react: "^19.2.5",
     "react-dom": "^19.2.5",
@@ -290592,7 +290726,7 @@ init_cli_diagnostics();
 
 // src/mcp.ts
 import fs48 from "fs/promises";
-import path62 from "path";
+import path63 from "path";
 
 // ../../node_modules/.bun/@bunli+plugin-mcp@0.2.5+ef72ce197b058209/node_modules/@bunli/plugin-mcp/src/errors.ts
 class SchemaConversionError extends TaggedError("SchemaConversionError")() {
@@ -291120,7 +291254,7 @@ function isToolGroup(value2) {
   return isObject3(value2) && typeof value2.namespace === "string" && Array.isArray(value2.tools) && value2.tools.every(isTool);
 }
 async function readSchemaSource(cwd, source) {
-  const schemaPath = path62.resolve(cwd, source.path);
+  const schemaPath = path63.resolve(cwd, source.path);
   const raw = await fs48.readFile(schemaPath, "utf8");
   const parsed = JSON.parse(raw);
   if (isToolGroup(parsed)) {
@@ -291137,7 +291271,7 @@ async function readSchemaSource(cwd, source) {
 async function loadMcpToolGroups(cwd, schemaSources) {
   return Promise.all(schemaSources.map((source) => readSchemaSource(cwd, source)));
 }
-async function syncMcpSchemas(cwd, schemaSources, outputDir = path62.join(cwd, ".bunli", "mcp")) {
+async function syncMcpSchemas(cwd, schemaSources, outputDir = path63.join(cwd, ".bunli", "mcp")) {
   const groups = await loadMcpToolGroups(cwd, schemaSources);
   const result = await generateMCPTypes({
     outputDir,
@@ -291160,7 +291294,7 @@ async function syncMcpSchemas(cwd, schemaSources, outputDir = path62.join(cwd, "
     }
   }
   await fs48.mkdir(outputDir, { recursive: true });
-  await fs48.writeFile(path62.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
+  await fs48.writeFile(path63.join(outputDir, "registry.json"), `${JSON.stringify(registry2, null, 2)}
 `, "utf8");
   return {
     commandCount: registry2.reduce((count, group) => count + group.tools.length, 0),
@@ -291482,4 +291616,4 @@ export {
   cli
 };
 
-//# debugId=A86DAAF9631CE27D64756E2164756E21
+//# debugId=609DB696D1E292A064756E2164756E21