@wp-typia/project-tools 0.22.8 → 0.22.9

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";
@@ -80,6 +80,13 @@ 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);
@@ -287,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;

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.d.ts

@@ -7,8 +7,9 @@
  * - `cli-add-block` for built-in block scaffolding
  * - `cli-add-workspace` for workspace mutation commands
  */
-export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, } from "./cli-add-shared.js";
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, suggestAddBlockTemplateId, } from "./cli-add-shared.js";
 export type { AddBlockTemplateId, AddKindId, EditorPluginSlotId, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
 export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
-export { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";
+export { getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, } from "./workspace-inventory.js";
+export type { WorkspaceBlockSelectOption } from "./workspace-inventory.js";

package/dist/runtime/cli-add.js

@@ -7,7 +7,7 @@
  * - `cli-add-block` for built-in block scaffolding
  * - `cli-add-workspace` for workspace mutation commands
  */
-export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, } from "./cli-add-shared.js";
+export { ADD_BLOCK_TEMPLATE_IDS, ADD_KIND_IDS, EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, isAddBlockTemplateId, suggestAddBlockTemplateId, } from "./cli-add-shared.js";
 export { runAddBlockCommand, seedWorkspaceMigrationProject, } from "./cli-add-block.js";
 export { runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, } from "./cli-add-workspace.js";
-export { getWorkspaceBlockSelectOptions } from "./workspace-inventory.js";
+export { getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, } from "./workspace-inventory.js";

package/dist/runtime/cli-core.d.ts

@@ -11,7 +11,8 @@
  * `runAddAdminViewCommand` for DataViews-backed admin screen scaffolds,
  * `runAddAbilityCommand` for typed workflow ability scaffolds,
  * and `HOOKED_BLOCK_POSITION_IDS`,
- * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
+ * `getWorkspaceBlockSelectOptions`, `getWorkspaceBlockSelectOptionsAsync`, and
+ * `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `runAddAiFeatureCommand` for server-owned WordPress AI feature scaffolds,
  * `runAddRestResourceCommand` for plugin-level REST resource scaffolds,
@@ -31,11 +32,12 @@
 export { getDoctorChecks, runDoctor, type DoctorCheck } from "./cli-doctor.js";
 export { createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODE_METADATA, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatDoctorCheckLine, formatDoctorSummaryLine, getCliDiagnosticCodeMetadata, getDoctorFailureDetailLines, getFailingDoctorChecks, isCliDiagnosticError, } from "./cli-diagnostics.js";
 export type { CliDiagnosticCode, CliDiagnosticCodeError, CliDiagnosticMessage, } from "./cli-diagnostics.js";
-export { EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, getWorkspaceBlockSelectOptions, runAddAdminViewCommand, runAddAbilityCommand, runAddBindingSourceCommand, runAddAiFeatureCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
+export { EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, runAddAdminViewCommand, runAddAbilityCommand, runAddBindingSourceCommand, runAddAiFeatureCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
 export { COMPOUND_INNER_BLOCKS_PRESET_IDS, getCompoundInnerBlocksPresetDefinition, } from "./compound-inner-blocks.js";
 export type { CompoundInnerBlocksPresetId } from "./compound-inner-blocks.js";
 export { HOOKED_BLOCK_POSITION_IDS } from "./hooked-blocks.js";
 export type { EditorPluginSlotId } from "./cli-add.js";
+export type { WorkspaceBlockSelectOption } from "./workspace-inventory.js";
 export type { HookedBlockPositionId } from "./hooked-blocks.js";
 export { formatHelpText } from "./cli-help.js";
 export { getNextSteps, getOptionalOnboarding, runScaffoldFlow, } from "./cli-scaffold.js";

package/dist/runtime/cli-core.js

@@ -11,7 +11,8 @@
  * `runAddAdminViewCommand` for DataViews-backed admin screen scaffolds,
  * `runAddAbilityCommand` for typed workflow ability scaffolds,
  * and `HOOKED_BLOCK_POSITION_IDS`,
- * `getWorkspaceBlockSelectOptions`, and `seedWorkspaceMigrationProject` for
+ * `getWorkspaceBlockSelectOptions`, `getWorkspaceBlockSelectOptionsAsync`, and
+ * `seedWorkspaceMigrationProject` for
  * explicit `wp-typia add` flows,
  * `runAddAiFeatureCommand` for server-owned WordPress AI feature scaffolds,
  * `runAddRestResourceCommand` for plugin-level REST resource scaffolds,
@@ -30,7 +31,7 @@
  */
 export { getDoctorChecks, runDoctor } from "./cli-doctor.js";
 export { createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODE_METADATA, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatDoctorCheckLine, formatDoctorSummaryLine, getCliDiagnosticCodeMetadata, getDoctorFailureDetailLines, getFailingDoctorChecks, isCliDiagnosticError, } from "./cli-diagnostics.js";
-export { EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, getWorkspaceBlockSelectOptions, runAddAdminViewCommand, runAddAbilityCommand, runAddBindingSourceCommand, runAddAiFeatureCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
+export { EDITOR_PLUGIN_SLOT_IDS, formatAddHelpText, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, runAddAdminViewCommand, runAddAbilityCommand, runAddBindingSourceCommand, runAddAiFeatureCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runAddRestResourceCommand, runAddVariationCommand, seedWorkspaceMigrationProject, } from "./cli-add.js";
 export { COMPOUND_INNER_BLOCKS_PRESET_IDS, getCompoundInnerBlocksPresetDefinition, } from "./compound-inner-blocks.js";
 export { HOOKED_BLOCK_POSITION_IDS } from "./hooked-blocks.js";
 export { formatHelpText } from "./cli-help.js";

package/dist/runtime/cli-doctor-workspace.js

@@ -70,6 +70,8 @@ export function getWorkspaceDoctorChecks(cwd) {
     }
     checks.push(getWorkspacePackageMetadataCheck(workspace, workspacePackageJson));
     try {
+        // Doctor checks expose a synchronous API so callers can collect a stable
+        // snapshot without mixing async inventory reads into check aggregation.
         const inventory = readWorkspaceInventory(workspace.projectDir);
         checks.push(createDoctorCheck("Workspace inventory", "pass", formatWorkspaceInventorySummary(inventory)));
         checks.push(...getWorkspaceBlockDoctorChecks(workspace, inventory));

package/dist/runtime/cli-scaffold.js

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, resolvePackageManagerId, resolveTemplateId, scaffoldProject, } from "./scaffold.js";
@@ -10,6 +9,7 @@ import { getPrimaryDevelopmentScript } from "./local-dev-presets.js";
 import { createManagedTempRoot } from "./temp-roots.js";
 import { getOptionalOnboardingNote, getOptionalOnboardingShortNote, getOptionalOnboardingSteps, } from "./scaffold-onboarding.js";
 import { formatNonEmptyTargetDirectoryError } from "./scaffold-bootstrap.js";
+import { pathExists } from "./fs-async.js";
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from "./template-registry.js";
 import { resolveOptionalInteractiveExternalLayerId, } from "./external-layer-selection.js";
 import { assertBuiltInTemplateVariantAllowed, resolveLocalCliPathOption, normalizeOptionalCliString, } from "./cli-validation.js";
@@ -32,7 +32,7 @@ async function listRelativeProjectFiles(rootDir) {
     return relativeFiles.sort((left, right) => left.localeCompare(right));
 }
 async function assertDryRunTargetDirectoryReady(projectDir, allowExistingDir) {
-    if (!fs.existsSync(projectDir) || allowExistingDir) {
+    if (!(await pathExists(projectDir)) || allowExistingDir) {
         return;
     }
     const entries = await fsp.readdir(projectDir);
@@ -425,7 +425,7 @@ export async function runScaffoldFlow({ projectInput, cwd = process.cwd(), templ
         let availableScripts;
         if (!dryRun) {
             try {
-                const parsedPackageJson = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+                const parsedPackageJson = JSON.parse(await fsp.readFile(path.join(projectDir, "package.json"), "utf8"));
                 const scripts = parsedPackageJson.scripts &&
                     typeof parsedPackageJson.scripts === "object" &&
                     !Array.isArray(parsedPackageJson.scripts)

package/dist/runtime/create-template-validation.js

@@ -3,6 +3,7 @@ import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from "./cli-diagn
 import { OFFICIAL_WORKSPACE_TEMPLATE_ALIAS, OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, TEMPLATE_IDS, getTemplateById, isBuiltInTemplateId, } from "./template-registry.js";
 import { getRemovedBuiltInTemplateMessage, isRemovedBuiltInTemplateId, } from "./template-defaults.js";
 import { parseNpmTemplateLocator } from "./template-source-locators.js";
+import { suggestCloseId } from "./id-suggestions.js";
 export const CREATE_TEMPLATE_SELECTION_HINT = `--template <${[
     ...TEMPLATE_IDS,
     OFFICIAL_WORKSPACE_TEMPLATE_ALIAS,
@@ -39,40 +40,13 @@ function looksLikeExplicitCreateExternalTemplateLocator(templateId) {
     return (looksLikeExplicitNonNpmExternalTemplateLocator(templateId) ||
         parseNpmTemplateLocator(templateId) !== null);
 }
-function getEditDistance(left, right) {
-    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
-    const current = new Array(right.length + 1);
-    for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
-        current[0] = leftIndex + 1;
-        for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
-            const substitutionCost = left[leftIndex] === right[rightIndex] ? 0 : 1;
-            current[rightIndex + 1] = Math.min(current[rightIndex] + 1, previous[rightIndex + 1] + 1, previous[rightIndex] + substitutionCost);
-        }
-        for (let index = 0; index < current.length; index += 1) {
-            previous[index] = current[index];
-        }
-    }
-    return previous[right.length];
-}
 function findMistypedBuiltInTemplateSuggestion(templateId) {
     const normalizedTemplateId = templateId.trim().toLowerCase();
     if (normalizedTemplateId.length === 0 ||
         looksLikeExplicitNonNpmExternalTemplateLocator(normalizedTemplateId)) {
         return null;
     }
-    let bestCandidate = null;
-    for (const candidateId of TEMPLATE_SUGGESTION_IDS) {
-        const distance = getEditDistance(normalizedTemplateId, candidateId);
-        if (bestCandidate === null || distance < bestCandidate.distance) {
-            bestCandidate = {
-                distance,
-                id: candidateId,
-            };
-        }
-    }
-    return bestCandidate && bestCandidate.distance <= 2
-        ? bestCandidate.id
-        : null;
+    return suggestCloseId(normalizedTemplateId, TEMPLATE_SUGGESTION_IDS);
 }
 function getMistypedBuiltInTemplateMessage(templateId) {
     const suggestion = findMistypedBuiltInTemplateSuggestion(templateId);

package/dist/runtime/id-suggestions.d.ts

@@ -0,0 +1,21 @@
+export interface SuggestCloseIdOptions {
+    /**
+     * Maximum edit distance accepted for a suggestion.
+     *
+     * Defaults to `2`, matching the create-template typo guard.
+     */
+    maxDistance?: number;
+    /**
+     * Normalizes user input and candidates before comparing them.
+     *
+     * Defaults to trimming and lowercasing for CLI id-like values.
+     */
+    normalize?: (value: string) => string;
+}
+/**
+ * Suggest the closest known id for a user-provided CLI value.
+ *
+ * This helper is intentionally generic so command-specific validation can keep
+ * its own wording and special-case handling while sharing typo thresholds.
+ */
+export declare function suggestCloseId<const TCandidate extends string>(input: string, candidates: readonly TCandidate[], options?: SuggestCloseIdOptions): TCandidate | null;

package/dist/runtime/id-suggestions.js

@@ -0,0 +1,48 @@
+function normalizeCloseId(value) {
+    return value.trim().toLowerCase();
+}
+function getEditDistance(left, right) {
+    const previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    const current = new Array(right.length + 1);
+    for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
+        current[0] = leftIndex + 1;
+        for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
+            const substitutionCost = left[leftIndex] === right[rightIndex] ? 0 : 1;
+            current[rightIndex + 1] = Math.min(current[rightIndex] + 1, previous[rightIndex + 1] + 1, previous[rightIndex] + substitutionCost);
+        }
+        for (let index = 0; index < current.length; index += 1) {
+            previous[index] = current[index];
+        }
+    }
+    return previous[right.length];
+}
+/**
+ * Suggest the closest known id for a user-provided CLI value.
+ *
+ * This helper is intentionally generic so command-specific validation can keep
+ * its own wording and special-case handling while sharing typo thresholds.
+ */
+export function suggestCloseId(input, candidates, options = {}) {
+    const normalize = options.normalize ?? normalizeCloseId;
+    const normalizedInput = normalize(input);
+    if (normalizedInput.length === 0) {
+        return null;
+    }
+    const maxDistance = options.maxDistance ?? 2;
+    if (maxDistance < 0) {
+        return null;
+    }
+    let bestCandidate = null;
+    for (const candidateId of candidates) {
+        const distance = getEditDistance(normalizedInput, normalize(candidateId));
+        if (bestCandidate === null || distance < bestCandidate.distance) {
+            bestCandidate = {
+                distance,
+                id: candidateId,
+            };
+        }
+    }
+    return bestCandidate && bestCandidate.distance <= maxDistance
+        ? bestCandidate.id
+        : null;
+}

