wp-typia 0.22.6 → 0.22.8

package/dist-bunli/{cli-add-5vmxpgmn.js → cli-add-1xvw17yg.js}

@@ -6,14 +6,12 @@ import {
   copyInterpolatedDirectory,
   createScaffoldCompatibilityConfig,
   getDefaultAnswers,
+  isCompoundPersistenceEnabled,
   listInterpolatedDirectoryOutputs,
   normalizeOptionalCliString,
   parseAlternateRenderTargets,
   parseCompoundInnerBlocksPreset,
-  parseTemplateLocator,
-  pathExists,
   renderScaffoldCompatibilityConfig,
-  require_semver,
   resolveExternalTemplateLayers,
   resolveLocalCliPathOption,
   resolveOptionalInteractiveExternalLayerId,
@@ -22,7 +20,7 @@ import {
   scaffoldProject,
   syncPersistenceRestArtifacts,
   updatePluginHeaderCompatibility
-} from "./cli-6a65qfb1.js";
+} from "./cli-fa7g1aqm.js";
 import {
   DEFAULT_WORDPRESS_ABILITIES_VERSION,
   DEFAULT_WORDPRESS_CORE_ABILITIES_VERSION,
@@ -32,10 +30,14 @@ import {
   DEFAULT_WP_TYPIA_DATAVIEWS_VERSION,
   getPackageVersions,
   resolveManagedPackageVersionRange
-} from "./cli-1sm60g1z.js";
+} from "./cli-arz4rcye.js";
+import {
+  parseTemplateLocator,
+  require_semver
+} from "./cli-mzvzbpnz.js";
 import {
   snapshotProjectVersion
-} from "./cli-0q0tz4dq.js";
+} from "./cli-bwwssctv.js";
 import {
   ensureMigrationDirectories,
   parseMigrationConfig,
@@ -49,10 +51,10 @@ import {
   hasUncommentedPattern,
   maskTypeScriptCommentsAndLiterals
 } from "./cli-rwjkqjhs.js";
-import"./cli-10pe4mf8.js";
+import"./cli-pnjx2e2h.js";
 import {
   SHARED_WORKSPACE_TEMPLATE_ROOT
-} from "./cli-tke8twkn.js";
+} from "./cli-qse6myha.js";
 import {
   ADD_BLOCK_TEMPLATE_IDS,
   EDITOR_PLUGIN_SLOT_IDS,
@@ -77,6 +79,7 @@ import {
   findPhpFunctionRange,
   formatAddHelpText,
   getMutableBlockHooks,
+  getPropertyNameText,
   getWorkspaceBlockSelectOptions,
   getWorkspaceBootstrapPath,
   hasPhpFunctionCall,
@@ -84,11 +87,13 @@ import {
   isAddBlockTemplateId,
   normalizeBlockSlug,
   patchFile,
+  pathExists,
   quotePhpString,
   quoteTsString,
   readOptionalFile,
+  readOptionalUtf8File,
   readWorkspaceBlockJson,
-  readWorkspaceInventory,
+  readWorkspaceInventoryAsync,
   replacePhpFunctionDefinition,
   require_typescript,
   resolveNonEmptyNormalizedBlockSlug,
@@ -101,7 +106,7 @@ import {
   toPascalCase,
   toSnakeCase,
   toTitleCase
-} from "./cli-5kn2p7ee.js";
+} from "./cli-bbj0kn1e.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -228,7 +233,7 @@ function buildConfigEntries(templateId, variables) {
   if (templateId === "persistence") {
     return [buildPersistenceBlockConfigEntry(variables)];
   }
-  if (variables.compoundPersistenceEnabled === "true") {
+  if (isCompoundPersistenceEnabled(variables)) {
     return [
       buildPersistenceBlockConfigEntry(variables),
       buildCompoundChildConfigEntry(variables)
@@ -504,7 +509,7 @@ async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir,
     await ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths);
     await copyTempDirectory(path3.join(tempProjectDir, "src", "blocks", variables.slugKebabCase), path3.join(projectDir, "src", "blocks", variables.slugKebabCase));
     await copyTempDirectory(path3.join(tempProjectDir, "src", "blocks", `${variables.slugKebabCase}-item`), path3.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`));
-    if (variables.compoundPersistenceEnabled === "true") {
+    if (isCompoundPersistenceEnabled(variables)) {
       await renderWorkspacePersistenceServerModule(projectDir, variables);
     }
     return;
@@ -617,7 +622,7 @@ async function syncWorkspaceAddedBlockArtifacts(projectDir, templateId, variable
   if (templateId === "compound") {
     await syncWorkspaceBlockMetadata(projectDir, `${variables.slugKebabCase}-item`, `${variables.pascalCase}ItemAttributes`, path3.join("src", "blocks", `${variables.slugKebabCase}-item`, "types.ts"));
   }
-  if (templateId === "persistence" || templateId === "compound" && variables.compoundPersistenceEnabled === "true") {
+  if (templateId === "persistence" || templateId === "compound" && isCompoundPersistenceEnabled(variables)) {
     await syncWorkspacePersistenceArtifacts(projectDir, variables);
   }
 }
@@ -772,7 +777,7 @@ async function runAddBlockCommand({
     try {
       await copyScaffoldedBlockSlice(workspace.projectDir, resolvedTemplateId, tempProjectDir, result.variables, legacyCompoundValidatorPaths);
       await addCollectionImportsForTemplate(workspace.projectDir, resolvedTemplateId, result.variables);
-      await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" || resolvedTemplateId === "compound" && result.variables.compoundPersistenceEnabled === "true");
+      await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" || resolvedTemplateId === "compound" && isCompoundPersistenceEnabled(result.variables));
       await syncWorkspaceAddedBlockArtifacts(workspace.projectDir, resolvedTemplateId, result.variables);
       await updateWorkspaceMigrationConfigIfPresent(workspace.projectDir, buildMigrationBlocks(resolvedTemplateId, result.variables));
       return {
@@ -794,10 +799,52 @@ async function runAddBlockCommand({
   }
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace.ts
-import fs5 from "fs";
 import { promises as fsp9 } from "fs";
 import path14 from "path";
 
+// ../wp-typia-project-tools/src/runtime/block-targets.ts
+var FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+function assertFullBlockName(blockName, flagName) {
+  const trimmed = blockName.trim();
+  if (!trimmed) {
+    throw new Error(`\`${flagName}\` requires a block name.`);
+  }
+  if (!FULL_BLOCK_NAME_PATTERN.test(trimmed)) {
+    throw new Error(`\`${flagName}\` must use <namespace/block-slug> format.`);
+  }
+  return trimmed;
+}
+function resolveWorkspaceBlockTargetName(blockName, namespace, diagnostics) {
+  const trimmed = blockName.trim();
+  if (!trimmed) {
+    throw new Error(diagnostics.empty());
+  }
+  const blockNameSegments = trimmed.split("/");
+  if (blockNameSegments.length > 2) {
+    throw new Error(diagnostics.invalidFormat(trimmed));
+  }
+  if (blockNameSegments.some((segment) => segment.trim() === "")) {
+    throw new Error(diagnostics.emptySegment(trimmed));
+  }
+  const [maybeNamespace, maybeSlug] = blockNameSegments.length === 2 ? blockNameSegments : [undefined, blockNameSegments[0]];
+  if (maybeNamespace && maybeNamespace !== namespace) {
+    throw new Error(diagnostics.namespaceMismatch(trimmed, maybeNamespace, namespace));
+  }
+  const blockSlug = normalizeBlockSlug(maybeSlug ?? "");
+  return {
+    blockName: `${namespace}/${blockSlug}`,
+    blockSlug
+  };
+}
+function resolveWorkspaceTargetBlockName(blockName, namespace, flagName) {
+  return resolveWorkspaceBlockTargetName(blockName, namespace, {
+    empty: () => `\`${flagName}\` requires <block-slug|namespace/block-slug>.`,
+    emptySegment: () => `\`${flagName}\` must use <block-slug|namespace/block-slug> format.`,
+    invalidFormat: () => `\`${flagName}\` must use <block-slug|namespace/block-slug> format.`,
+    namespaceMismatch: (_input, actualNamespace, expectedNamespace) => `\`${flagName}\` references namespace "${actualNamespace}". Expected "${expectedNamespace}".`
+  });
+}
+
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-types.ts
 var ADMIN_VIEW_REST_SOURCE_KIND = "rest-resource";
 var ADMIN_VIEW_CORE_DATA_SOURCE_KIND = "core-data";
@@ -905,7 +952,6 @@ function resolveAdminViewCoreDataSource(source) {
 }
 
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-admin-view-scaffold.ts
-import fs2 from "fs";
 import { promises as fsp3 } from "fs";
 import path5 from "path";
 
@@ -2086,26 +2132,31 @@ async function ensureAdminViewWebpackAnchors(workspace) {
     return nextSource;
   });
 }
