@wp-typia/project-tools 0.22.7 → 0.22.9

package/dist/runtime/block-targets.d.ts

@@ -0,0 +1,40 @@
+export interface WorkspaceBlockTargetName {
+    blockName: string;
+    blockSlug: string;
+}
+export interface WorkspaceBlockTargetDiagnostics {
+    empty: () => string;
+    emptySegment: (input: string) => string;
+    invalidFormat: (input: string) => string;
+    namespaceMismatch: (input: string, actualNamespace: string, expectedNamespace: string) => string;
+}
+/**
+ * Validate a full `namespace/block-slug` block name.
+ *
+ * @param blockName Candidate block name.
+ * @param flagName CLI flag name used in diagnostics.
+ * @returns The trimmed full block name.
+ * @throws {Error} When the block name is empty or not a full block name.
+ */
+export declare function assertFullBlockName(blockName: string, flagName: string): string;
+/**
+ * Resolve a workspace block target from either `block-slug` or
+ * `namespace/block-slug` input while preserving caller-owned diagnostics.
+ *
+ * @param blockName Candidate block target.
+ * @param namespace Expected workspace namespace.
+ * @param diagnostics Error message builders for the caller's UX context.
+ * @returns The normalized workspace block target.
+ * @throws {Error} When the target is empty, malformed, or references another namespace.
+ */
+export declare function resolveWorkspaceBlockTargetName(blockName: string, namespace: string, diagnostics: WorkspaceBlockTargetDiagnostics): WorkspaceBlockTargetName;
+/**
+ * Resolve the standard `--to` style workspace block target used by add flows.
+ *
+ * @param blockName Candidate block target.
+ * @param namespace Expected workspace namespace.
+ * @param flagName CLI flag name used in diagnostics.
+ * @returns The normalized workspace block target.
+ * @throws {Error} When the target is empty, malformed, or references another namespace.
+ */
+export declare function resolveWorkspaceTargetBlockName(blockName: string, namespace: string, flagName: string): WorkspaceBlockTargetName;

package/dist/runtime/block-targets.js

@@ -0,0 +1,71 @@
+import { normalizeBlockSlug } from "./scaffold-identifiers.js";
+const FULL_BLOCK_NAME_PATTERN = /^[a-z0-9-]+\/[a-z0-9-]+$/u;
+/**
+ * Validate a full `namespace/block-slug` block name.
+ *
+ * @param blockName Candidate block name.
+ * @param flagName CLI flag name used in diagnostics.
+ * @returns The trimmed full block name.
+ * @throws {Error} When the block name is empty or not a full block name.
+ */
+export 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;
+}
+/**
+ * Resolve a workspace block target from either `block-slug` or
+ * `namespace/block-slug` input while preserving caller-owned diagnostics.
+ *
+ * @param blockName Candidate block target.
+ * @param namespace Expected workspace namespace.
+ * @param diagnostics Error message builders for the caller's UX context.
+ * @returns The normalized workspace block target.
+ * @throws {Error} When the target is empty, malformed, or references another namespace.
+ */
+export 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,
+    };
+}
+/**
+ * Resolve the standard `--to` style workspace block target used by add flows.
+ *
+ * @param blockName Candidate block target.
+ * @param namespace Expected workspace namespace.
+ * @param flagName CLI flag name used in diagnostics.
+ * @returns The normalized workspace block target.
+ * @throws {Error} When the target is empty, malformed, or references another namespace.
+ */
+export 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}".`,
+    });
+}

package/dist/runtime/built-in-block-artifact-types.js