package/dist/runtime/index.d.ts

@@ -5,6 +5,7 @@
  * CLI while keeping reusable project logic out of the CLI package itself.
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `getWorkspaceBlockSelectOptionsAsync`,
  * `runAddBlockCommand`, `runAddBlockStyleCommand`,
  * `runAddBlockTransformCommand`, `runAddVariationCommand`,
  * `runAddPatternCommand`, `runAddBindingSourceCommand`,
@@ -29,11 +30,13 @@ export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJso
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 export type { EndpointAuthIntent, EndpointOpenApiAuthMode, EndpointOpenApiContractDocument, EndpointOpenApiDocumentOptions, EndpointOpenApiEndpointDefinition, EndpointOpenApiMethod, EndpointWordPressAuthDefinition, EndpointWordPressAuthMechanism, JsonSchemaDocument, JsonSchemaProjectionProfile, JsonSchemaObject, NormalizedEndpointAuthDefinition, OpenApiDocument, OpenApiInfo, OpenApiOperation, OpenApiParameter, OpenApiPathItem, OpenApiSecurityScheme, } from "./schema-core.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
+export { suggestCloseId } from "./id-suggestions.js";
+export type { SuggestCloseIdOptions } from "./id-suggestions.js";
 export { clearPackageVersionsCache, getPackageVersions, invalidatePackageVersionsCache, } from "./package-versions.js";
 export type { PackageVersions } from "./package-versions.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
 export { EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, pruneExternalTemplateCache, } from "./template-source-cache.js";
 export type { ExternalTemplateCachePruneOptions, ExternalTemplateCachePruneResult, } from "./template-source-cache.js";
 export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