-function resolveAdminViewRegistryPath(projectDir) {
+async function resolveAdminViewRegistryPath(projectDir) {
   const adminViewsDir = path5.join(projectDir, "src", "admin-views");
-  return [
+  for (const candidatePath of [
     path5.join(adminViewsDir, "index.ts"),
     path5.join(adminViewsDir, "index.js")
-  ].find((candidatePath) => fs2.existsSync(candidatePath)) ?? path5.join(adminViewsDir, "index.ts");
+  ]) {
+    if (await pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return path5.join(adminViewsDir, "index.ts");
 }
-function readAdminViewRegistrySlugs(registryPath) {
-  if (!fs2.existsSync(registryPath)) {
+async function readAdminViewRegistrySlugs(registryPath) {
+  const source = await readOptionalUtf8File(registryPath);
+  if (source === null) {
     return [];
   }
-  const source = fs2.readFileSync(registryPath, "utf8");
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeAdminViewRegistry(projectDir, adminViewSlug) {
   const adminViewsDir = path5.join(projectDir, "src", "admin-views");
-  const registryPath = resolveAdminViewRegistryPath(projectDir);
+  const registryPath = await resolveAdminViewRegistryPath(projectDir);
   await fsp3.mkdir(adminViewsDir, { recursive: true });
-  const existingAdminViewSlugs = readWorkspaceInventory(projectDir).adminViews.map((entry) => entry.slug);
-  const existingRegistrySlugs = readAdminViewRegistrySlugs(registryPath);
+  const existingAdminViewSlugs = (await readWorkspaceInventoryAsync(projectDir)).adminViews.map((entry) => entry.slug);
+  const existingRegistrySlugs = await readAdminViewRegistrySlugs(registryPath);
   const nextAdminViewSlugs = Array.from(new Set([
     ...existingAdminViewSlugs,
     ...existingRegistrySlugs,
@@ -2126,7 +2177,7 @@ async function scaffoldAdminViewWorkspace(options) {
   const buildScriptPath = path5.join(workspace.projectDir, "scripts", "build-workspace.mjs");
   const packageJsonPath = path5.join(workspace.projectDir, "package.json");
   const webpackConfigPath = path5.join(workspace.projectDir, "webpack.config.js");
-  const adminViewsIndexPath = resolveAdminViewRegistryPath(workspace.projectDir);
+  const adminViewsIndexPath = await resolveAdminViewRegistryPath(workspace.projectDir);
   const adminViewDir = path5.join(workspace.projectDir, "src", "admin-views", adminViewSlug);
   const adminViewPhpPath = path5.join(workspace.projectDir, "inc", "admin-views", `${adminViewSlug}.php`);
   await executeWorkspaceMutationPlan({
@@ -2174,7 +2225,7 @@ async function runAddAdminViewCommand({
   assertAdminViewPackageAvailability();
   const adminViewSlug = assertValidGeneratedSlug("Admin view name", normalizeBlockSlug(adminViewName), ADD_ADMIN_VIEW_USAGE);
   const parsedSource = parseAdminViewSource(source);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   const restResource = resolveRestResourceSource(inventory.restResources, parsedSource);
   const coreDataSource = resolveAdminViewCoreDataSource(parsedSource);
   assertAdminViewDoesNotExist(workspace.projectDir, adminViewSlug, inventory);
@@ -2193,7 +2244,6 @@ async function runAddAdminViewCommand({
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-assets.ts
 var import_typescript = __toESM(require_typescript(), 1);
-import fs3 from "fs";
 import { promises as fsp4 } from "fs";
 import path6 from "path";
 import {
@@ -2239,24 +2289,6 @@ function assertValidBindingAttributeName(attributeName) {
   }
   return trimmed;
 }
-function resolveBindingTargetBlockSlug(blockName, namespace) {
-  const trimmed = blockName.trim();
-  if (!trimmed) {
-    throw new Error("`wp-typia add binding-source` requires --block <block-slug|namespace/block-slug> to include a value when --attribute is provided.");
-  }
-  const blockNameSegments = trimmed.split("/");
-  if (blockNameSegments.length > 2) {
-    throw new Error(`Binding target block "${trimmed}" must use <block-slug> or <namespace/block-slug> format.`);
-  }
-  if (blockNameSegments.some((segment) => segment.trim() === "")) {
-    throw new Error(`Binding target block "${trimmed}" must use <block-slug> or <namespace/block-slug> format without empty path segments.`);
-  }
-  const [maybeNamespace, maybeSlug] = blockNameSegments.length === 2 ? blockNameSegments : [undefined, blockNameSegments[0]];
-  if (maybeNamespace && maybeNamespace !== namespace) {
-    throw new Error(`Binding target block "${trimmed}" uses namespace "${maybeNamespace}". Expected "${namespace}".`);
-  }
-  return normalizeBlockSlug(maybeSlug ?? "");
-}
 function buildEditorPluginConfigEntry(editorPluginSlug, slot) {
   return [
     "\t{",
@@ -2421,9 +2453,15 @@ function resolveBindingTarget(options, namespace) {
   if (!hasBlock || !hasAttribute) {
     throw new Error("`wp-typia add binding-source` requires --block and --attribute to be provided together.");
   }
+  const targetBlock = resolveWorkspaceBlockTargetName(blockName ?? "", namespace, {
+    empty: () => "`wp-typia add binding-source` requires --block <block-slug|namespace/block-slug> to include a value when --attribute is provided.",
+    emptySegment: (input) => `Binding target block "${input}" must use <block-slug> or <namespace/block-slug> format without empty path segments.`,
+    invalidFormat: (input) => `Binding target block "${input}" must use <block-slug> or <namespace/block-slug> format.`,
+    namespaceMismatch: (input, actualNamespace, expectedNamespace) => `Binding target block "${input}" uses namespace "${actualNamespace}". Expected "${expectedNamespace}".`
+  });
   return {
     attributeName: assertValidBindingAttributeName(attributeName ?? ""),
-    blockSlug: resolveBindingTargetBlockSlug(blockName ?? "", namespace)
+    blockSlug: targetBlock.blockSlug
   };
 }
 function formatBindingAttributeTypeMember(attributeName) {
@@ -2449,12 +2487,6 @@ function getInterfaceDeclaration(source, interfaceName) {
   visit(sourceFile);
   return declaration ? { declaration, sourceFile } : undefined;
 }
-function getPropertyNameText(name) {
-  if (import_typescript.default.isIdentifier(name) || import_typescript.default.isStringLiteral(name) || import_typescript.default.isNumericLiteral(name)) {
-    return name.text;
-  }
-  return;
-}
 function interfaceHasAttributeMember(declaration, attributeName) {
   return declaration.members.some((member) => import_typescript.default.isPropertySignature(member) && member.name !== undefined && getPropertyNameText(member.name) === attributeName);
 }
@@ -2931,38 +2963,51 @@ async function ensureEditorPluginWebpackAnchors(workspace) {
     return nextSource;
   });
 }
-function resolveBindingSourceRegistryPath(projectDir) {
+async function resolveBindingSourceRegistryPath(projectDir) {
   const bindingsDir = path6.join(projectDir, "src", "bindings");
-  return [path6.join(bindingsDir, "index.ts"), path6.join(bindingsDir, "index.js")].find((candidatePath) => fs3.existsSync(candidatePath)) ?? path6.join(bindingsDir, "index.ts");
+  for (const candidatePath of [
+    path6.join(bindingsDir, "index.ts"),
+    path6.join(bindingsDir, "index.js")
+  ]) {
+    if (await pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return path6.join(bindingsDir, "index.ts");
 }
 async function writeBindingSourceRegistry(projectDir, bindingSourceSlug) {
   const bindingsDir = path6.join(projectDir, "src", "bindings");
-  const bindingsIndexPath = resolveBindingSourceRegistryPath(projectDir);
+  const bindingsIndexPath = await resolveBindingSourceRegistryPath(projectDir);
   await fsp4.mkdir(bindingsDir, { recursive: true });
-  const existingBindingSourceSlugs = fs3.readdirSync(bindingsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  const existingBindingSourceSlugs = (await fsp4.readdir(bindingsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
   const nextBindingSourceSlugs = Array.from(new Set([...existingBindingSourceSlugs, bindingSourceSlug])).sort();
   await fsp4.writeFile(bindingsIndexPath, buildBindingSourceIndexSource(nextBindingSourceSlugs), "utf8");
 }
-function resolveEditorPluginRegistryPath(projectDir) {
+async function resolveEditorPluginRegistryPath(projectDir) {
   const editorPluginsDir = path6.join(projectDir, "src", "editor-plugins");
-  return [
+  for (const candidatePath of [
     path6.join(editorPluginsDir, "index.ts"),
     path6.join(editorPluginsDir, "index.js")
-  ].find((candidatePath) => fs3.existsSync(candidatePath)) ?? path6.join(editorPluginsDir, "index.ts");
+  ]) {
+    if (await pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return path6.join(editorPluginsDir, "index.ts");
 }
-function readEditorPluginRegistrySlugs(registryPath) {
-  if (!fs3.existsSync(registryPath)) {
+async function readEditorPluginRegistrySlugs(registryPath) {
+  const source = await readOptionalUtf8File(registryPath);
+  if (source === null) {
     return [];
   }
-  const source = fs3.readFileSync(registryPath, "utf8");
   return Array.from(source.matchAll(/^\s*import\s+['"]\.\/([^/'"]+)(?:\/index(?:\.[cm]?[jt]sx?)?)?['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeEditorPluginRegistry(projectDir, editorPluginSlug) {
   const editorPluginsDir = path6.join(projectDir, "src", "editor-plugins");
-  const registryPath = resolveEditorPluginRegistryPath(projectDir);
+  const registryPath = await resolveEditorPluginRegistryPath(projectDir);
   await fsp4.mkdir(editorPluginsDir, { recursive: true });
-  const existingEditorPluginSlugs = readWorkspaceInventory(projectDir).editorPlugins.map((entry) => entry.slug);
-  const existingRegistrySlugs = readEditorPluginRegistrySlugs(registryPath);
+  const existingEditorPluginSlugs = (await readWorkspaceInventoryAsync(projectDir)).editorPlugins.map((entry) => entry.slug);
+  const existingRegistrySlugs = await readEditorPluginRegistrySlugs(registryPath);
   const nextEditorPluginSlugs = Array.from(new Set([...existingEditorPluginSlugs, ...existingRegistrySlugs, editorPluginSlug])).sort();
   await fsp4.writeFile(registryPath, buildEditorPluginRegistrySource(nextEditorPluginSlugs), "utf8");
 }
@@ -2974,12 +3019,12 @@ async function runAddEditorPluginCommand({
   const workspace = resolveWorkspaceProject(cwd);
   const editorPluginSlug = assertValidGeneratedSlug("Editor plugin name", normalizeBlockSlug(editorPluginName), "wp-typia add editor-plugin <name> [--slot <sidebar|document-setting-panel>]");
   const resolvedSlot = assertValidEditorPluginSlot(slot);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   assertEditorPluginDoesNotExist(workspace.projectDir, editorPluginSlug, inventory);
   const blockConfigPath = path6.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
   const buildScriptPath = path6.join(workspace.projectDir, "scripts", "build-workspace.mjs");
-  const editorPluginsIndexPath = resolveEditorPluginRegistryPath(workspace.projectDir);
+  const editorPluginsIndexPath = await resolveEditorPluginRegistryPath(workspace.projectDir);
   const webpackConfigPath = path6.join(workspace.projectDir, "webpack.config.js");
   const editorPluginDir = path6.join(workspace.projectDir, "src", "editor-plugins", editorPluginSlug);
   const entryFilePath = path6.join(editorPluginDir, "index.tsx");
@@ -3030,7 +3075,7 @@ async function runAddPatternCommand({
 }) {
   const workspace = resolveWorkspaceProject(cwd);
   const patternSlug = assertValidGeneratedSlug("Pattern name", normalizeBlockSlug(patternName), "wp-typia add pattern <name>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   assertPatternDoesNotExist(workspace.projectDir, patternSlug, inventory);
   const blockConfigPath = path6.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
@@ -3064,7 +3109,7 @@ async function runAddBindingSourceCommand({
 }) {
   const workspace = resolveWorkspaceProject(cwd);
   const bindingSourceSlug = assertValidGeneratedSlug("Binding source name", normalizeBlockSlug(bindingSourceName), "wp-typia add binding-source <name> [--block <block-slug|namespace/block-slug> --attribute <attribute>]");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   assertBindingSourceDoesNotExist(workspace.projectDir, bindingSourceSlug, inventory);
   const target = resolveBindingTarget({
     attributeName,
@@ -3073,7 +3118,7 @@ async function runAddBindingSourceCommand({
   const targetBlock = target ? resolveWorkspaceBlock(inventory, target.blockSlug) : undefined;
   const blockConfigPath = path6.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
-  const bindingsIndexPath = resolveBindingSourceRegistryPath(workspace.projectDir);
+  const bindingsIndexPath = await resolveBindingSourceRegistryPath(workspace.projectDir);
   const bindingSourceDir = path6.join(workspace.projectDir, "src", "bindings", bindingSourceSlug);
   const serverFilePath = path6.join(bindingSourceDir, "server.php");
   const editorFilePath = path6.join(bindingSourceDir, "editor.ts");
@@ -4258,7 +4303,7 @@ async function runAddRestResourceCommand({
   const restResourceSlug = assertValidGeneratedSlug("REST resource name", normalizeBlockSlug(restResourceName), "wp-typia add rest-resource <name> [--namespace <vendor/v1>] [--methods <list,read,create>]");
   const resolvedMethods = assertValidRestResourceMethods(methods);
   const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   assertRestResourceDoesNotExist(workspace.projectDir, restResourceSlug, inventory);
   const blockConfigPath = path9.join(workspace.projectDir, "scripts", "block-config.ts");
   const bootstrapPath = getWorkspaceBootstrapPath(workspace);
@@ -4321,7 +4366,6 @@ async function runAddRestResourceCommand({
 }
 // ../wp-typia-project-tools/src/runtime/cli-add-workspace-ability-scaffold.ts
 var import_semver = __toESM(require_semver(), 1);
-import fs4 from "fs";
 import { promises as fsp6 } from "fs";
 import path10 from "path";
 import { syncTypeSchemas as syncTypeSchemas2 } from "@wp-typia/block-runtime/metadata-core";
@@ -4813,26 +4857,34 @@ function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
   }
   return import_semver.default.gte(existingMinimum, requiredMinimum) ? existingVersion : requiredVersion;
 }
-function resolveAbilityRegistryPath(projectDir) {
+async function resolveAbilityRegistryPath(projectDir) {
   const abilitiesDir = path10.join(projectDir, "src", "abilities");
-  return [path10.join(abilitiesDir, "index.ts"), path10.join(abilitiesDir, "index.js")].find((candidatePath) => fs4.existsSync(candidatePath)) ?? path10.join(abilitiesDir, "index.ts");
+  for (const candidatePath of [
+    path10.join(abilitiesDir, "index.ts"),
+    path10.join(abilitiesDir, "index.js")
+  ]) {
+    if (await pathExists(candidatePath)) {
+      return candidatePath;
+    }
+  }
+  return path10.join(abilitiesDir, "index.ts");
 }
-function readAbilityRegistrySlugs(registryPath) {
-  if (!fs4.existsSync(registryPath)) {
+async function readAbilityRegistrySlugs(registryPath) {
+  const source = await readOptionalUtf8File(registryPath);
+  if (source === null) {
     return [];
   }
-  const source = fs4.readFileSync(registryPath, "utf8");
-  return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client['"];?\s*$/gmu)).map((match) => match[1]);
+  return Array.from(source.matchAll(/^\s*export\s+\*\s+from\s+['"]\.\/([^/'"]+)\/client(?:\.[cm]?[jt]sx?)?['"];?\s*$/gmu)).map((match) => match[1]);
 }
 async function writeAbilityRegistry(projectDir, abilitySlug) {
   const abilitiesDir = path10.join(projectDir, "src", "abilities");
-  const registryPath = resolveAbilityRegistryPath(projectDir);
+  const registryPath = await resolveAbilityRegistryPath(projectDir);
   await fsp6.mkdir(abilitiesDir, { recursive: true });
-  const existingAbilitySlugs = readWorkspaceInventory(projectDir).abilities.map((entry) => entry.slug);
-  const existingRegistrySlugs = readAbilityRegistrySlugs(registryPath);
+  const existingAbilitySlugs = (await readWorkspaceInventoryAsync(projectDir)).abilities.map((entry) => entry.slug);
+  const existingRegistrySlugs = await readAbilityRegistrySlugs(registryPath);
   const nextAbilitySlugs = Array.from(new Set([...existingAbilitySlugs, ...existingRegistrySlugs, abilitySlug])).sort();
   const generatedSection = buildAbilityRegistrySource(nextAbilitySlugs);
-  const existingSource = fs4.existsSync(registryPath) ? fs4.readFileSync(registryPath, "utf8") : "";
+  const existingSource = await readOptionalUtf8File(registryPath) ?? "";
   const generatedSectionPattern = new RegExp(`${escapeRegex(ABILITY_REGISTRY_START_MARKER)}[\\s\\S]*?${escapeRegex(ABILITY_REGISTRY_END_MARKER)}\\n?`, "u");
   const nextSource = existingSource ? generatedSectionPattern.test(existingSource) ? existingSource.replace(generatedSectionPattern, generatedSection) : `${existingSource.trimEnd()}
 
@@ -5101,7 +5153,7 @@ async function scaffoldAbilityWorkspace({
   const syncAbilitiesScriptPath = path10.join(workspace.projectDir, "scripts", "sync-abilities.ts");
   const syncProjectScriptPath = path10.join(workspace.projectDir, "scripts", "sync-project.ts");
   const webpackConfigPath = path10.join(workspace.projectDir, "webpack.config.js");
-  const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
+  const abilitiesIndexPath = await resolveAbilityRegistryPath(workspace.projectDir);
   const abilityDir = path10.join(workspace.projectDir, "src", "abilities", abilitySlug);
   const configFilePath = path10.join(abilityDir, "ability.config.json");
   const typesFilePath = path10.join(abilityDir, "types.ts");
@@ -5172,7 +5224,7 @@ async function runAddAbilityCommand({
 }) {
   const workspace = resolveWorkspaceProject(cwd);
   const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
   const scaffoldResult = await scaffoldAbilityWorkspace({
@@ -6714,7 +6766,7 @@ async function runAddAiFeatureCommand({
   const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
   const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
   const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
   const scaffoldResult = await scaffoldAiFeatureWorkspace({
     aiFeatureSlug,
@@ -6744,7 +6796,6 @@ var BLOCK_TRANSFORMS_IMPORT_PATTERN = /^\s*import\s*\{\s*applyWorkspaceBlockTran
 var BLOCK_TRANSFORMS_CALL_LINE = "applyWorkspaceBlockTransforms(registration.settings);";
 var BLOCK_TRANSFORMS_CALL_PATTERN = /applyWorkspaceBlockTransforms\s*\(\s*registration\s*\.\s*settings\s*\)\s*;?/u;
 var SCAFFOLD_REGISTRATION_SETTINGS_CALL_PATTERN = /registerScaffoldBlockType\s*\(\s*registration\s*\.\s*name\s*,\s*registration\s*\.\s*settings\s*\)\s*;?/u;
-var FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
 function isIdentifierBoundary(source, index) {
   if (index < 0 || index >= source.length) {
     return true;
@@ -7117,7 +7168,7 @@ async function writeVariationRegistry(projectDir, blockSlug, variationSlug) {
   const variationsDir = path14.join(projectDir, "src", "blocks", blockSlug, "variations");
   const variationsIndexPath = path14.join(variationsDir, "index.ts");
   await fsp9.mkdir(variationsDir, { recursive: true });
-  const existingVariationSlugs = fs5.readdirSync(variationsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const existingVariationSlugs = (await fsp9.readdir(variationsDir)).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextVariationSlugs = Array.from(new Set([...existingVariationSlugs, variationSlug])).sort();
   await fsp9.writeFile(variationsIndexPath, buildVariationIndexSource(nextVariationSlugs), "utf8");
 }
@@ -7125,7 +7176,7 @@ async function writeBlockStyleRegistry(projectDir, blockSlug, styleSlug) {
   const stylesDir = path14.join(projectDir, "src", "blocks", blockSlug, "styles");
   const stylesIndexPath = path14.join(stylesDir, "index.ts");
   await fsp9.mkdir(stylesDir, { recursive: true });
-  const existingStyleSlugs = fs5.readdirSync(stylesDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const existingStyleSlugs = (await fsp9.readdir(stylesDir)).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextStyleSlugs = Array.from(new Set([...existingStyleSlugs, styleSlug])).sort();
   await fsp9.writeFile(stylesIndexPath, buildBlockStyleIndexSource(nextStyleSlugs), "utf8");
 }
@@ -7133,39 +7184,10 @@ async function writeBlockTransformRegistry(projectDir, blockSlug, transformSlug)
   const transformsDir = path14.join(projectDir, "src", "blocks", blockSlug, "transforms");
   const transformsIndexPath = path14.join(transformsDir, "index.ts");
   await fsp9.mkdir(transformsDir, { recursive: true });
-  const existingTransformSlugs = fs5.readdirSync(transformsDir).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
+  const existingTransformSlugs = (await fsp9.readdir(transformsDir)).filter((entry) => entry.endsWith(".ts") && entry !== "index.ts").map((entry) => entry.replace(/\.ts$/u, ""));
   const nextTransformSlugs = Array.from(new Set([...existingTransformSlugs, transformSlug])).sort();
   await fsp9.writeFile(transformsIndexPath, buildBlockTransformIndexSource(nextTransformSlugs), "utf8");
 }
-function assertFullBlockName(blockName, flagName) {
-  const trimmed = blockName.trim();
-  if (!trimmed) {
-    throw new Error(`\`${flagName}\` requires a block name.`);
-  }
-  if (!FULL_BLOCK_NAME_PATTERN.test(trimmed)) {
-    throw new Error(`\`${flagName}\` must use <namespace/block-slug> format.`);
-  }
-  return trimmed;
-}
-function resolveWorkspaceTargetBlockName(blockName, namespace, flagName) {
-  const trimmed = blockName.trim();
-  if (!trimmed) {
-    throw new Error(`\`${flagName}\` requires <block-slug|namespace/block-slug>.`);
-  }
-  const blockNameSegments = trimmed.split("/");
-  if (blockNameSegments.length > 2 || blockNameSegments.some((segment) => segment.trim() === "")) {
-    throw new Error(`\`${flagName}\` must use <block-slug|namespace/block-slug> format.`);
-  }
-  const [maybeNamespace, maybeSlug] = blockNameSegments.length === 2 ? blockNameSegments : [undefined, blockNameSegments[0]];
-  if (maybeNamespace && maybeNamespace !== namespace) {
-    throw new Error(`\`${flagName}\` references namespace "${maybeNamespace}". Expected "${namespace}".`);
-  }
-  const blockSlug = normalizeBlockSlug(maybeSlug ?? "");
-  return {
-    blockName: `${namespace}/${blockSlug}`,
-    blockSlug
-  };
-}
 async function runAddVariationCommand({
   blockName,
   cwd = process.cwd(),
@@ -7174,7 +7196,7 @@ async function runAddVariationCommand({
   const workspace = resolveWorkspaceProject(cwd);
   const blockSlug = normalizeBlockSlug(blockName);
   const variationSlug = assertValidGeneratedSlug("Variation name", normalizeBlockSlug(variationName), "wp-typia add variation <name> --block <block-slug>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertVariationDoesNotExist(workspace.projectDir, blockSlug, variationSlug, inventory);
   const blockConfigPath = path14.join(workspace.projectDir, "scripts", "block-config.ts");
@@ -7182,7 +7204,7 @@ async function runAddVariationCommand({
   const variationsDir = path14.join(workspace.projectDir, "src", "blocks", blockSlug, "variations");
   const variationFilePath = path14.join(variationsDir, `${variationSlug}.ts`);
   const variationsIndexPath = path14.join(variationsDir, "index.ts");
-  const shouldRemoveVariationsDirOnRollback = !fs5.existsSync(variationsDir);
+  const shouldRemoveVariationsDirOnRollback = !await pathExists(variationsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -7221,7 +7243,7 @@ async function runAddBlockStyleCommand({
   const workspace = resolveWorkspaceProject(cwd);
   const blockSlug = normalizeBlockSlug(blockName);
   const styleSlug = assertValidGeneratedSlug("Style name", normalizeBlockSlug(styleName), "wp-typia add style <name> --block <block-slug>");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   assertBlockStyleDoesNotExist(workspace.projectDir, blockSlug, styleSlug, inventory);
   const blockConfigPath = path14.join(workspace.projectDir, "scripts", "block-config.ts");
@@ -7229,7 +7251,7 @@ async function runAddBlockStyleCommand({
   const stylesDir = path14.join(workspace.projectDir, "src", "blocks", blockSlug, "styles");
   const styleFilePath = path14.join(stylesDir, `${styleSlug}.ts`);
   const stylesIndexPath = path14.join(stylesDir, "index.ts");
-  const shouldRemoveStylesDirOnRollback = !fs5.existsSync(stylesDir);
+  const shouldRemoveStylesDirOnRollback = !await pathExists(stylesDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -7270,7 +7292,7 @@ async function runAddBlockTransformCommand({
   const transformSlug = assertValidGeneratedSlug("Transform name", normalizeBlockSlug(transformName), "wp-typia add transform <name> --from <namespace/block> --to <block-slug|namespace/block-slug>");
   const resolvedFromBlockName = assertFullBlockName(fromBlockName, "--from");
   const target = resolveWorkspaceTargetBlockName(toBlockName, workspace.workspace.namespace, "--to");
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   resolveWorkspaceBlock(inventory, target.blockSlug);
   assertBlockTransformDoesNotExist(workspace.projectDir, target.blockSlug, transformSlug, inventory);
   const blockConfigPath = path14.join(workspace.projectDir, "scripts", "block-config.ts");
@@ -7278,7 +7300,7 @@ async function runAddBlockTransformCommand({
   const transformsDir = path14.join(workspace.projectDir, "src", "blocks", target.blockSlug, "transforms");
   const transformFilePath = path14.join(transformsDir, `${transformSlug}.ts`);
   const transformsIndexPath = path14.join(transformsDir, "index.ts");
-  const shouldRemoveTransformsDirOnRollback = !fs5.existsSync(transformsDir);
+  const shouldRemoveTransformsDirOnRollback = !await pathExists(transformsDir);
   const mutationSnapshot = {
     fileSources: await snapshotWorkspaceFiles([
       blockConfigPath,
@@ -7330,7 +7352,7 @@ async function runAddHookedBlockCommand({
 }) {
   const workspace = resolveWorkspaceProject(cwd);
   const blockSlug = normalizeBlockSlug(blockName);
-  const inventory = readWorkspaceInventory(workspace.projectDir);
+  const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
   resolveWorkspaceBlock(inventory, blockSlug);
   const resolvedAnchorBlockName = assertValidHookAnchor(anchorBlockName);
   const resolvedPosition = assertValidHookedBlockPosition(position);
@@ -7338,7 +7360,7 @@ async function runAddHookedBlockCommand({
   if (resolvedAnchorBlockName === selfHookAnchor) {
     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 { blockJson, blockJsonPath } = await readWorkspaceBlockJson(workspace.projectDir, blockSlug);
   const blockJsonRelativePath = path14.relative(workspace.projectDir, blockJsonPath);
   const blockHooks = getMutableBlockHooks(blockJson, blockJsonRelativePath);
   if (Object.prototype.hasOwnProperty.call(blockHooks, resolvedAnchorBlockName)) {
@@ -7385,4 +7407,4 @@ export {
   ADD_BLOCK_TEMPLATE_IDS
 };
 
-//# debugId=24FCFA027181E91A64756E2164756E21
+//# debugId=D2A71082E757E7C764756E2164756E21