wp-typia 0.22.4 → 0.22.6

package/dist-bunli/{cli-6ymn63t4.js → cli-6a65qfb1.js}

@@ -4,14 +4,14 @@ import {
 } from "./cli-1sm60g1z.js";
 import {
   seedProjectMigrations
-} from "./cli-2mt6bvcj.js";
+} from "./cli-0q0tz4dq.js";
 import {
   ensureMigrationDirectories,
   isPlainObject,
   stableJsonStringify,
   writeInitialMigrationScaffold,
   writeMigrationConfig
-} from "./cli-hb9vpsev.js";
+} from "./cli-2rqf6t0b.js";
 import {
   getBuiltInSharedTemplateLayerDir,
   getBuiltInTemplateLayerDirs,
@@ -51,7 +51,7 @@ import {
   toTitleCase,
   validateBlockSlug,
   validateNamespace
-} from "./cli-qr2ek735.js";
+} from "./cli-5kn2p7ee.js";
 import {
   createManagedTempRoot
 } from "./cli-t73q5aqz.js";
@@ -66,7 +66,7 @@ import {
   formatRunScript,
   getPackageManager,
   transformPackageManagerText
-} from "./cli-6bhfzq5e.js";
+} from "./cli-52ke0ptp.js";
 import {
   __commonJS,
   __require,
@@ -4548,7 +4548,7 @@ function getPhpRestExtensionPointsSection(templateId, { compoundPersistenceEnabl
 
 // ../wp-typia-project-tools/src/runtime/scaffold-bootstrap.ts
 import fs2 from "fs";
-import { promises as fsp3 } from "fs";
+import { promises as fsp4 } from "fs";
 import path4 from "path";
 
 // ../wp-typia-project-tools/src/runtime/persistence-rest-artifacts.ts
@@ -5679,17 +5679,41 @@ function stringifyStarterManifest(document) {
 `;
 }
 
+// ../wp-typia-project-tools/src/runtime/fs-async.ts
+import { promises as fsp3 } from "fs";
+async function pathExists(filePath) {
+  try {
+    await fsp3.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readOptionalUtf8File(filePath) {
+  try {
+    return await fsp3.readFile(filePath, "utf8");
+  } catch (error) {
+    if (isFileNotFoundError(error)) {
+      return null;
+    }
+    throw error;
+  }
+}
+function getNodeErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+}
+function isFileNotFoundError(error) {
+  return getNodeErrorCode(error) === "ENOENT";
+}
+
 // ../wp-typia-project-tools/src/runtime/scaffold-bootstrap.ts
 var EPHEMERAL_NODE_MODULES_LINK_TYPE = process.platform === "win32" ? "junction" : "dir";
 async function ensureScaffoldDirectory(targetDir, allowExisting = false) {
-  if (!fs2.existsSync(targetDir)) {
-    await fsp3.mkdir(targetDir, { recursive: true });
-    return;
-  }
+  await fsp4.mkdir(targetDir, { recursive: true });
   if (allowExisting) {
     return;
   }
-  const entries = await fsp3.readdir(targetDir);
+  const entries = await fsp4.readdir(targetDir);
   if (entries.length > 0) {
     throw new Error(formatNonEmptyTargetDirectoryError(targetDir));
   }
@@ -5708,8 +5732,8 @@ async function writeStarterManifestFiles(targetDir, templateId, variables) {
   const manifests = getStarterManifestFiles(templateId, variables);
   for (const { document, relativePath } of manifests) {
     const destinationPath = path4.join(targetDir, relativePath);
-    await fsp3.mkdir(path4.dirname(destinationPath), { recursive: true });
-    await fsp3.writeFile(destinationPath, stringifyStarterManifest(document), "utf8");
+    await fsp4.mkdir(path4.dirname(destinationPath), { recursive: true });
+    await fsp4.writeFile(destinationPath, stringifyStarterManifest(document), "utf8");
   }
 }
 async function seedBuiltInPersistenceArtifacts(targetDir, templateId, variables) {
@@ -5741,7 +5765,7 @@ function isWorkspaceProject(projectDir) {
 }
 async function applyWorkspaceMigrationCapability(projectDir, packageManager) {
   const packageJsonPath = path4.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp3.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fsp4.readFile(packageJsonPath, "utf8"));
   const wpTypiaPackageVersion = getPackageVersions().wpTypiaPackageVersion;
   const canonicalCliSpecifier = wpTypiaPackageVersion === "^0.0.0" ? "wp-typia" : `wp-typia@${wpTypiaPackageVersion.replace(/^[~^]/u, "")}`;
   const migrationCli = (args) => formatPackageExecCommand(packageManager, canonicalCliSpecifier, `migrate ${args}`);
@@ -5756,7 +5780,7 @@ async function applyWorkspaceMigrationCapability(projectDir, packageManager) {
     "migration:verify": migrationCli("verify --all"),
     "migration:fuzz": migrationCli("fuzz --all")
   };
-  await fsp3.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp4.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
   writeMigrationConfig(projectDir, {
     blocks: [],
@@ -5767,14 +5791,14 @@ async function applyWorkspaceMigrationCapability(projectDir, packageManager) {
   ensureMigrationDirectories(projectDir, []);
   writeInitialMigrationScaffold(projectDir, "v1", []);
 }
-function resolveScaffoldGeneratorNodeModulesPath() {
+async function resolveScaffoldGeneratorNodeModulesPath() {
   const candidates = [
     path4.join(PROJECT_TOOLS_PACKAGE_ROOT, "node_modules"),
     path4.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", ".."),
     path4.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..", "..", "node_modules")
   ];
   for (const candidate of candidates) {
-    if (fs2.existsSync(path4.join(candidate, "typia", "package.json"))) {
+    if (await pathExists(path4.join(candidate, "typia", "package.json"))) {
       return candidate;
     }
   }
@@ -5782,19 +5806,19 @@ function resolveScaffoldGeneratorNodeModulesPath() {
 }
 async function withEphemeralScaffoldNodeModules(targetDir, callback) {
   const targetNodeModulesPath = path4.join(targetDir, "node_modules");
-  if (fs2.existsSync(targetNodeModulesPath)) {
+  if (await pathExists(targetNodeModulesPath)) {
     await callback();
     return;
   }
-  const sourceNodeModulesPath = resolveScaffoldGeneratorNodeModulesPath();
+  const sourceNodeModulesPath = await resolveScaffoldGeneratorNodeModulesPath();
   if (!sourceNodeModulesPath) {
     throw new Error("Unable to resolve a node_modules directory with typia for scaffold-time REST artifact generation.");
   }
-  await fsp3.symlink(sourceNodeModulesPath, targetNodeModulesPath, EPHEMERAL_NODE_MODULES_LINK_TYPE);
+  await fsp4.symlink(sourceNodeModulesPath, targetNodeModulesPath, EPHEMERAL_NODE_MODULES_LINK_TYPE);
   try {
     await callback();
   } finally {
-    await fsp3.rm(targetNodeModulesPath, { force: true, recursive: true });
+    await fsp4.rm(targetNodeModulesPath, { force: true, recursive: true });
   }
 }
 
@@ -6219,37 +6243,36 @@ async function collectScaffoldAnswers({
 }
 
 // ../wp-typia-project-tools/src/runtime/scaffold.ts
-import fs15 from "fs";
-import { promises as fsp11 } from "fs";
+import fs12 from "fs";
+import { promises as fsp13 } from "fs";
 import path18 from "path";
 
 // ../wp-typia-project-tools/src/runtime/scaffold-apply-utils.ts
-import fs6 from "fs";
-import { promises as fsp6 } from "fs";
+import { promises as fsp7 } from "fs";
 import path11 from "path";
 import { execSync as execSync3 } from "child_process";
 import { fileURLToPath } from "url";
 
 // ../wp-typia-project-tools/src/runtime/migration-ui-capability.ts
-import { promises as fsp4 } from "fs";
+import { promises as fsp5 } from "fs";
 import path8 from "path";
 var INITIAL_MIGRATION_VERSION = "v1";
 var BLOCK_METADATA_IMPORT_LINE = "import metadata from './block-metadata';";
 var LEGACY_BLOCK_JSON_IMPORT_LINE = "import metadata from './block.json';";
 async function mutatePackageJson2(projectDir, mutate) {
   const packageJsonPath = path8.join(projectDir, "package.json");
-  const packageJson = JSON.parse(await fsp4.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fsp5.readFile(packageJsonPath, "utf8"));
   mutate(packageJson);
-  await fsp4.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function patchFile(filePath, transform) {
-  const source = await fsp4.readFile(filePath, "utf8");
+  const source = await fsp5.readFile(filePath, "utf8");
   const nextSource = transform(source);
   if (nextSource === source) {
     throw new Error(`Unable to apply migration UI patch for ${filePath}`);
   }
-  await fsp4.writeFile(filePath, nextSource, "utf8");
+  await fsp5.writeFile(filePath, nextSource, "utf8");
 }
 function injectAfter(source, needle, insertion) {
   if (source.includes(insertion)) {
@@ -6458,6 +6481,18 @@ function formatReadmeTemplateIdentity(templateId) {
   return [`- Template id: ${templateId}`, "- Type: custom or external scaffold"].join(`
 `);
 }
+function getPackageManagerInstallGuidance(packageManager) {
+  if (packageManager !== "npm") {
+    return "";
+  }
+  const installCommand = formatInstallCommand(packageManager);
+  return [
+    "",
+    `> npm note: the scaffold uses \`${installCommand}\` for the first install so npm does not spend the initial create flow in the audit resolver. Run \`npm audit\` separately when you want npm vulnerability output.`,
+    "> If npm prints React peer dependency noise from WordPress block-editor packages, validate with `npm run typecheck` and `npm run build` before changing WordPress package ranges."
+  ].join(`
+`);
+}
 function buildReadme(templateId, variables, packageManager, {
   withMigrationUi = false,
   withTestPreset = false,
@@ -6552,6 +6587,7 @@ ${formatReadmeTemplateIdentity(templateId)}
 ${formatInstallCommand(packageManager)}
 ${formatRunScript(packageManager, developmentScript)}
 \`\`\`
+${getPackageManagerInstallGuidance(packageManager)}
 
 ${getQuickStartWorkflowNote(packageManager, templateId, {
     compoundPersistenceEnabled
@@ -6647,8 +6683,7 @@ function mergeTextLines(primaryContent, existingContent) {
 }
 
 // ../wp-typia-project-tools/src/runtime/scaffold-package-manager-files.ts
-import fs4 from "fs";
-import { promises as fsp5 } from "fs";
+import { promises as fsp6 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import path9 from "path";
 var LOCKFILES = {
@@ -6660,19 +6695,20 @@ var LOCKFILES = {
 async function normalizePackageManagerFiles(targetDir, packageManagerId) {
   const yarnRcPath = path9.join(targetDir, ".yarnrc.yml");
   if (packageManagerId === "yarn") {
-    await fsp5.writeFile(yarnRcPath, `nodeLinker: node-modules
+    await fsp6.writeFile(yarnRcPath, `nodeLinker: node-modules
 `, "utf8");
     return;
   }
-  await fsp5.rm(yarnRcPath, { force: true });
+  await fsp6.rm(yarnRcPath, { force: true });
 }
 async function normalizePackageJson(targetDir, packageManagerId) {
   const packageJsonPath = path9.join(targetDir, "package.json");
-  if (!fs4.existsSync(packageJsonPath)) {
+  const packageJsonSource = await readOptionalUtf8File(packageJsonPath);
+  if (packageJsonSource === null) {
     return;
   }
   const packageManager = getPackageManager(packageManagerId);
-  const packageJson = JSON.parse(await fsp5.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(packageJsonSource);
   if (packageManagerId === "npm") {
     delete packageJson.packageManager;
   } else {
@@ -6685,7 +6721,7 @@ async function normalizePackageJson(targetDir, packageManagerId) {
       }
     }
   }
-  await fsp5.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
+  await fsp6.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, "\t")}
 `, "utf8");
 }
 async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
@@ -6695,7 +6731,7 @@ async function removeUnexpectedLockfiles(targetDir, packageManagerId) {
     if (keep.has(filename)) {
       return;
     }
-    await fsp5.rm(path9.join(targetDir, filename), { force: true });
+    await fsp6.rm(path9.join(targetDir, filename), { force: true });
   }));
 }
 async function defaultInstallDependencies({
@@ -6708,7 +6744,7 @@ async function defaultInstallDependencies({
   });
 }
 // ../wp-typia-project-tools/src/runtime/scaffold-repository-reference.ts
-import fs5 from "fs";
+import fs4 from "fs";
 import { createRequire } from "module";
 import path10 from "path";
 var require2 = createRequire(import.meta.url);
@@ -6718,7 +6754,7 @@ function getErrorCode(error) {
 }
 function readRepositoryPackageManifest(packageJsonPath) {
   try {
-    return JSON.parse(fs5.readFileSync(packageJsonPath, "utf8"));
+    return JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
   } catch (error) {
     if (getErrorCode(error) === "ENOENT") {
       return null;
@@ -6813,14 +6849,11 @@ var LOCKFILES2 = {
   yarn: ["yarn.lock"]
 };
 async function ensureDirectory(targetDir, allowExisting = false) {
-  if (!fs6.existsSync(targetDir)) {
-    await fsp6.mkdir(targetDir, { recursive: true });
-    return;
-  }
+  await fsp7.mkdir(targetDir, { recursive: true });
   if (allowExisting) {
     return;
   }
-  const entries = await fsp6.readdir(targetDir);
+  const entries = await fsp7.readdir(targetDir);
   if (entries.length > 0) {
     throw new Error(formatNonEmptyTargetDirectoryError(targetDir));
   }
@@ -6832,26 +6865,26 @@ async function writeStarterManifestFiles2(targetDir, templateId, variables, arti
   })) : getStarterManifestFiles(templateId, variables);
   for (const { document, relativePath } of manifests) {
     const destinationPath = path11.join(targetDir, relativePath);
-    await fsp6.mkdir(path11.dirname(destinationPath), { recursive: true });
-    await fsp6.writeFile(destinationPath, stringifyStarterManifest(document), "utf8");
+    await fsp7.mkdir(path11.dirname(destinationPath), { recursive: true });
+    await fsp7.writeFile(destinationPath, stringifyStarterManifest(document), "utf8");
   }
 }
 async function writeBuiltInStructuralArtifacts(targetDir, artifacts) {
   for (const artifact of artifacts) {
     const destinationDir = path11.join(targetDir, artifact.relativeDir);
-    await fsp6.mkdir(destinationDir, { recursive: true });
-    await fsp6.writeFile(path11.join(destinationDir, "types.ts"), artifact.typesSource, "utf8");
-    await fsp6.writeFile(path11.join(destinationDir, "block.json"), stringifyBuiltInBlockJsonDocument(artifact.blockJsonDocument), "utf8");
+    await fsp7.mkdir(destinationDir, { recursive: true });
+    await fsp7.writeFile(path11.join(destinationDir, "types.ts"), artifact.typesSource, "utf8");
+    await fsp7.writeFile(path11.join(destinationDir, "block.json"), stringifyBuiltInBlockJsonDocument(artifact.blockJsonDocument), "utf8");
   }
 }
 async function writeBuiltInCodeArtifacts(targetDir, codeArtifacts) {
   for (const artifact of codeArtifacts) {
     const destinationPath = path11.join(targetDir, artifact.relativePath);
-    await fsp6.mkdir(path11.dirname(destinationPath), { recursive: true });
-    await fsp6.writeFile(destinationPath, artifact.source, "utf8");
+    await fsp7.mkdir(path11.dirname(destinationPath), { recursive: true });
+    await fsp7.writeFile(destinationPath, artifact.source, "utf8");
   }
 }
-function resolveScaffoldGeneratorNodeModulesPath2() {
+async function resolveScaffoldGeneratorNodeModulesPath2() {
   const projectToolsPackageRoot = path11.resolve(__dirname2, "..", "..");
   const candidates = [
     path11.join(projectToolsPackageRoot, "node_modules"),
@@ -6859,7 +6892,7 @@ function resolveScaffoldGeneratorNodeModulesPath2() {
     path11.resolve(projectToolsPackageRoot, "..", "..", "node_modules")
   ];
   for (const candidate of candidates) {
-    if (fs6.existsSync(path11.join(candidate, "typia", "package.json"))) {
+    if (await pathExists(path11.join(candidate, "typia", "package.json"))) {
       return candidate;
     }
   }
@@ -6867,19 +6900,19 @@ function resolveScaffoldGeneratorNodeModulesPath2() {
 }
 async function withEphemeralScaffoldNodeModules2(targetDir, callback) {
   const targetNodeModulesPath = path11.join(targetDir, "node_modules");
-  if (fs6.existsSync(targetNodeModulesPath)) {
+  if (await pathExists(targetNodeModulesPath)) {
     await callback();
     return;
   }
-  const sourceNodeModulesPath = resolveScaffoldGeneratorNodeModulesPath2();
+  const sourceNodeModulesPath = await resolveScaffoldGeneratorNodeModulesPath2();
   if (!sourceNodeModulesPath) {
     throw new Error("Unable to resolve a node_modules directory with typia for scaffold-time REST artifact generation.");
   }
-  await fsp6.symlink(sourceNodeModulesPath, targetNodeModulesPath, EPHEMERAL_NODE_MODULES_LINK_TYPE2);
+  await fsp7.symlink(sourceNodeModulesPath, targetNodeModulesPath, EPHEMERAL_NODE_MODULES_LINK_TYPE2);
   try {
     await callback();
   } finally {
-    await fsp6.rm(targetNodeModulesPath, { force: true, recursive: true });
+    await fsp7.rm(targetNodeModulesPath, { force: true, recursive: true });
   }
 }
 async function seedBuiltInPersistenceArtifacts2(targetDir, templateId, variables) {
@@ -6908,19 +6941,17 @@ async function seedBuiltInPersistenceArtifacts2(targetDir, templateId, variables
 async function normalizePackageManagerFiles2(targetDir, packageManagerId) {
   const yarnRcPath = path11.join(targetDir, ".yarnrc.yml");
   if (packageManagerId === "yarn") {
-    await fsp6.writeFile(yarnRcPath, `nodeLinker: node-modules
+    await fsp7.writeFile(yarnRcPath, `nodeLinker: node-modules
 `, "utf8");
     return;
   }
-  if (fs6.existsSync(yarnRcPath)) {
-    await fsp6.rm(yarnRcPath, { force: true });
-  }
+  await fsp7.rm(yarnRcPath, { force: true });
 }
 async function removeQueryLoopPlaceholderFiles(projectDir, templateId) {
   if (templateId !== "query-loop") {
     return;
   }
-  await fsp6.rm(path11.join(projectDir, "src", "validator-toolkit.ts"), {
+  await fsp7.rm(path11.join(projectDir, "src", "validator-toolkit.ts"), {
     force: true
   });
 }
@@ -6931,10 +6962,7 @@ async function removeUnexpectedLockfiles2(targetDir, packageManagerId) {
     if (keep.has(filename)) {
       return;
     }
-    const filePath = path11.join(targetDir, filename);
-    if (fs6.existsSync(filePath)) {
-      await fsp6.rm(filePath, { force: true });
-    }
+    await fsp7.rm(path11.join(targetDir, filename), { force: true });
   }));
 }
 async function replaceTextRecursively(targetDir, packageManagerId, {
@@ -6957,9 +6985,9 @@ async function replaceTextRecursively(targetDir, packageManagerId, {
     manifestPaths: repositoryManifestPaths
   });
   async function visit(currentPath) {
-    const stats = await fsp6.stat(currentPath);
+    const stats = await fsp7.stat(currentPath);
     if (stats.isDirectory()) {
-      const entries = await fsp6.readdir(currentPath);
+      const entries = await fsp7.readdir(currentPath);
       for (const entry of entries) {
         await visit(path11.join(currentPath, entry));
       }
@@ -6968,10 +6996,10 @@ async function replaceTextRecursively(targetDir, packageManagerId, {
     if (path11.basename(currentPath) === "package.json" || !textExtensions.has(path11.extname(currentPath))) {
       return;
     }
-    const content = await fsp6.readFile(currentPath, "utf8");
+    const content = await fsp7.readFile(currentPath, "utf8");
     const nextContent = replaceRepositoryReferencePlaceholders(transformPackageManagerText(content, packageManagerId), resolvedRepositoryReference);
     if (nextContent !== content) {
-      await fsp6.writeFile(currentPath, nextContent, "utf8");
+      await fsp7.writeFile(currentPath, nextContent, "utf8");
     }
   }
   await visit(targetDir);
@@ -7044,16 +7072,16 @@ async function applyBuiltInScaffoldProjectFiles({
     title: "Finalizing scaffold output"
   });
   const readmePath = path11.join(projectDir, "README.md");
-  if (!fs6.existsSync(readmePath)) {
-    await fsp6.writeFile(readmePath, readmeContent ?? buildReadme(templateId, variables, packageManager, {
+  if (!await pathExists(readmePath)) {
+    await fsp7.writeFile(readmePath, readmeContent ?? buildReadme(templateId, variables, packageManager, {
       withMigrationUi,
       withTestPreset,
       withWpEnv
     }), "utf8");
   }
   const gitignorePath = path11.join(projectDir, ".gitignore");
-  const existingGitignore = fs6.existsSync(gitignorePath) ? await fsp6.readFile(gitignorePath, "utf8") : "";
-  await fsp6.writeFile(gitignorePath, mergeTextLines(gitignoreContent ?? buildGitignore(), existingGitignore), "utf8");
+  const existingGitignore = await readOptionalUtf8File(gitignorePath) ?? "";
+  await fsp7.writeFile(gitignorePath, mergeTextLines(gitignoreContent ?? buildGitignore(), existingGitignore), "utf8");
   await normalizePackageJson(projectDir, packageManager);
   await applyGeneratedProjectDxPackageJson({
     compoundPersistenceEnabled: variables.compoundPersistenceEnabled === "true",
@@ -7084,13 +7112,12 @@ async function applyBuiltInScaffoldProjectFiles({
 }
 
 // ../wp-typia-project-tools/src/runtime/template-source-normalization.ts
-import fs11 from "fs";
 import path15 from "path";
 
 // ../wp-typia-project-tools/src/runtime/template-layers.ts
-import fs7 from "fs";
+import fs5 from "fs";
 import path12 from "path";
-import { promises as fsp7 } from "fs";
+import { promises as fsp8 } from "fs";
 var TEMPLATE_LAYER_MANIFEST_FILENAME = "wp-typia.layers.json";
 var TEMPLATE_LAYER_MANIFEST_VERSION = 1;
 function resolveLayerPath(sourceRoot, relativePath) {
@@ -7102,14 +7129,14 @@ function resolveLayerPath(sourceRoot, relativePath) {
   return targetPath;
 }
 async function assertNoSymlinks(sourceDir) {
-  const stats = await fsp7.lstat(sourceDir);
+  const stats = await fsp8.lstat(sourceDir);
   if (stats.isSymbolicLink()) {
     throw new Error(`Template layer packages may not include symbolic links: ${sourceDir}`);
   }
   if (!stats.isDirectory()) {
     return;
   }
-  for (const entry of await fsp7.readdir(sourceDir)) {
+  for (const entry of await fsp8.readdir(sourceDir)) {
     await assertNoSymlinks(path12.join(sourceDir, entry));
   }
 }
@@ -7140,10 +7167,10 @@ function parseLayerDefinition(layerId, value) {
 }
 async function loadExternalTemplateLayerManifest(sourceRoot) {
   const manifestPath = path12.join(sourceRoot, TEMPLATE_LAYER_MANIFEST_FILENAME);
-  if (!fs7.existsSync(manifestPath)) {
+  if (!fs5.existsSync(manifestPath)) {
     return null;
   }
-  const raw = JSON.parse(await fsp7.readFile(manifestPath, "utf8"));
+  const raw = JSON.parse(await fsp8.readFile(manifestPath, "utf8"));
   if (!isPlainObject(raw)) {
     throw new Error(`${TEMPLATE_LAYER_MANIFEST_FILENAME} must export a JSON object.`);
   }
@@ -7237,7 +7264,7 @@ async function resolveExternalTemplateLayers({
       return;
     }
     const layerDir = resolveLayerPath(sourceRoot, definition.path);
-    const stats = await fsp7.stat(layerDir).catch(() => null);
+    const stats = await fsp8.stat(layerDir).catch(() => null);
     if (!stats || !stats.isDirectory()) {
       throw new Error(`Layer "${layerId}" points to a missing directory: ${definition.path}`);
     }
@@ -7275,12 +7302,13 @@ async function assertExternalTemplateLayersDoNotWriteProtectedOutputs({
 }
 
 // ../wp-typia-project-tools/src/runtime/template-source-external.ts
-import fs9 from "fs";
+import fs7 from "fs";
+import { promises as fsp9 } from "fs";
 import path13 from "path";
 import { pathToFileURL } from "url";
 
 // ../wp-typia-project-tools/src/runtime/external-template-guards.ts
-import fs8 from "fs";
+import fs6 from "fs";
 var TEMPLATE_SOURCE_TIMEOUT_CODE = "template-source-timeout";
 var TEMPLATE_SOURCE_TOO_LARGE_CODE = "template-source-too-large";
 var DEFAULT_EXTERNAL_TEMPLATE_TIMEOUT_MS = 20000;
@@ -7322,7 +7350,7 @@ function createExternalTemplateTooLargeError(label, maxBytes) {
   return createTemplateGuardError(TEMPLATE_SOURCE_TOO_LARGE_CODE, `${label} exceeded the external template size limit (${maxBytes} bytes).`);
 }
 function assertExternalTemplateFileSize(filePath, options) {
-  const stats = fs8.statSync(filePath);
+  const stats = fs6.statSync(filePath);
   if (stats.size > options.maxBytes) {
     throw createExternalTemplateTooLargeError(options.label, options.maxBytes);
   }
@@ -7427,17 +7455,17 @@ function resolveSourceSubpath(sourceDir, relativePath) {
   }
   return targetPath;
 }
-function getExternalTemplateEntry(sourceDir) {
+async function findExternalTemplateEntry(sourceDir) {
   for (const filename of EXTERNAL_TEMPLATE_ENTRY_CANDIDATES) {
     const candidate = path13.join(sourceDir, filename);
-    if (fs9.existsSync(candidate)) {
+    if (await pathExists(candidate)) {
       return candidate;
     }
   }
   return null;
 }
 async function loadExternalTemplateConfig(sourceDir) {
-  const entryPath = getExternalTemplateEntry(sourceDir);
+  const entryPath = await findExternalTemplateEntry(sourceDir);
   if (!entryPath) {
     throw new Error(`No external template config entry found in ${sourceDir}.`);
   }
@@ -7445,7 +7473,8 @@ async function loadExternalTemplateConfig(sourceDir) {
     label: `External template config "${entryPath}"`,
     maxBytes: getExternalTemplateConfigMaxBytes()
   });
-  const moduleUrl = `${pathToFileURL(entryPath).href}?mtime=${fs9.statSync(entryPath).mtimeMs}`;
+  const entryStats = await fsp9.stat(entryPath);
+  const moduleUrl = `${pathToFileURL(entryPath).href}?mtime=${entryStats.mtimeMs}`;
   const loadedModule = await withExternalTemplateTimeout(`loading external template config "${entryPath}"`, () => import(moduleUrl));
   const loadedConfig = loadedModule.default ?? loadedModule;
   if (!isPlainObject(loadedConfig)) {
@@ -7558,15 +7587,16 @@ async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVa
     await copyRenderedDirectory(blockTemplateDir, blockDir, view, {
       filter: (sourcePath, _destinationPath, entry) => {
         const mustacheVariantPath = path13.join(path13.dirname(sourcePath), `${entry.name}.mustache`);
-        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs9.existsSync(mustacheVariantPath));
+        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs7.existsSync(mustacheVariantPath));
       }
     });
     const assetsPath = typeof variantConfig.assetsPath === "string" ? variantConfig.assetsPath : config.assetsPath;
     if (typeof assetsPath === "string" && assetsPath.trim().length > 0) {
       await copyRawDirectory(resolveSourceSubpath(sourceDir, assetsPath), path13.join(tempRoot, "assets"));
     }
+    const assetsDir = path13.join(tempRoot, "assets");
     return {
-      assetsDir: fs9.existsSync(path13.join(tempRoot, "assets")) ? path13.join(tempRoot, "assets") : undefined,
+      assetsDir: await pathExists(assetsDir) ? assetsDir : undefined,
       blockDir,
       cleanup,
       formatHint,
@@ -7581,8 +7611,8 @@ async function renderCreateBlockExternalTemplate(sourceDir, context, requestedVa
 }
 
 // ../wp-typia-project-tools/src/runtime/template-source-remote.ts
-import fs10 from "fs";
-import { promises as fsp8 } from "fs";
+import fs8 from "fs";
+import { promises as fsp10 } from "fs";
 import path14 from "path";
 async function cleanupSeedRootPair(cleanup, seedCleanup) {
   let cleanupError;
@@ -7603,32 +7633,32 @@ async function cleanupSeedRootPair(cleanup, seedCleanup) {
 function getDefaultCategoryFromBlockJson(blockJson) {
   return typeof blockJson.category === "string" && blockJson.category.trim().length > 0 ? blockJson.category.trim() : "widgets";
 }
-function readRemoteBlockJson(blockDir) {
-  const sourceRoot = fs10.existsSync(path14.join(blockDir, "src")) ? path14.join(blockDir, "src") : blockDir;
+async function readRemoteBlockJsonAsync(blockDir) {
+  const sourceRoot = await getSeedSourceRoot(blockDir);
   for (const candidate of [
     path14.join(blockDir, "block.json"),
     path14.join(sourceRoot, "block.json")
   ]) {
-    if (fs10.existsSync(candidate)) {
-      return JSON.parse(fs10.readFileSync(candidate, "utf8"));
+    if (await pathExists(candidate)) {
+      return JSON.parse(await fsp10.readFile(candidate, "utf8"));
     }
   }
   throw new Error(`Unable to locate block.json in ${blockDir}`);
 }
-function getDefaultCategory(sourceDir) {
+async function getDefaultCategoryAsync(sourceDir) {
   try {
-    const blockJson = readRemoteBlockJson(sourceDir);
+    const blockJson = await readRemoteBlockJsonAsync(sourceDir);
     return getDefaultCategoryFromBlockJson(blockJson);
   } catch {
     return "widgets";
   }
 }
-function readTemplatePackageJson(sourceDir) {
+async function readTemplatePackageJsonAsync(sourceDir) {
   for (const candidate of [
     path14.join(sourceDir, "package.json.mustache"),
     path14.join(sourceDir, "package.json")
   ]) {
-    if (!fs10.existsSync(candidate)) {
+    if (!await pathExists(candidate)) {
       continue;
     }
     try {
@@ -7637,7 +7667,7 @@ function readTemplatePackageJson(sourceDir) {
         maxBytes: getExternalTemplatePackageJsonMaxBytes()
       });
       return {
-        packageJson: JSON.parse(fs10.readFileSync(candidate, "utf8")),
+        packageJson: JSON.parse(await fsp10.readFile(candidate, "utf8")),
         sourcePath: candidate
       };
     } catch (error) {
@@ -7647,8 +7677,8 @@ function readTemplatePackageJson(sourceDir) {
   }
   return null;
 }
-function getTemplateProjectType(sourceDir) {
-  const packageJsonEntry = readTemplatePackageJson(sourceDir);
+async function getTemplateProjectTypeAsync(sourceDir) {
+  const packageJsonEntry = await readTemplatePackageJsonAsync(sourceDir);
   if (!packageJsonEntry) {
     return null;
   }
@@ -7668,11 +7698,11 @@ async function normalizeWpTypiaTemplateSeed(seed) {
     await copyRawDirectory(seed.blockDir, normalizedDir, {
       filter: (sourcePath, _targetPath, entry) => {
         const mustacheVariantPath = path14.join(path14.dirname(sourcePath), `${entry.name}.mustache`);
-        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs10.existsSync(mustacheVariantPath));
+        return !(entry.isFile() && (entry.name === "package.json" || entry.name === "README.md") && fs8.existsSync(mustacheVariantPath));
       }
     });
-    if (seed.assetsDir && fs10.existsSync(seed.assetsDir)) {
-      await fsp8.cp(seed.assetsDir, path14.join(normalizedDir, "assets"), {
+    if (seed.assetsDir && await pathExists(seed.assetsDir)) {
+      await fsp10.cp(seed.assetsDir, path14.join(normalizedDir, "assets"), {
         recursive: true,
         force: true
       });
@@ -7763,9 +7793,9 @@ async function rewriteBlockJsonImports(directory) {
   const textExtensions = new Set([".js", ".jsx", ".ts", ".tsx"]);
   const targetBlockJsonPath = path14.join(directory, "block.json");
   async function visit(currentPath) {
-    const stats = await fsp8.stat(currentPath);
+    const stats = await fsp10.stat(currentPath);
     if (stats.isDirectory()) {
-      const entries = await fsp8.readdir(currentPath);
+      const entries = await fsp10.readdir(currentPath);
       for (const entry of entries) {
         await visit(path14.join(currentPath, entry));
       }
@@ -7774,19 +7804,19 @@ async function rewriteBlockJsonImports(directory) {
     if (!textExtensions.has(path14.extname(currentPath))) {
       return;
     }
-    const content = await fsp8.readFile(currentPath, "utf8");
+    const content = await fsp10.readFile(currentPath, "utf8");
     const relativeSpecifier = path14.relative(path14.dirname(currentPath), targetBlockJsonPath).replace(/\\/g, "/");
     const normalizedSpecifier = relativeSpecifier.startsWith(".") ? relativeSpecifier : `./${relativeSpecifier}`;
     const next = content.replace(/(['"])\.{1,2}\/[^'"]*block\.json\1/g, `$1${normalizedSpecifier}$1`);
     if (next !== content) {
-      await fsp8.writeFile(currentPath, next, "utf8");
+      await fsp10.writeFile(currentPath, next, "utf8");
     }
   }
   await visit(directory);
 }
 async function patchRemotePackageJson(templateDir, needsInteractivity) {
   const packageJsonPath = path14.join(templateDir, "package.json.mustache");
-  const packageJson = JSON.parse(await fsp8.readFile(packageJsonPath, "utf8"));
+  const packageJson = JSON.parse(await fsp10.readFile(packageJsonPath, "utf8"));
   const existingDependencies = { ...packageJson.dependencies ?? {} };
   const existingDevDependencies = { ...packageJson.devDependencies ?? {} };
   delete existingDependencies["@wp-typia/project-tools"];
@@ -7806,18 +7836,18 @@ async function patchRemotePackageJson(templateDir, needsInteractivity) {
   } else {
     delete packageJson.dependencies;
   }
-  await fsp8.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  await fsp10.writeFile(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `, "utf8");
 }
-function getSeedSourceRoot(blockDir) {
-  return fs10.existsSync(path14.join(blockDir, "src")) ? path14.join(blockDir, "src") : blockDir;
+async function getSeedSourceRoot(blockDir) {
+  return await pathExists(path14.join(blockDir, "src")) ? path14.join(blockDir, "src") : blockDir;
 }
-function findSeedRenderPhp(seed) {
+async function findSeedRenderPhp(seed) {
   for (const candidate of [
     path14.join(seed.blockDir, "render.php"),
     path14.join(seed.rootDir, "render.php")
   ]) {
-    if (fs10.existsSync(candidate)) {
+    if (await pathExists(candidate)) {
       return candidate;
     }
   }
@@ -7856,47 +7886,54 @@ async function removeSeedEntryConflicts(templateDir) {
     "view.ts",
     "view.tsx"
   ]) {
-    await fsp8.rm(path14.join(templateDir, "src", filename), { force: true });
+    await fsp10.rm(path14.join(templateDir, "src", filename), { force: true });
   }
 }
 async function normalizeCreateBlockSubset(seed, context) {
   const { path: tempRoot, cleanup } = await createManagedTempRoot("wp-typia-remote-template-");
   try {
     const templateDir = path14.join(tempRoot, "template");
-    const blockJson = readRemoteBlockJson(seed.blockDir);
-    const sourceRoot = getSeedSourceRoot(seed.blockDir);
-    await fsp8.mkdir(templateDir, { recursive: true });
+    const blockJson = await readRemoteBlockJsonAsync(seed.blockDir);
+    const sourceRoot = await getSeedSourceRoot(seed.blockDir);
+    await fsp10.mkdir(templateDir, { recursive: true });
     for (const layerDir of getBuiltInTemplateLayerDirs("basic")) {
-      if (!fs10.existsSync(layerDir)) {
+      if (!await pathExists(layerDir)) {
         if (isOmittableBuiltInTemplateLayerDir("basic", layerDir)) {
           continue;
         }
         throw new Error(`Built-in template layer is missing: ${layerDir}`);
       }
-      await fsp8.cp(layerDir, templateDir, {
+      await fsp10.cp(layerDir, templateDir, {
         recursive: true,
         force: true
       });
     }
     await removeSeedEntryConflicts(templateDir);
-    await fsp8.cp(sourceRoot, path14.join(templateDir, "src"), {
+    await fsp10.cp(sourceRoot, path14.join(templateDir, "src"), {
       recursive: true,
       force: true
     });
-    const remoteRenderPath = findSeedRenderPhp(seed);
+    const remoteRenderPath = await findSeedRenderPhp(seed);
     if (remoteRenderPath) {
-      await fsp8.copyFile(remoteRenderPath, path14.join(templateDir, "render.php"));
+      await fsp10.copyFile(remoteRenderPath, path14.join(templateDir, "render.php"));
     }
-    if (seed.assetsDir && fs10.existsSync(seed.assetsDir)) {
-      await fsp8.cp(seed.assetsDir, path14.join(templateDir, "assets"), {
+    if (seed.assetsDir && await pathExists(seed.assetsDir)) {
+      await fsp10.cp(seed.assetsDir, path14.join(templateDir, "assets"), {
         recursive: true,
         force: true
       });
     }
-    await fsp8.writeFile(path14.join(templateDir, "src", "types.ts"), buildRemoteTypesSource(blockJson, context), "utf8");
-    await fsp8.writeFile(path14.join(templateDir, "src", "block.json"), buildRemoteBlockJsonTemplate(blockJson), "utf8");
+    await fsp10.writeFile(path14.join(templateDir, "src", "types.ts"), buildRemoteTypesSource(blockJson, context), "utf8");
+    await fsp10.writeFile(path14.join(templateDir, "src", "block.json"), buildRemoteBlockJsonTemplate(blockJson), "utf8");
     await rewriteBlockJsonImports(path14.join(templateDir, "src"));
-    const needsInteractivity = typeof blockJson.viewScriptModule === "string" || typeof blockJson.viewScript === "string" || fs10.existsSync(path14.join(templateDir, "src", "view.js")) || fs10.existsSync(path14.join(templateDir, "src", "view.ts")) || fs10.existsSync(path14.join(templateDir, "src", "view.tsx")) || fs10.existsSync(path14.join(templateDir, "src", "interactivity.js")) || fs10.existsSync(path14.join(templateDir, "src", "interactivity.ts"));
+    const needsInteractivity = typeof blockJson.viewScriptModule === "string" || typeof blockJson.viewScript === "string" || (await Promise.all([
+      "view.js",
+      "view.jsx",
+      "view.ts",
+      "view.tsx",
+      "interactivity.js",
+      "interactivity.ts"
+    ].map((filename) => pathExists(path14.join(templateDir, "src", filename))))).some(Boolean);
     await patchRemotePackageJson(templateDir, needsInteractivity);
     return {
       id: "remote:create-block-subset",
@@ -7946,27 +7983,27 @@ function getTemplateVariableContext(variables) {
   };
 }
 async function detectTemplateSourceFormat(sourceDir) {
-  if (fs11.existsSync(path15.join(sourceDir, "package.json.mustache"))) {
+  if (await pathExists(path15.join(sourceDir, "package.json.mustache"))) {
     return "wp-typia";
   }
   if (await loadExternalTemplateLayerManifest(sourceDir)) {
     throw new Error(`Template source at ${sourceDir} is an external layer package. External layers currently compose only through built-in scaffolds via the runtime API, not as standalone template ids.`);
   }
-  if (getExternalTemplateEntry(sourceDir)) {
+  if (await findExternalTemplateEntry(sourceDir)) {
     return "create-block-external";
   }
-  if (getTemplateProjectType(sourceDir) !== null) {
+  if (await getTemplateProjectTypeAsync(sourceDir) !== null) {
     return "wp-typia";
   }
-  const sourceRoot = fs11.existsSync(path15.join(sourceDir, "src")) ? path15.join(sourceDir, "src") : sourceDir;
+  const sourceRoot = await pathExists(path15.join(sourceDir, "src")) ? path15.join(sourceDir, "src") : sourceDir;
   const blockJsonCandidates = [
     path15.join(sourceDir, "block.json"),
     path15.join(sourceRoot, "block.json")
   ];
-  const hasBlockJson = blockJsonCandidates.some((candidate) => fs11.existsSync(candidate));
-  const hasIndexFile = ["index.js", "index.jsx", "index.ts", "index.tsx"].some((filename) => fs11.existsSync(path15.join(sourceRoot, filename)));
-  const hasEditFile = ["edit.js", "edit.jsx", "edit.ts", "edit.tsx"].some((filename) => fs11.existsSync(path15.join(sourceRoot, filename)));
-  const hasSaveFile = ["save.js", "save.jsx", "save.ts", "save.tsx"].some((filename) => fs11.existsSync(path15.join(sourceRoot, filename)));
+  const hasBlockJson = (await Promise.all(blockJsonCandidates.map((candidate) => pathExists(candidate)))).some(Boolean);
+  const hasIndexFile = (await Promise.all(["index.js", "index.jsx", "index.ts", "index.tsx"].map((filename) => pathExists(path15.join(sourceRoot, filename))))).some(Boolean);
+  const hasEditFile = (await Promise.all(["edit.js", "edit.jsx", "edit.ts", "edit.tsx"].map((filename) => pathExists(path15.join(sourceRoot, filename))))).some(Boolean);
+  const hasSaveFile = (await Promise.all(["save.js", "save.jsx", "save.ts", "save.tsx"].map((filename) => pathExists(path15.join(sourceRoot, filename))))).some(Boolean);
   if (hasBlockJson && hasIndexFile && hasEditFile && hasSaveFile) {
     return "create-block-subset";
   }
@@ -7975,8 +8012,8 @@ async function detectTemplateSourceFormat(sourceDir) {
 
 // ../wp-typia-project-tools/src/runtime/template-source-seeds.ts
 var import_semver = __toESM(require_semver2(), 1);
-import fs14 from "fs";
-import { promises as fsp10 } from "fs";
+import fs11 from "fs";
+import { promises as fsp12 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import path17 from "path";
 import { spawnSync } from "child_process";
@@ -10251,7 +10288,7 @@ var Vn = 512 * 1024;
 var $n = pr | ur | dr | mr;
 var lr = !fr && typeof ar == "number" ? ar | ur | dr | mr : null;
 var cs = lr !== null ? () => lr : Kn ? (s3) => s3 < Vn ? $n : "w" : () => "w";
-var fs12 = (s3, t, e) => {
+var fs9 = (s3, t, e) => {
   try {
     return mi.lchownSync(s3, t, e);
   } catch (i) {
@@ -10300,7 +10337,7 @@ var ds = (s3, t, e, i) => {
   });
 };
 var qn = (s3, t, e, i) => {
-  t.isDirectory() && us(Ee.resolve(s3, t.name), e, i), fs12(Ee.resolve(s3, t.name), e, i);
+  t.isDirectory() && us(Ee.resolve(s3, t.name), e, i), fs9(Ee.resolve(s3, t.name), e, i);
 };
 var us = (s3, t, e) => {
   let i;
@@ -10311,12 +10348,12 @@ var us = (s3, t, e) => {
     if (n?.code === "ENOENT")
       return;
     if (n?.code === "ENOTDIR" || n?.code === "ENOTSUP")
-      return fs12(s3, t, e);
+      return fs9(s3, t, e);
     throw n;
   }
   for (let r of i)
     qn(s3, r, t, e);
-  return fs12(s3, t, e);
+  return fs9(s3, t, e);
 };
 var we = class extends Error {
   path;
@@ -11130,15 +11167,18 @@ var So = (s3) => {
 
 // ../wp-typia-project-tools/src/runtime/template-source-cache.ts
 import { createHash } from "crypto";
-import fs13 from "fs";
-import { promises as fsp9 } from "fs";
+import fs10 from "fs";
+import { promises as fsp11 } from "fs";
 import os2 from "os";
 import path16 from "path";
 var EXTERNAL_TEMPLATE_CACHE_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE";
 var EXTERNAL_TEMPLATE_CACHE_DIR_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_DIR";
 var EXTERNAL_TEMPLATE_CACHE_TTL_DAYS_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_TTL_DAYS";
+var EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV = "WP_TYPIA_EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS";
 var CACHE_MARKER_FILE = "wp-typia-template-cache.json";
+var CACHE_PRUNE_MARKER_FILE = "wp-typia-template-cache-prune.json";
 var MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+var DEFAULT_CACHE_PRUNE_INTERVAL_MS = 60 * 60 * 1000;
 var PRIVATE_CACHE_DIRECTORY_MODE = 448;
 var REDACTED_CACHE_METADATA_VALUE = "[redacted]";
 var DISABLED_CACHE_VALUES = new Set(["0", "false", "no", "off"]);
@@ -11186,12 +11226,33 @@ function resolveExternalTemplateCacheTtlMs(options = {}) {
   const ttlMs = ttlDays * MILLISECONDS_PER_DAY;
   return Number.isFinite(ttlMs) ? ttlMs : null;
 }
+function parseExternalTemplateCachePruneIntervalMs(value) {
+  if (typeof value !== "string" && typeof value !== "number") {
+    return null;
+  }
+  const intervalMs = typeof value === "number" ? value : Number(value.trim());
+  if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+    return null;
+  }
+  return intervalMs;
+}
+function resolveExternalTemplateCachePruneIntervalMs(options = {}) {
+  if (options.pruneIntervalMs !== undefined) {
+    return parseExternalTemplateCachePruneIntervalMs(options.pruneIntervalMs);
+  }
+  const env = options.env ?? process.env;
+  const envValue = env[EXTERNAL_TEMPLATE_CACHE_PRUNE_INTERVAL_MS_ENV];
+  if (envValue === undefined) {
+    return DEFAULT_CACHE_PRUNE_INTERVAL_MS;
+  }
+  return parseExternalTemplateCachePruneIntervalMs(envValue);
+}
 function createExternalTemplateCacheKey(keyParts) {
   return createHash("sha256").update(JSON.stringify(keyParts)).digest("hex");
 }
-async function pathExists(filePath) {
+async function pathExists2(filePath) {
   try {
-    await fsp9.access(filePath, fs13.constants.F_OK);
+    await fsp11.access(filePath, fs10.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -11199,18 +11260,18 @@ async function pathExists(filePath) {
 }
 async function isDirectoryPath(directory) {
   try {
-    const stats = await fsp9.lstat(directory);
+    const stats = await fsp11.lstat(directory);
     return stats.isDirectory() && !stats.isSymbolicLink();
   } catch {
     return false;
   }
 }
-function getNodeErrorCode(error) {
+function getNodeErrorCode2(error) {
   return typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
 }
 async function removeTemporaryCacheEntry(entryDir) {
   try {
-    await fsp9.rm(entryDir, { force: true, recursive: true });
+    await fsp11.rm(entryDir, { force: true, recursive: true });
   } catch {}
 }
 function getCurrentUserCacheSegment() {
@@ -11229,7 +11290,7 @@ function getCurrentUid() {
 }
 async function isPrivateCacheDirectory(directory) {
   try {
-    const stats = await fsp9.lstat(directory);
+    const stats = await fsp11.lstat(directory);
     if (!stats.isDirectory() || stats.isSymbolicLink()) {
       return false;
     }
@@ -11247,11 +11308,11 @@ async function isPrivateCacheDirectory(directory) {
 }
 async function ensurePrivateCacheDirectory(directory) {
   try {
-    await fsp9.mkdir(directory, {
+    await fsp11.mkdir(directory, {
       mode: PRIVATE_CACHE_DIRECTORY_MODE,
       recursive: true
     });
-    const stats = await fsp9.lstat(directory);
+    const stats = await fsp11.lstat(directory);
     if (!stats.isDirectory() || stats.isSymbolicLink()) {
       return false;
     }
@@ -11261,7 +11322,7 @@ async function ensurePrivateCacheDirectory(directory) {
     }
     if (process.platform !== "win32") {
       if ((stats.mode & 63) !== 0) {
-        await fsp9.chmod(directory, PRIVATE_CACHE_DIRECTORY_MODE);
+        await fsp11.chmod(directory, PRIVATE_CACHE_DIRECTORY_MODE);
       }
     }
     return isPrivateCacheDirectory(directory);
@@ -11319,7 +11380,7 @@ function getCacheEntryPaths(descriptor) {
   };
 }
 async function isReusableCacheEntry(entryDir, markerPath, sourceDir) {
-  return await isPrivateCacheDirectory(entryDir) && await pathExists(markerPath) && await isDirectoryPath(sourceDir);
+  return await isPrivateCacheDirectory(entryDir) && await pathExists2(markerPath) && await isDirectoryPath(sourceDir);
 }
 function parseCacheMarkerMetadata(markerText) {
   let marker;
@@ -11349,6 +11410,13 @@ function parseCacheMarkerMetadata(markerText) {
     metadata
   };
 }
+async function readCacheEntryMarker(markerPath) {
+  try {
+    return parseCacheMarkerMetadata(await fsp11.readFile(markerPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
 function cacheMetadataMatches(actual, expected) {
   return Object.entries(expected).every(([key, value]) => actual[key] === value);
 }
@@ -11356,6 +11424,19 @@ function getExternalTemplateCacheNowMs(now) {
   const nowMs = now instanceof Date ? now.getTime() : typeof now === "number" ? now : Date.now();
   return Number.isFinite(nowMs) ? nowMs : Date.now();
 }
+function isCacheEntryFreshForTtl(createdAtMs, nowMs, ttlMs) {
+  return ttlMs === null || createdAtMs >= nowMs - ttlMs;
+}
+async function getReusableCacheEntryMarker(entryDir, markerPath, sourceDir) {
+  if (!await isReusableCacheEntry(entryDir, markerPath, sourceDir)) {
+    return null;
+  }
+  return readCacheEntryMarker(markerPath);
+}
+async function isReusableFreshCacheEntry(entryDir, markerPath, sourceDir, nowMs, ttlMs) {
+  const marker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
+  return marker !== null && isCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs);
+}
 function isPathInsideDirectory(directory, candidatePath) {
   const relativePath = path16.relative(directory, candidatePath);
   return relativePath.length > 0 && !relativePath.startsWith("..") && !path16.isAbsolute(relativePath);
@@ -11365,12 +11446,82 @@ async function removeCacheEntryWithinRoot(cacheRoot, entryDir) {
     return false;
   }
   try {
-    await fsp9.rm(entryDir, { force: true, recursive: true });
+    await fsp11.rm(entryDir, { force: true, recursive: true });
     return true;
   } catch {
     return false;
   }
 }
+function getCachePruneMarkerPath(cacheRoot) {
+  return path16.join(cacheRoot, CACHE_PRUNE_MARKER_FILE);
+}
+function parseCachePruneMarker(markerText) {
+  let marker;
+  try {
+    marker = JSON.parse(markerText);
+  } catch {
+    return null;
+  }
+  if (typeof marker !== "object" || marker === null || Array.isArray(marker)) {
+    return null;
+  }
+  const rawPrunedAt = marker.prunedAt;
+  const prunedAtMs = typeof rawPrunedAt === "string" ? Date.parse(rawPrunedAt) : Number.NaN;
+  const rawPruneIntervalMs = marker.pruneIntervalMs;
+  const rawTtlMs = marker.ttlMs;
+  if (typeof rawTtlMs !== "number" || !Number.isFinite(rawTtlMs)) {
+    return null;
+  }
+  if (!Number.isFinite(prunedAtMs)) {
+    return null;
+  }
+  if (rawPruneIntervalMs !== null && (typeof rawPruneIntervalMs !== "number" || !Number.isFinite(rawPruneIntervalMs))) {
+    return null;
+  }
+  return {
+    prunedAtMs,
+    pruneIntervalMs: rawPruneIntervalMs ?? null,
+    ttlMs: rawTtlMs
+  };
+}
+async function shouldSkipExternalTemplateCachePrune({
+  cacheRoot,
+  force,
+  nowMs,
+  pruneIntervalMs,
+  ttlMs
+}) {
+  if (force || pruneIntervalMs === null) {
+    return false;
+  }
+  let markerText;
+  try {
+    markerText = await fsp11.readFile(getCachePruneMarkerPath(cacheRoot), "utf8");
+  } catch {
+    return false;
+  }
+  const marker = parseCachePruneMarker(markerText);
+  if (!marker || marker.ttlMs !== ttlMs || marker.pruneIntervalMs !== pruneIntervalMs) {
+    return false;
+  }
+  const elapsedMs = nowMs - marker.prunedAtMs;
+  return elapsedMs >= 0 && elapsedMs < pruneIntervalMs;
+}
+async function writeExternalTemplateCachePruneMarker({
+  cacheRoot,
+  nowMs,
+  pruneIntervalMs,
+  ttlMs
+}) {
+  try {
+    await fsp11.writeFile(getCachePruneMarkerPath(cacheRoot), `${JSON.stringify({
+      prunedAt: new Date(nowMs).toISOString(),
+      pruneIntervalMs,
+      ttlMs
+    }, null, 2)}
+`, "utf8");
+  } catch {}
+}
 async function pruneExternalTemplateCache(options = {}) {
   const env = options.env ?? process.env;
   const cacheRoot = getExternalTemplateCacheRoot(env);
@@ -11378,23 +11529,39 @@ async function pruneExternalTemplateCache(options = {}) {
     env,
     ttlDays: options.ttlDays
   });
+  const pruneIntervalMs = resolveExternalTemplateCachePruneIntervalMs({
+    env,
+    pruneIntervalMs: options.pruneIntervalMs
+  });
   const result = {
     cacheRoot,
     prunedEntries: 0,
     scannedEntries: 0,
     skippedEntries: 0,
+    skippedByThrottle: false,
     ttlMs
   };
   if (ttlMs === null || !await isPrivateCacheDirectory(cacheRoot)) {
     return result;
   }
+  const nowMs = getExternalTemplateCacheNowMs(options.now);
+  if (await shouldSkipExternalTemplateCachePrune({
+    cacheRoot,
+    force: options.force,
+    nowMs,
+    pruneIntervalMs,
+    ttlMs
+  })) {
+    result.skippedByThrottle = true;
+    return result;
+  }
   let namespaceEntries;
   try {
-    namespaceEntries = await fsp9.readdir(cacheRoot, { withFileTypes: true });
+    namespaceEntries = await fsp11.readdir(cacheRoot, { withFileTypes: true });
   } catch {
     return result;
   }
-  const expiresBeforeMs = getExternalTemplateCacheNowMs(options.now) - ttlMs;
+  const expiresBeforeMs = nowMs - ttlMs;
   for (const namespaceEntry of namespaceEntries) {
     if (!namespaceEntry.isDirectory()) {
       continue;
@@ -11406,7 +11573,7 @@ async function pruneExternalTemplateCache(options = {}) {
     }
     let cacheEntries;
     try {
-      cacheEntries = await fsp9.readdir(namespaceDir, { withFileTypes: true });
+      cacheEntries = await fsp11.readdir(namespaceDir, { withFileTypes: true });
     } catch {
       result.skippedEntries += 1;
       continue;
@@ -11427,18 +11594,7 @@ async function pruneExternalTemplateCache(options = {}) {
       }
       const markerPath = path16.join(entryDir, CACHE_MARKER_FILE);
       const sourceDir = path16.join(entryDir, "source");
-      if (!await isReusableCacheEntry(entryDir, markerPath, sourceDir)) {
-        result.skippedEntries += 1;
-        continue;
-      }
-      let markerText;
-      try {
-        markerText = await fsp9.readFile(markerPath, "utf8");
-      } catch {
-        result.skippedEntries += 1;
-        continue;
-      }
-      const marker = parseCacheMarkerMetadata(markerText);
+      const marker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
       if (!marker) {
         result.skippedEntries += 1;
         continue;
@@ -11452,6 +11608,12 @@ async function pruneExternalTemplateCache(options = {}) {
       }
     }
   }
+  await writeExternalTemplateCachePruneMarker({
+    cacheRoot,
+    nowMs,
+    pruneIntervalMs,
+    ttlMs
+  });
   return result;
 }
 async function findReusableExternalTemplateSourceCache(descriptor) {
@@ -11466,10 +11628,12 @@ async function findReusableExternalTemplateSourceCache(descriptor) {
   if (!await isPrivateCacheDirectory(cacheRoot) || !await isPrivateCacheDirectory(namespaceDir)) {
     return null;
   }
+  const ttlMs = resolveExternalTemplateCacheTtlMs();
+  const nowMs = getExternalTemplateCacheNowMs(undefined);
   await pruneExternalTemplateCache();
   let entries;
   try {
-    entries = await fsp9.readdir(namespaceDir, { withFileTypes: true });
+    entries = await fsp11.readdir(namespaceDir, { withFileTypes: true });
   } catch {
     return null;
   }
@@ -11481,17 +11645,8 @@ async function findReusableExternalTemplateSourceCache(descriptor) {
     const entryDir = path16.join(namespaceDir, entry.name);
     const markerPath = path16.join(entryDir, CACHE_MARKER_FILE);
     const sourceDir = path16.join(entryDir, "source");
-    if (!await isReusableCacheEntry(entryDir, markerPath, sourceDir)) {
-      continue;
-    }
-    let markerText;
-    try {
-      markerText = await fsp9.readFile(markerPath, "utf8");
-    } catch {
-      continue;
-    }
-    const marker = parseCacheMarkerMetadata(markerText);
-    if (!marker || !cacheMetadataMatches(marker.metadata, descriptor.metadata)) {
+    const marker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
+    if (!marker || !isCacheEntryFreshForTtl(marker.createdAtMs, nowMs, ttlMs) || !cacheMetadataMatches(marker.metadata, descriptor.metadata)) {
       continue;
     }
     if (!bestEntry || marker.createdAtMs > bestEntry.createdAtMs) {
@@ -11518,23 +11673,29 @@ async function resolveExternalTemplateSourceCache(descriptor, populateSourceDir)
   if (!await ensurePrivateCacheDirectory(cacheRoot) || !await ensurePrivateCacheDirectory(namespaceDir)) {
     return null;
   }
+  const ttlMs = resolveExternalTemplateCacheTtlMs();
+  const nowMs = getExternalTemplateCacheNowMs(undefined);
   await pruneExternalTemplateCache();
-  if (await isReusableCacheEntry(entryDir, markerPath, sourceDir)) {
+  const existingMarker = await getReusableCacheEntryMarker(entryDir, markerPath, sourceDir);
+  if (existingMarker && isCacheEntryFreshForTtl(existingMarker.createdAtMs, nowMs, ttlMs)) {
     return {
       cacheHit: true,
       sourceDir
     };
   }
+  if (existingMarker) {
+    await removeCacheEntryWithinRoot(cacheRoot, entryDir);
+  }
   const temporaryEntryDir = path16.join(namespaceDir, `.tmp-${cacheKey}-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
   const temporarySourceDir = path16.join(temporaryEntryDir, "source");
   let populateFailed = false;
   try {
-    await fsp9.mkdir(temporarySourceDir, {
+    await fsp11.mkdir(temporarySourceDir, {
       mode: PRIVATE_CACHE_DIRECTORY_MODE,
       recursive: true
     });
     if (process.platform !== "win32") {
-      await fsp9.chmod(temporaryEntryDir, PRIVATE_CACHE_DIRECTORY_MODE);
+      await fsp11.chmod(temporaryEntryDir, PRIVATE_CACHE_DIRECTORY_MODE);
     }
     try {
       await populateSourceDir(temporarySourceDir);
@@ -11542,14 +11703,14 @@ async function resolveExternalTemplateSourceCache(descriptor, populateSourceDir)
       populateFailed = true;
       throw error;
     }
-    await fsp9.writeFile(path16.join(temporaryEntryDir, CACHE_MARKER_FILE), `${JSON.stringify({
+    await fsp11.writeFile(path16.join(temporaryEntryDir, CACHE_MARKER_FILE), `${JSON.stringify({
       createdAt: new Date().toISOString(),
       key: cacheKey,
       metadata: sanitizeCacheMetadata(descriptor.metadata),
       namespace: descriptor.namespace
     }, null, 2)}
 `, "utf8");
-    await fsp9.rename(temporaryEntryDir, entryDir);
+    await fsp11.rename(temporaryEntryDir, entryDir);
     return {
       cacheHit: false,
       sourceDir
@@ -11557,13 +11718,13 @@ async function resolveExternalTemplateSourceCache(descriptor, populateSourceDir)
   } catch (error) {
     await removeTemporaryCacheEntry(temporaryEntryDir);
     if (populateFailed) {
-      if (CACHE_UNAVAILABLE_ERROR_CODES.has(getNodeErrorCode(error))) {
+      if (CACHE_UNAVAILABLE_ERROR_CODES.has(getNodeErrorCode2(error))) {
         return null;
       }
       throw error;
     }
-    const errorCode = getNodeErrorCode(error);
-    if (CACHE_PUBLISH_RACE_ERROR_CODES.has(errorCode) && await isReusableCacheEntry(entryDir, markerPath, sourceDir)) {
+    const errorCode = getNodeErrorCode2(error);
+    if (CACHE_PUBLISH_RACE_ERROR_CODES.has(errorCode) && await isReusableFreshCacheEntry(entryDir, markerPath, sourceDir, nowMs, ttlMs)) {
       return {
         cacheHit: true,
         sourceDir
@@ -11621,8 +11782,8 @@ async function downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl,
     throw new Error(`Failed to download npm template tarball for ${locator.raw}: ${tarballResponse.status}`);
   }
   const tarballPath = path17.join(path17.dirname(unpackDir), "template.tgz");
-  await fsp10.mkdir(unpackDir, { recursive: true });
-  await fsp10.writeFile(tarballPath, await readBufferResponseWithLimit(tarballResponse, {
+  await fsp12.mkdir(unpackDir, { recursive: true });
+  await fsp12.writeFile(tarballPath, await readBufferResponseWithLimit(tarballResponse, {
     label: `npm template tarball for ${locator.raw}@${resolvedVersion}`,
     maxBytes: getExternalTemplateTarballMaxBytes()
   }));
@@ -11631,7 +11792,7 @@ async function downloadNpmTemplateTarball(locator, resolvedVersion, tarballUrl,
     file: tarballPath,
     strip: 1
   });
-  await fsp10.rm(tarballPath, { force: true });
+  await fsp12.rm(tarballPath, { force: true });
   await assertNoSymlinks2(unpackDir);
 }
 function selectRegistryVersion(metadata, locator) {
@@ -11743,8 +11904,8 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
     return null;
   }
   const workspacePackagesRoot = path17.resolve(PROJECT_TOOLS_PACKAGE_ROOT, "..");
-  if (fs14.existsSync(workspacePackagesRoot)) {
-    for (const entry of fs14.readdirSync(workspacePackagesRoot, {
+  if (fs11.existsSync(workspacePackagesRoot)) {
+    for (const entry of fs11.readdirSync(workspacePackagesRoot, {
       withFileTypes: true
     })) {
       if (!entry.isDirectory()) {
@@ -11752,10 +11913,10 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
       }
       const packageDir = path17.join(workspacePackagesRoot, entry.name);
       const packageJsonPath = path17.join(packageDir, "package.json");
-      if (!fs14.existsSync(packageJsonPath)) {
+      if (!fs11.existsSync(packageJsonPath)) {
         continue;
       }
-      const manifest = JSON.parse(fs14.readFileSync(packageJsonPath, "utf8"));
+      const manifest = JSON.parse(fs11.readFileSync(packageJsonPath, "utf8"));
       if (manifest.name === locator.name) {
         return {
           blockDir: packageDir,
@@ -11766,7 +11927,7 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
   }
   const workspaceRequire = createRequire2(path17.join(path17.resolve(cwd), "__wp_typia_template_resolver__.cjs"));
   try {
-    const packageJsonPath = fs14.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
+    const packageJsonPath = fs11.realpathSync(workspaceRequire.resolve(`${locator.name}/package.json`));
     const sourceDir = path17.dirname(packageJsonPath);
     return {
       blockDir: sourceDir,
@@ -11777,10 +11938,10 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
     if (errorCode === "MODULE_NOT_FOUND" || errorCode === "ERR_PACKAGE_PATH_NOT_EXPORTED") {
       for (const basePath of workspaceRequire.resolve.paths(locator.name) ?? []) {
         const packageJsonPath = path17.join(basePath, locator.name, "package.json");
-        if (!fs14.existsSync(packageJsonPath)) {
+        if (!fs11.existsSync(packageJsonPath)) {
           continue;
         }
-        const sourceDir = path17.dirname(fs14.realpathSync(packageJsonPath));
+        const sourceDir = path17.dirname(fs11.realpathSync(packageJsonPath));
         return {
           blockDir: sourceDir,
           rootDir: sourceDir
@@ -11793,25 +11954,25 @@ function resolveInstalledNpmTemplateSource(locator, cwd) {
 }
 function isOfficialWorkspaceTemplateSeed(seed) {
   const packageJsonPath = path17.join(seed.rootDir, "package.json");
-  if (!fs14.existsSync(packageJsonPath)) {
+  if (!fs11.existsSync(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson = JSON.parse(fs14.readFileSync(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(fs11.readFileSync(packageJsonPath, "utf8"));
     return packageJson.name === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE;
   } catch {
     return false;
   }
 }
 async function assertNoSymlinks2(sourceDir) {
-  const stats = await fsp10.lstat(sourceDir);
+  const stats = await fsp12.lstat(sourceDir);
   if (stats.isSymbolicLink()) {
     throw new Error(`Template sources may not include symbolic links: ${sourceDir}`);
   }
   if (!stats.isDirectory()) {
     return;
   }
-  for (const entry of await fsp10.readdir(sourceDir)) {
+  for (const entry of await fsp12.readdir(sourceDir)) {
     await assertNoSymlinks2(path17.join(sourceDir, entry));
   }
 }
@@ -11846,7 +12007,7 @@ function resolveGitHubTemplateDirectory(checkoutDir, locator) {
   if (relativeSourceDir.startsWith("..") || path17.isAbsolute(relativeSourceDir)) {
     throw new Error("GitHub template path must stay within the cloned repository.");
   }
-  if (!fs14.existsSync(sourceDir)) {
+  if (!fs11.existsSync(sourceDir)) {
     throw new Error(`GitHub template path does not exist: ${locator.sourcePath}`);
   }
   return sourceDir;
@@ -12050,7 +12211,7 @@ async function resolveGitHubTemplateSource(locator) {
 async function resolveTemplateSeed(locator, cwd) {
   if (locator.kind === "path") {
     const sourceDir = path17.resolve(cwd, locator.templatePath);
-    if (!fs14.existsSync(sourceDir)) {
+    if (!fs11.existsSync(sourceDir)) {
       throw new Error(`Template path does not exist: ${sourceDir}`);
     }
     await assertNoSymlinks2(sourceDir);
@@ -12095,10 +12256,10 @@ async function resolveTemplateSource(templateId, cwd, variables, variant) {
         throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
       }
       normalizedSeed = await normalizeWpTypiaTemplateSeed(seed);
-      const supportsMigrationUi = getTemplateProjectType(seed.blockDir) === "workspace";
+      const supportsMigrationUi = await getTemplateProjectTypeAsync(seed.blockDir) === "workspace";
       return {
         id: templateId,
-        defaultCategory: getDefaultCategory(seed.blockDir),
+        defaultCategory: await getDefaultCategoryAsync(seed.blockDir),
         description: "A remote wp-typia template source",
         features: ["Remote source", "wp-typia format"],
         format,
@@ -12115,28 +12276,37 @@ async function resolveTemplateSource(templateId, cwd, variables, variant) {
       const renderedFormat = normalizedSeed.formatHint ?? await detectTemplateSourceFormat(normalizedSeed.blockDir);
       if (renderedFormat === "wp-typia") {
         const normalized3 = await normalizeWpTypiaTemplateSeed(normalizedSeed);
-        const supportsMigrationUi = getTemplateProjectType(normalizedSeed.blockDir) === "workspace";
-        return {
-          cleanup: async () => {
-            await normalized3.cleanup?.();
-            await seed.cleanup?.();
-          },
-          defaultCategory: getDefaultCategory(normalizedSeed.blockDir),
-          description: "A wp-typia scaffold normalized from an official external template config",
-          features: [
-            "Remote source",
-            "official external template",
-            "wp-typia format",
-            ...supportsMigrationUi ? ["workspace-capable scaffold"] : []
-          ],
-          format,
-          id: "remote:create-block-external",
-          isOfficialWorkspaceTemplate,
-          selectedVariant: normalizedSeed.selectedVariant ?? null,
-          supportsMigrationUi,
-          templateDir: normalized3.blockDir,
-          warnings: normalizedSeed.warnings ?? []
-        };
+        try {
+          const [projectType, defaultCategory] = await Promise.all([
+            getTemplateProjectTypeAsync(normalizedSeed.blockDir),
+            getDefaultCategoryAsync(normalizedSeed.blockDir)
+          ]);
+          const supportsMigrationUi = projectType === "workspace";
+          return {
+            cleanup: async () => {
+              await normalized3.cleanup?.();
+              await seed.cleanup?.();
+            },
+            defaultCategory,
+            description: "A wp-typia scaffold normalized from an official external template config",
+            features: [
+              "Remote source",
+              "official external template",
+              "wp-typia format",
+              ...supportsMigrationUi ? ["workspace-capable scaffold"] : []
+            ],
+            format,
+            id: "remote:create-block-external",
+            isOfficialWorkspaceTemplate,
+            selectedVariant: normalizedSeed.selectedVariant ?? null,
+            supportsMigrationUi,
+            templateDir: normalized3.blockDir,
+            warnings: normalizedSeed.warnings ?? []
+          };
+        } catch (error) {
+          await normalized3.cleanup?.();
+          throw error;
+        }
       }
       const normalized2 = await normalizeCreateBlockSubset(normalizedSeed, context);
       return {
@@ -12200,10 +12370,16 @@ function compareVersionFloors(left, right) {
   return 0;
 }
 function pickHigherVersionFloor(current, candidate) {
-  if (!candidate) {
+  if (current !== undefined) {
+    parseVersionFloorParts(current);
+  }
+  if (candidate !== undefined) {
+    parseVersionFloorParts(candidate);
+  }
+  if (candidate === undefined) {
     return current;
   }
-  if (!current) {
+  if (current === undefined) {
     return candidate;
   }
   return compareVersionFloors(current, candidate) >= 0 ? current : candidate;
@@ -12283,6 +12459,24 @@ function normalizeSelections(selections) {
   }
   return [...normalized.values()];
 }
+function validateFeatureMinimumVersions(definition) {
+  for (const [platform, value] of [
+    ["wordpress", definition.minimumVersions?.wordpress],
+    ["php", definition.minimumVersions?.php]
+  ]) {
+    if (value === undefined) {
+      continue;
+    }
+    try {
+      pickHigherVersionFloor(value, undefined);
+    } catch (error) {
+      throw new Error([
+        `Invalid ${platform} minimum version floor for AI feature "${definition.id}": "${value}".`,
+        'Expected dotted numeric segments such as "6.7" or "8.1.2".'
+      ].join(" "), { cause: error });
+    }
+  }
+}
 function resolveAiFeatureCapabilityPlan(selections, registry = DEFAULT_AI_FEATURE_REGISTRY) {
   const requiredFeatures = [];
   const optionalFeatures = [];
@@ -12293,6 +12487,7 @@ function resolveAiFeatureCapabilityPlan(selections, registry = DEFAULT_AI_FEATUR
     if (!definition) {
       throw new Error(`Unknown AI feature capability "${selection.featureId}".`);
     }
+    validateFeatureMinimumVersions(definition);
     const resolvedDefinition = {
       ...definition,
       mode: selection.mode
@@ -12340,17 +12535,44 @@ var REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY = [
 function pickHigherScaffoldVersionFloor(current, candidate) {
   return pickHigherVersionFloor(current, candidate) ?? current;
 }
-function pickHigherHeaderVersionFloor(policyValue, currentValue) {
+function pickHigherHeaderVersionFloor(policyValue, currentValue, {
+  headerName,
+  onWarning
+}) {
   const normalizedCurrentValue = currentValue.trim();
   if (!normalizedCurrentValue) {
     return policyValue;
   }
   try {
     return pickHigherScaffoldVersionFloor(policyValue, normalizedCurrentValue);
-  } catch {
+  } catch (error) {
+    const warning = [
+      `Invalid plugin header version floor for ${headerName}: "${normalizedCurrentValue}".`,
+      'Expected dotted numeric segments such as "6.7" or "8.1.2".',
+      `Replacing it with compatibility policy value "${policyValue}".`
+    ].join(" ");
+    if (!onWarning) {
+      throw new Error(warning, { cause: error });
+    }
+    onWarning(warning);
     return policyValue;
   }
 }
+function assertPolicyVersionFloor(headerName, value) {
+  try {
+    parseVersionFloorParts(value);
+  } catch (error) {
+    throw new Error([
+      `Invalid scaffold compatibility policy floor for ${headerName}: "${value}".`,
+      'Expected dotted numeric segments such as "6.7" or "8.1.2".'
+    ].join(" "), { cause: error });
+  }
+}
+function assertPluginHeaderPolicyVersionFloors(pluginHeader) {
+  assertPolicyVersionFloor("Requires at least", pluginHeader.requiresAtLeast);
+  assertPolicyVersionFloor("Tested up to", pluginHeader.testedUpTo);
+  assertPolicyVersionFloor("Requires PHP", pluginHeader.requiresPhp);
+}
 function formatRuntimeGate(feature) {
   return (feature.runtimeGates ?? []).map((gate) => `${feature.label}: ${gate.kind} ${gate.value}`);
 }
@@ -12400,17 +12622,21 @@ function renderScaffoldCompatibilityConfig(policy, indent = "\t\t") {
 `).map((line, index) => index === 0 ? line : `${indent}${line}`).join(`
 `);
 }
-function replacePluginHeaderVersionFloor(source, pattern, policyValue) {
+function replacePluginHeaderVersionFloor(source, pattern, policyValue, headerName, options) {
   return source.replace(pattern, (_match, prefix, currentValue, lineEnding) => {
     const versionPrefix = prefix.endsWith(":") ? `${prefix} ` : prefix;
-    return `${versionPrefix}${pickHigherHeaderVersionFloor(policyValue, currentValue)}${lineEnding}`;
+    return `${versionPrefix}${pickHigherHeaderVersionFloor(policyValue, currentValue, {
+      headerName,
+      onWarning: options.onWarning
+    })}${lineEnding}`;
   });
 }
-function updatePluginHeaderCompatibility(source, policy) {
+function updatePluginHeaderCompatibility(source, policy, options = {}) {
   const { pluginHeader } = policy;
-  const nextSource = replacePluginHeaderVersionFloor(source, /(\* Requires at least:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.requiresAtLeast);
-  const nextSourceWithTestedUpTo = replacePluginHeaderVersionFloor(nextSource, /(\* Tested up to:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.testedUpTo);
-  return replacePluginHeaderVersionFloor(nextSourceWithTestedUpTo, /(\* Requires PHP:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.requiresPhp);
+  assertPluginHeaderPolicyVersionFloors(pluginHeader);
+  const nextSource = replacePluginHeaderVersionFloor(source, /(\* Requires at least:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.requiresAtLeast, "Requires at least", options);
+  const nextSourceWithTestedUpTo = replacePluginHeaderVersionFloor(nextSource, /(\* Tested up to:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.testedUpTo, "Tested up to", options);
+  return replacePluginHeaderVersionFloor(nextSourceWithTestedUpTo, /(\* Requires PHP:[^\S\r\n]*)([^\r\n]*)(\r?)/u, pluginHeader.requiresPhp, "Requires PHP", options);
 }
 
 // ../wp-typia-project-tools/src/runtime/block-generator-service-spec.ts
@@ -17358,16 +17584,16 @@ async function scaffoldProject({
     title: "Finalizing scaffold output"
   });
   const readmePath = path18.join(projectDir, "README.md");
-  if (!fs15.existsSync(readmePath)) {
-    await fsp11.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
+  if (!fs12.existsSync(readmePath)) {
+    await fsp13.writeFile(readmePath, buildReadme(resolvedTemplateId, variables, resolvedPackageManager, {
       withMigrationUi: isBuiltInTemplate || isWorkspace ? withMigrationUi : false,
       withTestPreset: isBuiltInTemplate ? withTestPreset : false,
       withWpEnv: isBuiltInTemplate ? withWpEnv : false
     }), "utf8");
   }
   const gitignorePath = path18.join(projectDir, ".gitignore");
-  const existingGitignore = fs15.existsSync(gitignorePath) ? await fsp11.readFile(gitignorePath, "utf8") : "";
-  await fsp11.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
+  const existingGitignore = fs12.existsSync(gitignorePath) ? await fsp13.readFile(gitignorePath, "utf8") : "";
+  await fsp13.writeFile(gitignorePath, mergeTextLines(buildGitignore(), existingGitignore), "utf8");
   await normalizePackageJson(projectDir, resolvedPackageManager);
   if (isBuiltInTemplate) {
     const variableGroups = getScaffoldTemplateVariableGroups(variables);
@@ -17447,6 +17673,6 @@ async function resolveOptionalInteractiveExternalLayerId({
   }
 }
 
-export { syncPersistenceRestArtifacts, copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, getPrimaryDevelopmentScript, getOptionalOnboardingSteps, getOptionalOnboardingNote, getOptionalOnboardingShortNote, formatNonEmptyTargetDirectoryError, require_semver2 as require_semver, parseTemplateLocator, resolveExternalTemplateLayers, resolveTemplateSeed, normalizeOptionalCliString, resolveLocalCliPathOption, assertExternalLayerCompositionOptions, assertBuiltInTemplateVariantAllowed, parseAlternateRenderTargets, parseCompoundInnerBlocksPreset, OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY, REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, createScaffoldCompatibilityConfig, renderScaffoldCompatibilityConfig, updatePluginHeaderCompatibility, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
+export { syncPersistenceRestArtifacts, copyInterpolatedDirectory, listInterpolatedDirectoryOutputs, getPrimaryDevelopmentScript, getOptionalOnboardingSteps, getOptionalOnboardingNote, getOptionalOnboardingShortNote, pathExists, formatNonEmptyTargetDirectoryError, require_semver2 as require_semver, parseTemplateLocator, resolveExternalTemplateLayers, resolveTemplateSeed, normalizeOptionalCliString, resolveLocalCliPathOption, assertExternalLayerCompositionOptions, assertBuiltInTemplateVariantAllowed, parseAlternateRenderTargets, parseCompoundInnerBlocksPreset, OPTIONAL_WORDPRESS_AI_CLIENT_COMPATIBILITY, REQUIRED_WORKSPACE_ABILITY_COMPATIBILITY, resolveScaffoldCompatibilityPolicy, createScaffoldCompatibilityConfig, renderScaffoldCompatibilityConfig, updatePluginHeaderCompatibility, getDefaultAnswers, resolveTemplateId, resolvePackageManagerId, collectScaffoldAnswers, DATA_STORAGE_MODES, PERSISTENCE_POLICIES, isDataStorageMode, isPersistencePolicy, scaffoldProject, resolveOptionalInteractiveExternalLayerId };
 
-//# debugId=7E585E3F386D6E1964756E2164756E21
+//# debugId=7CCCC2F398FB931D64756E2164756E21