-export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
-export type { CliDiagnosticCode, CliDiagnosticCodeError, CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export type { CliDiagnosticCode, CliDiagnosticCodeError, CliDiagnosticMessage, DoctorCheck, EditorPluginSlotId, HookedBlockPositionId, ReadlinePrompt, WorkspaceBlockSelectOption, } from "./cli-core.js";

package/dist/runtime/index.js

@@ -5,6 +5,7 @@
  * CLI while keeping reusable project logic out of the CLI package itself.
  * Consumers should prefer these exports for scaffold, add, migrate, doctor,
  * and workspace-aware helpers such as `getWorkspaceBlockSelectOptions`,
+ * `getWorkspaceBlockSelectOptionsAsync`,
  * `runAddBlockCommand`, `runAddBlockStyleCommand`,
  * `runAddBlockTransformCommand`, `runAddVariationCommand`,
  * `runAddPatternCommand`, `runAddBindingSourceCommand`,
@@ -23,8 +24,9 @@ export { parseWorkspacePackageManagerId, resolveWorkspaceProject, tryResolveWork
 export { manifestAttributeToJsonSchema, projectJsonSchemaDocument, manifestToJsonSchema, manifestToOpenApi, normalizeEndpointAuthDefinition, } from "./schema-core.js";
 export { buildCompoundChildStarterManifestDocument, getStarterManifestFiles, stringifyStarterManifest, } from "./starter-manifests.js";
 export { PACKAGE_MANAGER_IDS, PACKAGE_MANAGERS, formatPackageExecCommand, formatInstallCommand, formatRunScript, getPackageManager, getPackageManagerSelectOptions, transformPackageManagerText, } from "./package-managers.js";
+export { suggestCloseId } from "./id-suggestions.js";
 export { clearPackageVersionsCache, getPackageVersions, invalidatePackageVersionsCache, } from "./package-versions.js";
 export { TEMPLATE_IDS, TEMPLATE_REGISTRY, getTemplateById, getTemplateSelectOptions, listTemplates, } from "./template-registry.js";
 export { EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV, pruneExternalTemplateCache, } from "./template-source-cache.js";
 export { STALE_TEMP_ROOT_MAX_AGE_MS, WP_TYPIA_TEMP_ROOT_PREFIX, cleanupManagedTempRoot, cleanupStaleTempRoots, createManagedTempRoot, getTrackedTempRoots, } from "./temp-roots.js";
-export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";
+export { createReadlinePrompt, createCliCommandError, createCliDiagnosticCodeError, CliDiagnosticError, CLI_DIAGNOSTIC_CODES, formatCliDiagnosticError, formatAddHelpText, formatDoctorCheckLine, formatDoctorSummaryLine, formatHelpText, formatTemplateDetails, formatTemplateFeatures, formatTemplateSummary, getDoctorChecks, getDoctorFailureDetailLines, getFailingDoctorChecks, getNextSteps, getOptionalOnboarding, getWorkspaceBlockSelectOptions, getWorkspaceBlockSelectOptionsAsync, HOOKED_BLOCK_POSITION_IDS, EDITOR_PLUGIN_SLOT_IDS, isCliDiagnosticError, runAddAdminViewCommand, runAddAbilityCommand, runAddAiFeatureCommand, runAddBindingSourceCommand, runAddBlockCommand, runAddBlockStyleCommand, runAddBlockTransformCommand, runAddEditorPluginCommand, runAddHookedBlockCommand, runAddPatternCommand, runDoctor, runAddVariationCommand, runScaffoldFlow, } from "./cli-core.js";

package/dist/runtime/migration-maintenance-verify.js

@@ -76,6 +76,8 @@ function recordWorkspaceMigrationTargetAlignment(projectDir, state, recordCheck)
         return;
     }
     try {
+        // Maintenance verification is intentionally synchronous so it can compare
+        // migration state against a single inventory snapshot.
         const inventory = readWorkspaceInventory(workspace.projectDir);
         const expectedTargets = inventory.blocks.map((block) => `${workspace.workspace.namespace}/${block.slug}`);
         const configuredTargets = state.blocks.map((block) => block.blockName);

package/dist/runtime/scaffold.js

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { getPackageManager } from "./package-managers.js";
@@ -14,6 +13,7 @@ import { BlockGeneratorService, } from "./block-generator-service.js";
 import { getTemplateVariables } from "./scaffold-template-variables.js";
 import { getScaffoldTemplateVariableGroups } from "./scaffold-template-variable-groups.js";
 import { assertExternalLayerCompositionOptions, } from "./cli-validation.js";
+import { pathExists } from "./fs-async.js";
 export const DATA_STORAGE_MODES = ["post-meta", "custom-table"];
 export const PERSISTENCE_POLICIES = ["authenticated", "public"];
 export { buildBlockCssClassName } from "./scaffold-identifiers.js";
@@ -149,7 +149,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, alterna
         title: "Finalizing scaffold output",
     });
     const readmePath = path.join(projectDir, "README.md");