@@ -1,3 +1,4 @@
+import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
 const STANDARD_PREAMBLE_LINES = [
     'import type { TextAlignment } from "@wp-typia/block-types/block-editor/alignment";',
     "import type {",
@@ -216,7 +217,7 @@ export function buildPersistenceTypesSource(variables, attributes) {
  * @returns TypeScript source for the compound parent runtime types.
  */
 export function buildCompoundTypesSource(variables, attributes) {
-    const persistenceEnabled = variables.compoundPersistenceEnabled === "true";
+    const persistenceEnabled = isCompoundPersistenceEnabled(variables);
     return emitTypesModule({
         preambleLines: persistenceEnabled
             ? [...STANDARD_PREAMBLE_LINES]

package/dist/runtime/built-in-block-attribute-specs.js

@@ -1,3 +1,4 @@
+import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
 import { DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER, buildAttributesFromSpecs, describe, } from "./built-in-block-attribute-emitters.js";
 const ALIGNMENT_VALUES = ["left", "center", "right"];
 const BASIC_ALIGNMENT_VALUES = ["left", "center", "right", "justify"];
@@ -334,7 +335,7 @@ export function buildPersistenceAttributes(variables) {
  * @returns Emitted attribute definitions for the compound parent artifact.
  */
 export function buildCompoundParentAttributes(variables) {
-    return buildAttributesFromSpecs(variables.compoundPersistenceEnabled === "true"
+    return buildAttributesFromSpecs(isCompoundPersistenceEnabled(variables)
         ? [
             ...COMPOUND_PARENT_BASE_ATTRIBUTE_SPECS,
             ...COMPOUND_PARENT_PERSISTENCE_ATTRIBUTE_SPECS,

package/dist/runtime/built-in-block-code-artifacts.js

@@ -1,8 +1,10 @@
 import { buildBuiltInNonTsArtifacts } from "./built-in-block-non-ts-artifacts.js";
 import { BASIC_EDIT_TEMPLATE, BASIC_INDEX_TEMPLATE, BASIC_SAVE_TEMPLATE, BASIC_VALIDATORS_TEMPLATE, BLOCK_METADATA_WRAPPER_TEMPLATE, COMPOUND_CHILD_EDIT_TEMPLATE, COMPOUND_CHILD_INDEX_TEMPLATE, COMPOUND_CHILD_SAVE_TEMPLATE, COMPOUND_CHILD_VALIDATORS_TEMPLATE, COMPOUND_CHILDREN_TEMPLATE, COMPOUND_LOCAL_HOOKS_TEMPLATE, COMPOUND_PARENT_EDIT_TEMPLATE, COMPOUND_PARENT_INDEX_TEMPLATE, COMPOUND_PARENT_SAVE_TEMPLATE, COMPOUND_PARENT_VALIDATORS_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_EDIT_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_INTERACTIVITY_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_SAVE_TEMPLATE, COMPOUND_PERSISTENCE_PARENT_VALIDATORS_TEMPLATE, INTERACTIVITY_EDIT_TEMPLATE, INTERACTIVITY_INDEX_TEMPLATE, INTERACTIVITY_SAVE_TEMPLATE, INTERACTIVITY_SCRIPT_TEMPLATE, INTERACTIVITY_STORE_TEMPLATE, INTERACTIVITY_VALIDATORS_TEMPLATE, MANIFEST_DEFAULTS_DOCUMENT_WRAPPER_TEMPLATE, MANIFEST_DOCUMENT_WRAPPER_TEMPLATE, PERSISTENCE_EDIT_TEMPLATE, PERSISTENCE_INDEX_TEMPLATE, PERSISTENCE_INTERACTIVITY_TEMPLATE, PERSISTENCE_SAVE_TEMPLATE, PERSISTENCE_VALIDATORS_TEMPLATE, QUERY_LOOP_INDEX_TEMPLATE, SHARED_HOOKS_TEMPLATE, } from "./built-in-block-code-templates.js";
 import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
+import { assertScaffoldTemplateCodeIdentifiers } from "./scaffold-template-assertions.js";
 import { renderMustacheTemplateString } from "./template-render.js";
 function renderCodeTemplate(template, variables) {
+    assertScaffoldTemplateCodeIdentifiers(variables);
     const rendered = renderMustacheTemplateString(template, variables);
     return rendered.endsWith("\n") ? rendered : `${rendered}\n`;
 }

package/dist/runtime/built-in-block-non-ts-family-artifacts.js

@@ -1,4 +1,5 @@
 import { buildAlternateRenderEntryArtifact, renderArtifact, toPhpSingleQuotedString, } from "./built-in-block-non-ts-render-utils.js";
+import { getScaffoldAlternateRenderTargets, isCompoundPersistenceEnabled, } from "./scaffold-template-variable-groups.js";
 const BASIC_STYLE_TEMPLATE = `/**
  * {{title}} Block Styles
  */
@@ -826,7 +827,8 @@ export function buildInteractivityArtifacts(variables) {
  * @returns The persistence SCSS and PHP artifacts for the selected render targets.
  */
 export function buildPersistenceArtifacts(variables) {
-    if (variables.hasAlternateRenderTargets !== "true") {
+    const alternateRenderTargets = getScaffoldAlternateRenderTargets(variables);
+    if (!alternateRenderTargets.enabled) {
         return [
             renderArtifact("src/style.scss", PERSISTENCE_STYLE_TEMPLATE, variables),
             renderArtifact("src/render.php", PERSISTENCE_RENDER_TEMPLATE, variables),
@@ -837,13 +839,13 @@ export function buildPersistenceArtifacts(variables) {
         renderArtifact("src/render-targets.php", PERSISTENCE_RENDER_TARGETS_TEMPLATE, variables),
         buildAlternateRenderEntryArtifact("src/render.php", "web", variables),
     ];
-    if (variables.hasAlternateEmailRenderTarget === "true") {
+    if (alternateRenderTargets.hasEmail) {
         artifacts.push(buildAlternateRenderEntryArtifact("src/render-email.php", "email", variables));
     }
-    if (variables.hasAlternateMjmlRenderTarget === "true") {
+    if (alternateRenderTargets.hasMjml) {
         artifacts.push(buildAlternateRenderEntryArtifact("src/render-mjml.php", "mjml", variables));
     }
-    if (variables.hasAlternatePlainTextRenderTarget === "true") {
+    if (alternateRenderTargets.hasPlainText) {
         artifacts.push(buildAlternateRenderEntryArtifact("src/render-text.php", "plain-text", variables));
     }
     return artifacts;
@@ -855,23 +857,24 @@ export function buildPersistenceArtifacts(variables) {
  * @returns The compound SCSS and PHP artifacts, including persistence variants when enabled.
  */
 export function buildCompoundArtifacts(variables) {
+    const alternateRenderTargets = getScaffoldAlternateRenderTargets(variables);
     const artifacts = [
         renderArtifact(`src/blocks/${variables.slugKebabCase}/style.scss`, COMPOUND_STYLE_TEMPLATE, variables),
     ];
-    if (variables.compoundPersistenceEnabled === "true") {
+    if (isCompoundPersistenceEnabled(variables)) {
         const renderView = {
             ...variables,
             titlePhpLiteral: toPhpSingleQuotedString(variables.title),
         };
-        if (variables.hasAlternateRenderTargets === "true") {
+        if (alternateRenderTargets.enabled) {
             artifacts.push(renderArtifact(`src/blocks/${variables.slugKebabCase}/render-targets.php`, COMPOUND_PERSISTENCE_RENDER_TARGETS_TEMPLATE, renderView), buildAlternateRenderEntryArtifact(`src/blocks/${variables.slugKebabCase}/render.php`, "web", variables));
-            if (variables.hasAlternateEmailRenderTarget === "true") {
+            if (alternateRenderTargets.hasEmail) {
                 artifacts.push(buildAlternateRenderEntryArtifact(`src/blocks/${variables.slugKebabCase}/render-email.php`, "email", variables));
             }
-            if (variables.hasAlternateMjmlRenderTarget === "true") {
+            if (alternateRenderTargets.hasMjml) {
                 artifacts.push(buildAlternateRenderEntryArtifact(`src/blocks/${variables.slugKebabCase}/render-mjml.php`, "mjml", variables));
             }
-            if (variables.hasAlternatePlainTextRenderTarget === "true") {
+            if (alternateRenderTargets.hasPlainText) {
                 artifacts.push(buildAlternateRenderEntryArtifact(`src/blocks/${variables.slugKebabCase}/render-text.php`, "plain-text", variables));
             }
             return artifacts;

package/dist/runtime/built-in-block-non-ts-render-utils.js

@@ -1,3 +1,4 @@
+import { assertScaffoldTemplateCodeIdentifiers } from "./scaffold-template-assertions.js";
 import { renderMustacheTemplateString } from "./template-render.js";
 /**
  * Renders a non-TypeScript artifact and normalizes the output to a trailing newline.
@@ -8,6 +9,7 @@ import { renderMustacheTemplateString } from "./template-render.js";
  * @returns A built-in code artifact with normalized source text.
  */
 export function renderArtifact(relativePath, template, view) {
+    assertScaffoldTemplateCodeIdentifiers(view);
     const source = renderMustacheTemplateString(template, view);
     return {
         relativePath,

package/dist/runtime/cli-add-block-config.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
+import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
 import { quoteTsString, } from "./cli-add-shared.js";
 export function buildServerTemplateRoot(persistencePolicy) {
     return path.join(SHARED_WORKSPACE_TEMPLATE_ROOT, persistencePolicy === "public" ? "persistence-public" : "persistence-auth");
@@ -98,7 +99,7 @@ export function buildConfigEntries(templateId, variables) {
     if (templateId === "persistence") {
         return [buildPersistenceBlockConfigEntry(variables)];
     }
-    if (variables.compoundPersistenceEnabled === "true") {
+    if (isCompoundPersistenceEnabled(variables)) {
         return [
             buildPersistenceBlockConfigEntry(variables),
             buildCompoundChildConfigEntry(variables),

package/dist/runtime/cli-add-block.js

@@ -9,7 +9,7 @@ import { copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, } from "./
 import { appendWorkspaceInventoryEntries, } from "./workspace-inventory.js";
 import { createManagedTempRoot } from "./temp-roots.js";
 import { resolveWorkspaceProject, } from "./workspace-project.js";
-import { ADD_BLOCK_TEMPLATE_IDS, buildWorkspacePhpPrefix, isAddBlockTemplateId, patchFile, readOptionalFile, rollbackWorkspaceMutation, snapshotWorkspaceFiles, } from "./cli-add-shared.js";
+import { ADD_BLOCK_TEMPLATE_IDS, buildWorkspacePhpPrefix, isAddBlockTemplateId, patchFile, readOptionalFile, rollbackWorkspaceMutation, snapshotWorkspaceFiles, suggestAddBlockTemplateId, } from "./cli-add-shared.js";
 import { resolveNonEmptyNormalizedBlockSlug, } from "./scaffold-identifiers.js";
 import { buildConfigEntries, buildMigrationBlocks, buildServerTemplateRoot, } from "./cli-add-block-config.js";
 import { COMPOUND_SHARED_SUPPORT_FILES, collectLegacyCompoundValidatorPaths, ensureBlockConfigCanAddRestManifests, ensureCompoundWorkspaceSupportFiles, } from "./cli-add-block-legacy-validator.js";
@@ -17,6 +17,7 @@ import { parseTemplateLocator, resolveTemplateSeed, } from "./template-source.js
 import { resolveExternalTemplateLayers, } from "./template-layers.js";
 import { formatInstallCommand, } from "./package-managers.js";
 import { parseCompoundInnerBlocksPreset } from "./compound-inner-blocks.js";
+import { isCompoundPersistenceEnabled } from "./scaffold-template-variable-groups.js";
 import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
 import { parseAlternateRenderTargets } from "./alternate-render-targets.js";
 import { assertExternalLayerCompositionOptions, normalizeOptionalCliString, resolveLocalCliPathOption, } from "./cli-validation.js";
@@ -79,12 +80,19 @@ async function assertWorkspaceDependenciesInstalled(workspace) {
     }
     throw new Error(`Workspace dependencies have not been installed yet. Run \`${formatInstallCommand(workspace.packageManager)}\` from the workspace root before using \`wp-typia add block ...\`.`);
 }
+function getMistypedAddBlockTemplateMessage(templateId) {
+    const suggestion = suggestAddBlockTemplateId(templateId);
+    if (!suggestion) {
+        return null;
+    }
+    return `Unknown add-block template "${templateId}". Did you mean "${suggestion}"? Use \`--template ${suggestion}\`, or run \`wp-typia templates list\` to inspect available templates.`;
+}
 async function copyScaffoldedBlockSlice(projectDir, templateId, tempProjectDir, variables, legacyValidatorPaths = []) {
     if (templateId === "compound") {
         await ensureCompoundWorkspaceSupportFiles(projectDir, tempProjectDir, legacyValidatorPaths);
         await copyTempDirectory(path.join(tempProjectDir, "src", "blocks", variables.slugKebabCase), path.join(projectDir, "src", "blocks", variables.slugKebabCase));
         await copyTempDirectory(path.join(tempProjectDir, "src", "blocks", `${variables.slugKebabCase}-item`), path.join(projectDir, "src", "blocks", `${variables.slugKebabCase}-item`));
-        if (variables.compoundPersistenceEnabled === "true") {
+        if (isCompoundPersistenceEnabled(variables)) {
             await renderWorkspacePersistenceServerModule(projectDir, variables);
         }
         return;
@@ -196,7 +204,7 @@ async function syncWorkspaceAddedBlockArtifacts(projectDir, templateId, variable
         await syncWorkspaceBlockMetadata(projectDir, `${variables.slugKebabCase}-item`, `${variables.pascalCase}ItemAttributes`, path.join("src", "blocks", `${variables.slugKebabCase}-item`, "types.ts"));
     }
     if (templateId === "persistence" ||
-        (templateId === "compound" && variables.compoundPersistenceEnabled === "true")) {
+        (templateId === "compound" && isCompoundPersistenceEnabled(variables))) {
         await syncWorkspacePersistenceArtifacts(projectDir, variables);
     }
 }
@@ -286,6 +294,10 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
         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)) {
+        const mistypedAddBlockTemplateMessage = getMistypedAddBlockTemplateMessage(templateId);
+        if (mistypedAddBlockTemplateMessage) {
+            throw new Error(mistypedAddBlockTemplateMessage);
+        }
         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;
@@ -390,7 +402,7 @@ export async function runAddBlockCommand({ alternateRenderTargets, blockName, cw
             await addCollectionImportsForTemplate(workspace.projectDir, resolvedTemplateId, result.variables);
             await appendBlockConfigEntries(workspace.projectDir, buildConfigEntries(resolvedTemplateId, result.variables), resolvedTemplateId === "persistence" ||
                 (resolvedTemplateId === "compound" &&
-                    result.variables.compoundPersistenceEnabled === "true"));
+                    isCompoundPersistenceEnabled(result.variables)));
             await syncWorkspaceAddedBlockArtifacts(workspace.projectDir, resolvedTemplateId, result.variables);
             await updateWorkspaceMigrationConfigIfPresent(workspace.projectDir, buildMigrationBlocks(resolvedTemplateId, result.variables));
             return {

package/dist/runtime/cli-add-types.d.ts

@@ -42,6 +42,14 @@ export declare const ADD_BLOCK_TEMPLATE_IDS: readonly ["basic", "interactivity",
  * Union of supported built-in block template ids.
  */
 export type AddBlockTemplateId = (typeof ADD_BLOCK_TEMPLATE_IDS)[number];
+/**
+ * Suggest the closest supported add-block template id for typo diagnostics.
+ *
+ * @param templateId Raw `wp-typia add block --template` value.
+ * @returns The closest supported template id when it is within the shared
+ * close-id threshold, otherwise `null`.
+ */
+export declare function suggestAddBlockTemplateId(templateId: string): AddBlockTemplateId | null;
 /**
  * Options for `wp-typia add variation`.
  *

package/dist/runtime/cli-add-types.js

@@ -1,3 +1,4 @@
+import { suggestCloseId } from "./id-suggestions.js";
 export { ADD_KIND_IDS } from "./cli-add-kind-ids.js";
 /**
  * Supported plugin-level REST resource methods accepted by
@@ -46,3 +47,13 @@ export const ADD_BLOCK_TEMPLATE_IDS = [
     "persistence",
     "compound",
 ];
+/**
+ * Suggest the closest supported add-block template id for typo diagnostics.
+ *
+ * @param templateId Raw `wp-typia add block --template` value.
+ * @returns The closest supported template id when it is within the shared
+ * close-id threshold, otherwise `null`.
+ */
+export function suggestAddBlockTemplateId(templateId) {
+    return suggestCloseId(templateId, ADD_BLOCK_TEMPLATE_IDS);
+}

package/dist/runtime/cli-add-workspace-ability-scaffold.js

@@ -1,9 +1,9 @@
-import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { syncTypeSchemas } from "@wp-typia/block-runtime/metadata-core";
 import semver from "semver";
-import { appendWorkspaceInventoryEntries, readWorkspaceInventory, } from "./workspace-inventory.js";
+import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from "./workspace-inventory.js";
+import { pathExists, readOptionalUtf8File } from "./fs-async.js";
 import { buildAbilityClientSource, buildAbilityConfigEntry, buildAbilityConfigSource, buildAbilityDataSource, buildAbilityPhpSource, buildAbilityRegistrySource, buildAbilitySyncScriptSource, buildAbilityTypesSource, } from "./cli-add-workspace-ability-templates.js";
 import { ABILITY_EDITOR_ASSET, ABILITY_EDITOR_SCRIPT, ABILITY_REGISTRY_END_MARKER, ABILITY_REGISTRY_START_MARKER, ABILITY_SERVER_GLOB, WP_ABILITIES_SCRIPT_MODULE_ID, WP_CORE_ABILITIES_SCRIPT_MODULE_ID, } from "./cli-add-workspace-ability-types.js";
 import { getWorkspaceBootstrapPath, patchFile, } from "./cli-add-shared.js";
@@ -25,28 +25,34 @@ function resolveManagedDependencyVersion(existingVersion, requiredVersion) {
         ? existingVersion
         : requiredVersion;
 }
-function resolveAbilityRegistryPath(projectDir) {
+async function resolveAbilityRegistryPath(projectDir) {
     const abilitiesDir = path.join(projectDir, "src", "abilities");
-    return [path.join(abilitiesDir, "index.ts"), path.join(abilitiesDir, "index.js")].find((candidatePath) => fs.existsSync(candidatePath)) ?? path.join(abilitiesDir, "index.ts");
+    for (const candidatePath of [
+        path.join(abilitiesDir, "index.ts"),
+        path.join(abilitiesDir, "index.js"),
+    ]) {
+        if (await pathExists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return path.join(abilitiesDir, "index.ts");
 }
-function readAbilityRegistrySlugs(registryPath) {
-    if (!fs.existsSync(registryPath)) {
+async function readAbilityRegistrySlugs(registryPath) {
+    const source = await readOptionalUtf8File(registryPath);
+    if (source === null) {
         return [];
     }
-    const source = fs.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 = path.join(projectDir, "src", "abilities");
-    const registryPath = resolveAbilityRegistryPath(projectDir);
+    const registryPath = await resolveAbilityRegistryPath(projectDir);
     await fsp.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 = fs.existsSync(registryPath)
-        ? fs.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)
@@ -318,7 +324,7 @@ export async function scaffoldAbilityWorkspace({ abilitySlug, compatibilityPolic
     const syncAbilitiesScriptPath = path.join(workspace.projectDir, "scripts", "sync-abilities.ts");
     const syncProjectScriptPath = path.join(workspace.projectDir, "scripts", "sync-project.ts");
     const webpackConfigPath = path.join(workspace.projectDir, "webpack.config.js");
-    const abilitiesIndexPath = resolveAbilityRegistryPath(workspace.projectDir);
+    const abilitiesIndexPath = await resolveAbilityRegistryPath(workspace.projectDir);
     const abilityDir = path.join(workspace.projectDir, "src", "abilities", abilitySlug);
     const configFilePath = path.join(abilityDir, "ability.config.json");
     const typesFilePath = path.join(abilityDir, "types.ts");

package/dist/runtime/cli-add-workspace-ability.js

@@ -1,6 +1,6 @@
 import { assertAbilityDoesNotExist, assertValidGeneratedSlug, normalizeBlockSlug, } from "./cli-add-shared.js";
 import { scaffoldAbilityWorkspace } from "./cli-add-workspace-ability-scaffold.js";
-import { readWorkspaceInventory } from "./workspace-inventory.js";
+import { readWorkspaceInventoryAsync } from "./workspace-inventory.js";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, } from "./scaffold-compatibility.js";
 /**
@@ -12,7 +12,7 @@ import { REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityP
 export async function runAddAbilityCommand({ abilityName, cwd = process.cwd(), }) {
     const workspace = resolveWorkspaceProject(cwd);
     const abilitySlug = assertValidGeneratedSlug("Ability name", normalizeBlockSlug(abilityName), "wp-typia add ability <name>");
-    const inventory = readWorkspaceInventory(workspace.projectDir);
+    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
     assertAbilityDoesNotExist(workspace.projectDir, abilitySlug, inventory);
     const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY);
     const scaffoldResult = await scaffoldAbilityWorkspace({

package/dist/runtime/cli-add-workspace-admin-view-scaffold.js

@@ -1,7 +1,7 @@
-import fs from 'node:fs';
 import { promises as fsp } from 'node:fs';
 import path from 'node:path';
-import { appendWorkspaceInventoryEntries, readWorkspaceInventory, } from './workspace-inventory.js';
+import { pathExists, readOptionalUtf8File } from './fs-async.js';
+import { appendWorkspaceInventoryEntries, readWorkspaceInventoryAsync, } from './workspace-inventory.js';
 import { buildAdminViewConfigEntry, buildAdminViewConfigSource, buildAdminViewEntrySource, buildAdminViewPhpSource, buildAdminViewRegistrySource, buildAdminViewScreenSource, buildAdminViewStyleSource, buildAdminViewTypesSource, buildCoreDataAdminViewDataSource, buildCoreDataAdminViewScreenSource, buildDefaultAdminViewDataSource, buildRestAdminViewDataSource, } from './cli-add-workspace-admin-view-templates.js';
 import { ADMIN_VIEWS_PHP_GLOB, isAdminViewCoreDataSource, } from './cli-add-workspace-admin-view-types.js';
 import { getWorkspaceBootstrapPath, patchFile, } from './cli-add-shared.js';
@@ -152,27 +152,31 @@ async function ensureAdminViewWebpackAnchors(workspace) {
         return nextSource;
     });
 }
-function resolveAdminViewRegistryPath(projectDir) {
+async function resolveAdminViewRegistryPath(projectDir) {
     const adminViewsDir = path.join(projectDir, 'src', 'admin-views');
-    return ([
+    for (const candidatePath of [
         path.join(adminViewsDir, 'index.ts'),
         path.join(adminViewsDir, 'index.js'),
-    ].find((candidatePath) => fs.existsSync(candidatePath)) ??
-        path.join(adminViewsDir, 'index.ts'));
+    ]) {
+        if (await pathExists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return path.join(adminViewsDir, 'index.ts');
 }
-function readAdminViewRegistrySlugs(registryPath) {
-    if (!fs.existsSync(registryPath)) {
+async function readAdminViewRegistrySlugs(registryPath) {
+    const source = await readOptionalUtf8File(registryPath);
+    if (source === null) {
         return [];
     }
-    const source = fs.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 = path.join(projectDir, 'src', 'admin-views');
-    const registryPath = resolveAdminViewRegistryPath(projectDir);
+    const registryPath = await resolveAdminViewRegistryPath(projectDir);
     await fsp.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,
@@ -187,7 +191,7 @@ export async function scaffoldAdminViewWorkspace(options) {
     const buildScriptPath = path.join(workspace.projectDir, 'scripts', 'build-workspace.mjs');
     const packageJsonPath = path.join(workspace.projectDir, 'package.json');
     const webpackConfigPath = path.join(workspace.projectDir, 'webpack.config.js');
-    const adminViewsIndexPath = resolveAdminViewRegistryPath(workspace.projectDir);
+    const adminViewsIndexPath = await resolveAdminViewRegistryPath(workspace.projectDir);
     const adminViewDir = path.join(workspace.projectDir, 'src', 'admin-views', adminViewSlug);
     const adminViewPhpPath = path.join(workspace.projectDir, 'inc', 'admin-views', `${adminViewSlug}.php`);
     await executeWorkspaceMutationPlan({

package/dist/runtime/cli-add-workspace-admin-view.js

@@ -2,7 +2,7 @@ import { assertAdminViewDoesNotExist, assertValidGeneratedSlug, normalizeBlockSl
 import { assertAdminViewPackageAvailability, parseAdminViewSource, resolveAdminViewCoreDataSource, resolveRestResourceSource, } from './cli-add-workspace-admin-view-source.js';
 import { scaffoldAdminViewWorkspace } from './cli-add-workspace-admin-view-scaffold.js';
 import { formatAdminViewSourceLocator } from './cli-add-workspace-admin-view-types.js';
-import { readWorkspaceInventory } from './workspace-inventory.js';
+import { readWorkspaceInventoryAsync } from './workspace-inventory.js';
 import { resolveWorkspaceProject } from './workspace-project.js';
 const ADD_ADMIN_VIEW_USAGE = 'wp-typia add admin-view <name> [--source <rest-resource:slug|core-data:kind/name>]';
 /**
@@ -14,7 +14,7 @@ export async function runAddAdminViewCommand({ adminViewName, cwd = process.cwd(
     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);

package/dist/runtime/cli-add-workspace-ai.js

@@ -1,6 +1,6 @@
 import { assertAiFeatureDoesNotExist, assertValidGeneratedSlug, normalizeBlockSlug, resolveRestResourceNamespace, } from "./cli-add-shared.js";
 import { scaffoldAiFeatureWorkspace } from "./cli-add-workspace-ai-scaffold.js";
-import { readWorkspaceInventory } from "./workspace-inventory.js";
+import { readWorkspaceInventoryAsync } from "./workspace-inventory.js";
 import { resolveWorkspaceProject } from "./workspace-project.js";
 import { OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, } from "./scaffold-compatibility.js";
 /**
@@ -15,7 +15,7 @@ export async function runAddAiFeatureCommand({ aiFeatureName, cwd = process.cwd(
     const aiFeatureSlug = assertValidGeneratedSlug("AI feature name", normalizeBlockSlug(aiFeatureName), "wp-typia add ai-feature <name> [--namespace <vendor/v1>]");
     const resolvedNamespace = resolveRestResourceNamespace(workspace.workspace.namespace, namespace);
     const compatibilityPolicy = resolveScaffoldCompatibilityPolicy(OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY);
-    const inventory = readWorkspaceInventory(workspace.projectDir);
+    const inventory = await readWorkspaceInventoryAsync(workspace.projectDir);
     assertAiFeatureDoesNotExist(workspace.projectDir, aiFeatureSlug, inventory);
     const scaffoldResult = await scaffoldAiFeatureWorkspace({
         aiFeatureSlug,