-    if (!fs.existsSync(readmePath)) {
+    if (!(await pathExists(readmePath))) {
         await fsp.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
             withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
             withTestPreset: isBuiltInTemplate ? withTestPreset : false,
@@ -157,7 +157,7 @@ export async function scaffoldProject({ projectDir, templateId, answers, alterna
         }), "utf8");
     }
     const gitignorePath = path.join(projectDir, ".gitignore");
-    const existingGitignore = fs.existsSync(gitignorePath)
+    const existingGitignore = (await pathExists(gitignorePath))
         ? await fsp.readFile(gitignorePath, "utf8")
         : "";
     await fsp.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");

package/dist/runtime/template-builtins.js

@@ -1,6 +1,6 @@
-import fs from "node:fs";
 import path from "node:path";
 import { promises as fsp } from "node:fs";
+import { pathExists } from "./fs-async.js";
 import { createManagedTempRoot } from "./temp-roots.js";
 import { getTemplateById, SHARED_BASE_TEMPLATE_ROOT, SHARED_COMPOUND_TEMPLATE_ROOT, SHARED_MIGRATION_UI_TEMPLATE_ROOT, SHARED_PERSISTENCE_TEMPLATE_ROOT, SHARED_PRESET_TEMPLATE_ROOT, SHARED_REST_HELPER_TEMPLATE_ROOT, SHARED_WORKSPACE_TEMPLATE_ROOT, } from "./template-registry.js";
 const BUILT_IN_SHARED_TEMPLATE_LAYERS = Object.freeze([
@@ -138,20 +138,23 @@ export function isOmittableBuiltInTemplateLayerDir(templateId, layerDir) {
     return (OMITTABLE_BUILT_IN_OVERLAY_TEMPLATE_IDS.has(templateId) &&
         layerDir === getTemplateById(templateId).templateDir);
 }
-function resolveMaterializedTemplateLayerDirs(templateId, layerDirs) {
-    return layerDirs.flatMap((layerDir) => {
-        if (fs.existsSync(layerDir)) {
-            return [layerDir];
+async function resolveMaterializedTemplateLayerDirs(templateId, layerDirs) {
+    const materializedLayerDirs = [];
+    for (const layerDir of layerDirs) {
+        if (await pathExists(layerDir)) {
+            materializedLayerDirs.push(layerDir);
+            continue;
         }
         if (isOmittableBuiltInTemplateLayerDir(templateId, layerDir)) {
-            return [];
+            continue;
         }
         throw new Error(`Built-in template layer is missing: ${layerDir}`);
-    });
+    }
+    return materializedLayerDirs;
 }
 async function materializeBuiltInTemplateSource(templateId, layerDirs) {
     const template = getTemplateById(templateId);
-    const materializedLayerDirs = resolveMaterializedTemplateLayerDirs(templateId, layerDirs);
+    const materializedLayerDirs = await resolveMaterializedTemplateLayerDirs(templateId, layerDirs);
     const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-template-");
     const templateDir = path.join(tempRoot, templateId);
     try {

package/dist/runtime/template-layers.js

@@ -1,6 +1,6 @@
-import fs from "node:fs";
 import path from "node:path";
 import { promises as fsp } from "node:fs";
+import { pathExists } from "./fs-async.js";
 import { isPlainObject } from "./object-utils.js";
 import { getBuiltInSharedTemplateLayerDir, isBuiltInSharedTemplateLayerId, } from "./template-builtins.js";
 import { listInterpolatedDirectoryOutputs } from "./template-render.js";
@@ -56,7 +56,7 @@ function parseLayerDefinition(layerId, value) {
 }
 export async function loadExternalTemplateLayerManifest(sourceRoot) {
     const manifestPath = path.join(sourceRoot, TEMPLATE_LAYER_MANIFEST_FILENAME);
-    if (!fs.existsSync(manifestPath)) {
+    if (!(await pathExists(manifestPath))) {
         return null;
     }
     const raw = JSON.parse(await fsp.readFile(manifestPath, "utf8"));

package/dist/runtime/template-source-external.d.ts

@@ -7,6 +7,9 @@ export declare const EXTERNAL_TEMPLATE_TRUST_WARNING = "External template config
 /**
  * Search a source directory for the first supported external template entry.
  *
+ * @deprecated Use `findExternalTemplateEntry()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Directory that may contain an external template config entry.
  * @returns The first matching entry path, or null when no supported entry exists.
  */

package/dist/runtime/template-source-external.js

@@ -33,6 +33,9 @@ function resolveSourceSubpath(sourceDir, relativePath) {
 /**
  * Search a source directory for the first supported external template entry.
  *
+ * @deprecated Use `findExternalTemplateEntry()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Directory that may contain an external template config entry.
  * @returns The first matching entry path, or null when no supported entry exists.
  */
@@ -205,11 +208,11 @@ export async function renderCreateBlockExternalTemplate(sourceDir, context, requ
         const view = await buildExternalTemplateView(context, config, selectedVariant, variantConfig);
         const blockTemplateDir = resolveSourceSubpath(sourceDir, templatePath);
         await copyRenderedDirectory(blockTemplateDir, blockDir, view, {
-            filter: (sourcePath, _destinationPath, entry) => {
+            filter: async (sourcePath, _destinationPath, entry) => {
                 const mustacheVariantPath = path.join(path.dirname(sourcePath), `${entry.name}.mustache`);
                 return !(entry.isFile() &&
                     (entry.name === 'package.json' || entry.name === 'README.md') &&
-                    fs.existsSync(mustacheVariantPath));
+                    (await pathExists(mustacheVariantPath)));
             },
         });
         const assetsPath = typeof variantConfig.assetsPath === 'string'

package/dist/runtime/template-source-remote.d.ts

@@ -2,6 +2,9 @@ import type { ResolvedTemplateSource, SeedSource, TemplateVariableContext } from
 /**
  * Read a remote block source and return its default block category.
  *
+ * @deprecated Use `getDefaultCategoryAsync()` from async template-source paths.
+ * This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Block source directory that may contain a block.json file.
  * @returns The declared block category, or "widgets" when detection fails.
  */
@@ -16,6 +19,9 @@ export declare function getDefaultCategoryAsync(sourceDir: string): Promise<stri
 /**
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
+ *
+ * @deprecated Use `getTemplateProjectTypeAsync()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
  */
 export declare function getTemplateProjectType(sourceDir: string): string | null;
 /**

package/dist/runtime/template-source-remote.js

@@ -59,6 +59,9 @@ async function readRemoteBlockJsonAsync(blockDir) {
 /**
  * Read a remote block source and return its default block category.
  *
+ * @deprecated Use `getDefaultCategoryAsync()` from async template-source paths.
+ * This synchronous helper remains only for compatibility callers.
+ *
  * @param sourceDir Block source directory that may contain a block.json file.
  * @returns The declared block category, or "widgets" when detection fails.
  */
@@ -139,6 +142,9 @@ async function readTemplatePackageJsonAsync(sourceDir) {
 /**
  * Read `wpTypia.projectType` from a rendered or source template package
  * manifest and return it when present.
+ *
+ * @deprecated Use `getTemplateProjectTypeAsync()` from async template-source
+ * paths. This synchronous helper remains only for compatibility callers.
  */
 export function getTemplateProjectType(sourceDir) {
     const packageJsonEntry = readTemplatePackageJson(sourceDir);
@@ -185,11 +191,11 @@ export async function normalizeWpTypiaTemplateSeed(seed) {
     const normalizedDir = path.join(tempRoot, 'template');
     try {
         await copyRawDirectory(seed.blockDir, normalizedDir, {
-            filter: (sourcePath, _targetPath, entry) => {
+            filter: async (sourcePath, _targetPath, entry) => {
                 const mustacheVariantPath = path.join(path.dirname(sourcePath), `${entry.name}.mustache`);
                 return !(entry.isFile() &&
                     (entry.name === 'package.json' || entry.name === 'README.md') &&
-                    fs.existsSync(mustacheVariantPath));
+                    (await pathExists(mustacheVariantPath)));
             },
         });
         if (seed.assetsDir && (await pathExists(seed.assetsDir))) {

package/dist/runtime/template-source-seeds.d.ts

@@ -1,5 +1,18 @@
 import type { RemoteTemplateLocator, SeedSource } from './template-source-contracts.js';
+/**
+ * Synchronously identify the bundled workspace template seed.
+ *
+ * This remains sync-only for compatibility callers. Async template resolution
+ * paths should use `isOfficialWorkspaceTemplateSeedAsync()`.
+ */
 export declare function isOfficialWorkspaceTemplateSeed(seed: SeedSource): boolean;
+/**
+ * Asynchronously identify the bundled workspace template seed.
+ *
+ * @param seed Seed source to inspect.
+ * @returns Whether the seed resolves to the official workspace template package.
+ */
+export declare function isOfficialWorkspaceTemplateSeedAsync(seed: SeedSource): Promise<boolean>;
 export declare function assertNoSymlinks(sourceDir: string): Promise<void>;
 /**
  * Resolves a template locator into a local seed source directory.

package/dist/runtime/template-source-seeds.js

@@ -8,6 +8,7 @@ import { x as extractTarball } from 'tar';
 import { createExternalTemplateTimeoutError, fetchWithExternalTemplateTimeout, getExternalTemplateMetadataMaxBytes, getExternalTemplateTarballMaxBytes, getExternalTemplateTimeoutMs, readBufferResponseWithLimit, readJsonResponseWithLimit, } from './external-template-guards.js';
 import { findReusableExternalTemplateSourceCache, isExternalTemplateCacheEnabled, resolveExternalTemplateSourceCache, } from './template-source-cache.js';
 import { CLI_DIAGNOSTIC_CODES, createCliDiagnosticCodeError, } from './cli-diagnostics.js';
+import { pathExists } from './fs-async.js';
 import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, OFFICIAL_WORKSPACE_TEMPLATE_ALIAS, PROJECT_TOOLS_PACKAGE_ROOT, TEMPLATE_IDS, } from './template-registry.js';
 import { isPlainObject } from './object-utils.js';
 import { createManagedTempRoot } from './temp-roots.js';
@@ -184,7 +185,9 @@ async function fetchNpmTemplateSource(locator) {
  * Resolve a locally installed npm template package from the caller workspace.
  *
  * Bare package ids are preferred here so monorepo and offline workflows can
- * use an already-installed template without forcing a registry fetch.
+ * use an already-installed template without forcing a registry fetch. This
+ * path intentionally keeps Node's synchronous `require.resolve` semantics
+ * because the module resolver itself has no async equivalent.
  */
 function resolveInstalledNpmTemplateSource(locator, cwd) {
     if (locator.rawSpec !== '' && locator.rawSpec !== '*') {
@@ -244,6 +247,12 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
         throw error;
     }
 }
+/**
+ * Synchronously identify the bundled workspace template seed.
+ *
+ * This remains sync-only for compatibility callers. Async template resolution
+ * paths should use `isOfficialWorkspaceTemplateSeedAsync()`.
+ */
 export function isOfficialWorkspaceTemplateSeed(seed) {
     const packageJsonPath = path.join(seed.rootDir, 'package.json');
     if (!fs.existsSync(packageJsonPath)) {
@@ -257,6 +266,25 @@ export function isOfficialWorkspaceTemplateSeed(seed) {
         return false;
     }
 }
+/**
+ * Asynchronously identify the bundled workspace template seed.
+ *
+ * @param seed Seed source to inspect.
+ * @returns Whether the seed resolves to the official workspace template package.
+ */
+export async function isOfficialWorkspaceTemplateSeedAsync(seed) {
+    const packageJsonPath = path.join(seed.rootDir, 'package.json');
+    if (!(await pathExists(packageJsonPath))) {
+        return false;
+    }
+    try {
+        const packageJson = JSON.parse(await fsp.readFile(packageJsonPath, 'utf8'));
+        return packageJson.name === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE;
+    }
+    catch {
+        return false;
+    }
+}
 export async function assertNoSymlinks(sourceDir) {
     const stats = await fsp.lstat(sourceDir);
     if (stats.isSymbolicLink()) {
@@ -300,13 +328,13 @@ function runGitTemplateCommand(args, label, options = {}) {
 function getGitHubTemplateRepositoryUrl(locator) {
     return `https://github.com/${locator.owner}/${locator.repo}.git`;
 }
-function resolveGitHubTemplateDirectory(checkoutDir, locator) {
+async function resolveGitHubTemplateDirectory(checkoutDir, locator) {
     const sourceDir = path.resolve(checkoutDir, locator.sourcePath);
     const relativeSourceDir = path.relative(checkoutDir, sourceDir);
     if (relativeSourceDir.startsWith('..') || path.isAbsolute(relativeSourceDir)) {
         throw new Error('GitHub template path must stay within the cloned repository.');
     }
-    if (!fs.existsSync(sourceDir)) {
+    if (!(await pathExists(sourceDir))) {
         throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
     }
     return sourceDir;
@@ -438,7 +466,7 @@ async function reuseGitHubTemplateCacheByMetadata(locator) {
     if (!cachedSource) {
         return null;
     }
-    const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+    const sourceDir = await resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
     await assertNoSymlinks(sourceDir);
     return {
         blockDir: sourceDir,
@@ -482,12 +510,12 @@ async function resolveGitHubTemplateSource(locator) {
                 namespace: 'github',
             }, async (checkoutDir) => {
                 cloneGitHubTemplateSource(locator, checkoutDir);
-                const sourceDir = resolveGitHubTemplateDirectory(checkoutDir, locator);
+                const sourceDir = await resolveGitHubTemplateDirectory(checkoutDir, locator);
                 await assertNoSymlinks(sourceDir);
                 pinGitHubTemplateCacheRevision(locator, checkoutDir, resolvedCacheRevision);
             });
             if (cachedSource) {
-                const sourceDir = resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
+                const sourceDir = await resolveGitHubTemplateDirectory(cachedSource.sourceDir, locator);
                 await assertNoSymlinks(sourceDir);
                 return {
                     blockDir: sourceDir,
@@ -506,7 +534,7 @@ async function resolveGitHubTemplateSource(locator) {
     const checkoutDir = path.join(remoteRoot, 'source');
     try {
         cloneGitHubTemplateSource(locator, checkoutDir);
-        const sourceDir = resolveGitHubTemplateDirectory(checkoutDir, locator);
+        const sourceDir = await resolveGitHubTemplateDirectory(checkoutDir, locator);
         await assertNoSymlinks(sourceDir);
         return {
             blockDir: sourceDir,
@@ -530,7 +558,7 @@ async function resolveGitHubTemplateSource(locator) {
 export async function resolveTemplateSeed(locator, cwd) {
     if (locator.kind === 'path') {
         const sourceDir = path.resolve(cwd, locator.templatePath);
-        if (!fs.existsSync(sourceDir)) {
+        if (!(await pathExists(sourceDir))) {
             throw new Error(`Template path does not exist: ${sourceDir}`);
         }
         await assertNoSymlinks(sourceDir);

package/dist/runtime/template-source.js

@@ -2,7 +2,7 @@ import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from './tem
 import { resolveBuiltInTemplateSource } from './template-builtins.js';
 import { parseTemplateLocator, } from './template-source-locators.js';
 import { detectTemplateSourceFormat, getTemplateProjectTypeAsync, getDefaultCategoryAsync, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
-import { isOfficialWorkspaceTemplateSeed, resolveTemplateSeed, } from './template-source-seeds.js';
+import { isOfficialWorkspaceTemplateSeedAsync, resolveTemplateSeed, } from './template-source-seeds.js';
 import { assertBuiltInTemplateVariantAllowed, } from './cli-validation.js';
 import { getScaffoldTemplateVariableGroups } from './scaffold-template-variable-groups.js';
 export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
@@ -27,7 +27,7 @@ export async function resolveTemplateSource(templateId, cwd, variables, variant)
     const context = getTemplateVariableContext(variables);
     const seed = await resolveTemplateSeed(locator, cwd);
     const isOfficialWorkspaceTemplate = templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE ||
-        isOfficialWorkspaceTemplateSeed(seed);
+        (await isOfficialWorkspaceTemplateSeedAsync(seed));
     let normalizedSeed = null;
     try {
         const format = await detectTemplateSourceFormat(seed.blockDir);

package/dist/runtime/workspace-inventory.d.ts

@@ -142,6 +142,11 @@ export interface WorkspaceInventory {
     source: string;
     variations: WorkspaceVariationInventoryEntry[];
 }
+export type WorkspaceBlockSelectOption = {
+    description: string;
+    name: string;
+    value: string;
+};
 export declare const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 export declare const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
 export declare const BLOCK_STYLE_CONFIG_ENTRY_MARKER = "\t// wp-typia add style entries";
@@ -199,19 +204,28 @@ export declare function readWorkspaceInventory(projectDir: string): WorkspaceInv
  */
 export declare function readWorkspaceInventoryAsync(projectDir: string): Promise<WorkspaceInventory>;
 /**
- * Return select options for the current workspace block inventory.
+ * Synchronously return select options for the current workspace block inventory.
  *
  * The `description` field mirrors `block.typesFile`, while `name` and `value`
  * both map to the block slug for use in interactive add flows.
  *
+ * @deprecated Use `getWorkspaceBlockSelectOptionsAsync()` from async command
+ * paths. This helper intentionally remains sync-only for compatibility callers.
+ *
  * @param projectDir Workspace root directory.
  * @returns Block options for variation-target selection.
  */
-export declare function getWorkspaceBlockSelectOptions(projectDir: string): Array<{
-    description: string;
-    name: string;
-    value: string;
-}>;
+export declare function getWorkspaceBlockSelectOptions(projectDir: string): WorkspaceBlockSelectOption[];
+/**
+ * Asynchronously return select options for the current workspace block inventory.
+ *
+ * The returned option shape matches `getWorkspaceBlockSelectOptions()` while
+ * avoiding synchronous inventory reads in interactive or async command paths.
+ *
+ * @param projectDir Workspace root directory.
+ * @returns Block options for variation-target selection.
+ */
+export declare function getWorkspaceBlockSelectOptionsAsync(projectDir: string): Promise<WorkspaceBlockSelectOption[]>;
 /**
  * Update `scripts/block-config.ts` source text with additional inventory entries.
  *

package/dist/runtime/workspace-inventory.js

@@ -5,8 +5,8 @@ import ts from "typescript";
 import { REST_RESOURCE_METHOD_IDS } from "./cli-add-shared.js";
 import { escapeRegex } from "./php-utils.js";
 import { getPropertyNameText } from "./ts-property-names.js";
-function defineInventoryEntryParser(descriptor) {
-    return descriptor;
+function defineInventoryEntryParser() {
+    return (descriptor) => descriptor;
 }
 export const BLOCK_CONFIG_ENTRY_MARKER = "\t// wp-typia add block entries";
 export const VARIATION_CONFIG_ENTRY_MARKER = "\t// wp-typia add variation entries";
@@ -213,7 +213,7 @@ const BLOCK_INVENTORY_SECTION = {
     },
     parse: {
         entriesKey: "blocks",
-        entry: defineInventoryEntryParser({
+        entry: defineInventoryEntryParser()({
             entryName: "BLOCKS",
             fields: [
                 { key: "apiTypesFile" },
@@ -239,7 +239,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "variations",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "VARIATIONS",
                 fields: [
                     { key: "block", required: true },
@@ -265,7 +265,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "blockStyles",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "BLOCK_STYLES",
                 fields: [
                     { key: "block", required: true },
@@ -291,7 +291,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "blockTransforms",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "BLOCK_TRANSFORMS",
                 fields: [
                     { key: "block", required: true },
@@ -319,7 +319,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "patterns",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "PATTERNS",
                 fields: [
                     { key: "file", required: true },
@@ -344,7 +344,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "bindingSources",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "BINDING_SOURCES",
                 fields: [
                     { key: "attribute" },
@@ -372,7 +372,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "restResources",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "REST_RESOURCES",
                 fields: [
                     { key: "apiFile", required: true },
@@ -416,7 +416,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "abilities",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "ABILITIES",
                 fields: [
                     { key: "clientFile", required: true },
@@ -449,7 +449,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "aiFeatures",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "AI_FEATURES",
                 fields: [
                     { key: "aiSchemaFile", required: true },
@@ -482,7 +482,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "adminViews",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "ADMIN_VIEWS",
                 fields: [
                     { key: "file", required: true },
@@ -509,7 +509,7 @@ const INVENTORY_SECTIONS = [
         },
         parse: {
             entriesKey: "editorPlugins",
-            entry: defineInventoryEntryParser({
+            entry: defineInventoryEntryParser()({
                 entryName: "EDITOR_PLUGINS",
                 fields: [
                     { key: "file", required: true },
@@ -570,14 +570,7 @@ function getOptionalStringProperty(entryName, elementIndex, objectLiteral, key)
     }
     return undefined;
 }
-function getRequiredStringProperty(entryName, elementIndex, objectLiteral, key) {
-    const value = getOptionalStringProperty(entryName, elementIndex, objectLiteral, key);
-    if (!value) {
-        throw new Error(`${entryName}[${elementIndex}] is missing required "${key}" in scripts/block-config.ts.`);
-    }
-    return value;
-}
-function getRequiredStringArrayProperty(entryName, elementIndex, objectLiteral, key) {
+function getOptionalStringArrayProperty(entryName, elementIndex, objectLiteral, key) {
     for (const property of objectLiteral.properties) {
         if (!ts.isPropertyAssignment(property)) {
             continue;
@@ -596,7 +589,24 @@ function getRequiredStringArrayProperty(entryName, elementIndex, objectLiteral,
             return element.text;
         });
     }
-    throw new Error(`${entryName}[${elementIndex}] is missing required "${key}" in scripts/block-config.ts.`);
+    return undefined;
+}
+function isMissingRequiredInventoryValue(value) {
+    return value === undefined || (typeof value === "string" && value.length === 0);
+}
+function formatMissingRequiredInventoryFields(keys) {
+    return keys.length === 1
+        ? `required "${keys[0]}"`
+        : `required fields ${keys.map((key) => `"${key}"`).join(", ")}`;
+}
+function assertParsedInventoryEntry(entry, descriptor, elementIndex) {
+    const missingRequiredKeys = descriptor.fields
+        .filter((field) => field.required === true &&
+        isMissingRequiredInventoryValue(entry[field.key]))
+        .map((field) => field.key);
+    if (missingRequiredKeys.length > 0) {
+        throw new Error(`${descriptor.entryName}[${elementIndex}] is missing ${formatMissingRequiredInventoryFields(missingRequiredKeys)} in scripts/block-config.ts.`);
+    }
 }
 function parseInventoryEntries(arrayLiteral, descriptor) {
     return arrayLiteral.elements.map((element, elementIndex) => {
@@ -607,10 +617,8 @@ function parseInventoryEntries(arrayLiteral, descriptor) {
         for (const field of descriptor.fields) {
             const kind = field.kind ?? "string";
             const value = kind === "stringArray"
-                ? getRequiredStringArrayProperty(descriptor.entryName, elementIndex, element, field.key)
-                : field.required
-                    ? getRequiredStringProperty(descriptor.entryName, elementIndex, element, field.key)
-                    : getOptionalStringProperty(descriptor.entryName, elementIndex, element, field.key);
+                ? getOptionalStringArrayProperty(descriptor.entryName, elementIndex, element, field.key)
+                : getOptionalStringProperty(descriptor.entryName, elementIndex, element, field.key);
             field.validate?.(value, {
                 elementIndex,
                 entryName: descriptor.entryName,
@@ -618,6 +626,7 @@ function parseInventoryEntries(arrayLiteral, descriptor) {
             });
             entry[field.key] = value;
         }
+        assertParsedInventoryEntry(entry, descriptor, elementIndex);
         return entry;
     });
 }
@@ -757,21 +766,39 @@ export async function readWorkspaceInventoryAsync(projectDir) {
         ...parseWorkspaceInventorySource(source),
     };
 }
+function toWorkspaceBlockSelectOptions(blocks) {
+    return blocks.map((block) => ({
+        description: block.typesFile,
+        name: block.slug,
+        value: block.slug,
+    }));
+}
 /**
- * Return select options for the current workspace block inventory.
+ * Synchronously return select options for the current workspace block inventory.
  *
  * The `description` field mirrors `block.typesFile`, while `name` and `value`
  * both map to the block slug for use in interactive add flows.
  *
+ * @deprecated Use `getWorkspaceBlockSelectOptionsAsync()` from async command
+ * paths. This helper intentionally remains sync-only for compatibility callers.
+ *
  * @param projectDir Workspace root directory.
  * @returns Block options for variation-target selection.
  */
 export function getWorkspaceBlockSelectOptions(projectDir) {
-    return readWorkspaceInventory(projectDir).blocks.map((block) => ({
-        description: block.typesFile,
-        name: block.slug,
-        value: block.slug,
-    }));
+    return toWorkspaceBlockSelectOptions(readWorkspaceInventory(projectDir).blocks);
+}
+/**
+ * Asynchronously return select options for the current workspace block inventory.
+ *
+ * The returned option shape matches `getWorkspaceBlockSelectOptions()` while
+ * avoiding synchronous inventory reads in interactive or async command paths.
+ *
+ * @param projectDir Workspace root directory.
+ * @returns Block options for variation-target selection.
+ */
+export async function getWorkspaceBlockSelectOptionsAsync(projectDir) {
+    return toWorkspaceBlockSelectOptions((await readWorkspaceInventoryAsync(projectDir)).blocks);
 }
 function ensureWorkspaceInventorySections(source) {
     let nextSource = source.trimEnd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/project-tools",
-  "version": "0.22.8",
+  "version": "0.22.9",
   "description": "Project orchestration and programmatic tooling for wp-typia",
   "packageManager": "bun@1.3.11",
   "type": "module",
@@ -52,6 +52,11 @@
       "import": "./dist/runtime/create-template-validation.js",
       "default": "./dist/runtime/create-template-validation.js"
     },
+    "./id-suggestions": {
+      "types": "./dist/runtime/id-suggestions.d.ts",
+      "import": "./dist/runtime/id-suggestions.js",
+      "default": "./dist/runtime/id-suggestions.js"
+    },
     "./ai-artifacts": {
       "types": "./dist/runtime/ai-artifacts.d.ts",
       "import": "./dist/runtime/ai-artifacts.js",